{"version":3,"file":"async-markdown.js","mappings":"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G,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,EAAE,EAAE,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,IAAI,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,IAAI,EAAE,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,KAAK,IAAI,KAAK,IAAI,EAAE,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,GAAG,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,KAAK,EAAE,IAAI,KAAK,IAAI,GAAG,EAAE,GAAG,EAAE,EAAE,IAAI,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,KAAK,GAAG,GAAG,EAAE,GAAG,EAAE,IAAI,GAAG,KAAK,IAAI,GAAG,GAAG,EAAE,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,KAAK,MAAM,GAAG,KAAK,GAAG,IAAI,EAAE,KAAK,GAAG,KAAK,KAAK,KAGpuCrC,EAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,IAAI,GAAG,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,GAAG,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAA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","sources":["webpack:///./src/fragments/Math.react.js","webpack:///./src/utils/MarkdownHighlighter.js","webpack:///./src/utils/LazyLoader/hljs.js","webpack:///./src/fragments/Markdown.react.js","webpack:///./node_modules/is-plain-obj/index.js","webpack:///react-jsx-parser/webpack/universalModuleDefinition","webpack:///react-jsx-parser/webpack/bootstrap","webpack:///react-jsx-parser/external \"react\"","webpack:///react-jsx-parser/node_modules/acorn/dist/acorn.mjs","webpack:///react-jsx-parser/node_modules/acorn-jsx/index.js","webpack:///react-jsx-parser/node_modules/acorn-jsx/xhtml.js","webpack:///react-jsx-parser/source/constants/attributeNames.js","webpack:///react-jsx-parser/source/constants/specialTags.js","webpack:///react-jsx-parser/source/helpers/hash.js","webpack:///react-jsx-parser/source/helpers/parseStyle.js","webpack:///react-jsx-parser/source/helpers/camelCase.js","webpack:///react-jsx-parser/source/helpers/resolvePath.js","webpack:///react-jsx-parser/source/components/JsxParser.js","webpack:///./node_modules/react-markdown/lib/ast-to-react.js","webpack:///./node_modules/react-markdown/lib/get-definitions.js","webpack:///./node_modules/react-markdown/lib/plugins/disallow-node.js","webpack:///./node_modules/react-markdown/lib/plugins/naive-html.js","webpack:///./node_modules/react-markdown/lib/react-markdown.js","webpack:///./node_modules/react-markdown/lib/renderers.js","webpack:///./node_modules/react-markdown/lib/symbols.js","webpack:///./node_modules/react-markdown/lib/uri-transformer.js","webpack:///./node_modules/react-markdown/lib/wrap-table-rows.js","webpack:///./node_modules/remark-math/block.js","webpack:///./node_modules/remark-math/index.js","webpack:///./node_modules/remark-math/inline.js","webpack:///./node_modules/remark-math/util.js","webpack:///./node_modules/bail/index.js","webpack:///./node_modules/collapse-white-space/index.js","webpack:///./node_modules/extend/index.js","webpack:///./node_modules/is-alphabetical/index.js","webpack:///./node_modules/is-alphanumerical/index.js","webpack:///./node_modules/is-buffer/index.js","webpack:///./node_modules/is-decimal/index.js","webpack:///./node_modules/is-hexadecimal/index.js","webpack:///./node_modules/is-whitespace-character/index.js","webpack:///./node_modules/is-word-character/index.js","webpack:///./node_modules/markdown-escapes/index.js","webpack:///./node_modules/mdast-add-list-metadata/index.js","webpack:///./node_modules/parse-entities/decode-entity.browser.js","webpack:///./node_modules/parse-entities/index.js","webpack:///./node_modules/path-browserify/index.js","webpack:///./node_modules/remark-parse/index.js","webpack:///./node_modules/remark-parse/lib/decode.js","webpack:///./node_modules/remark-parse/lib/defaults.js","webpack:///./node_modules/remark-parse/lib/locate/break.js","webpack:///./node_modules/remark-parse/lib/locate/code-inline.js","webpack:///./node_modules/remark-parse/lib/locate/delete.js","webpack:///./node_modules/remark-parse/lib/locate/emphasis.js","webpack:///./node_modules/remark-parse/lib/locate/escape.js","webpack:///./node_modules/remark-parse/lib/locate/link.js","webpack:///./node_modules/remark-parse/lib/locate/strong.js","webpack:///./node_modules/remark-parse/lib/locate/tag.js","webpack:///./node_modules/remark-parse/lib/locate/url.js","webpack:///./node_modules/remark-parse/lib/parse.js","webpack:///./node_modules/remark-parse/lib/parser.js","webpack:///./node_modules/remark-parse/lib/set-options.js","webpack:///./node_modules/remark-parse/lib/tokenize/auto-link.js","webpack:///./node_modules/remark-parse/lib/tokenize/blockquote.js","webpack:///./node_modules/remark-parse/lib/tokenize/break.js","webpack:///./node_modules/remark-parse/lib/tokenize/code-fenced.js","webpack:///./node_modules/remark-parse/lib/tokenize/code-indented.js","webpack:///./node_modules/remark-parse/lib/tokenize/code-inline.js","webpack:///./node_modules/remark-parse/lib/tokenize/definition.js","webpack:///./node_modules/remark-parse/lib/tokenize/delete.js","webpack:///./node_modules/remark-parse/lib/tokenize/emphasis.js","webpack:///./node_modules/remark-parse/lib/tokenize/escape.js","webpack:///./node_modules/remark-parse/lib/tokenize/footnote-definition.js","webpack:///./node_modules/remark-parse/lib/tokenize/heading-atx.js","webpack:///./node_modules/remark-parse/lib/tokenize/heading-setext.js","webpack:///./node_modules/remark-parse/lib/tokenize/html-block.js","webpack:///./node_modules/remark-parse/lib/tokenize/html-inline.js","webpack:///./node_modules/remark-parse/lib/tokenize/link.js","webpack:///./node_modules/remark-parse/lib/tokenize/list.js","webpack:///./node_modules/remark-parse/lib/tokenize/newline.js","webpack:///./node_modules/remark-parse/lib/tokenize/paragraph.js","webpack:///./node_modules/remark-parse/lib/tokenize/reference.js","webpack:///./node_modules/remark-parse/lib/tokenize/strong.js","webpack:///./node_modules/remark-parse/lib/tokenize/table.js","webpack:///./node_modules/remark-parse/lib/tokenize/text.js","webpack:///./node_modules/remark-parse/lib/tokenize/thematic-break.js","webpack:///./node_modules/remark-parse/lib/tokenize/url.js","webpack:///./node_modules/remark-parse/lib/tokenizer.js","webpack:///./node_modules/remark-parse/lib/unescape.js","webpack:///./node_modules/remark-parse/lib/util/get-indentation.js","webpack:///./node_modules/remark-parse/lib/util/html.js","webpack:///./node_modules/remark-parse/lib/util/interrupt.js","webpack:///./node_modules/remark-parse/lib/util/normalize.js","webpack:///./node_modules/remark-parse/lib/util/remove-indentation.js","webpack:///./node_modules/repeat-string/index.js","webpack:///./node_modules/replace-ext/index.js","webpack:///./node_modules/state-toggle/index.js","webpack:///./node_modules/trim-trailing-lines/index.js","webpack:///./node_modules/trim/index.js","webpack:///./node_modules/trough/index.js","webpack:///./node_modules/trough/wrap.js","webpack:///./node_modules/unherit/index.js","webpack:///./node_modules/unified/index.js","webpack:///./node_modules/unist-util-is/convert.js","webpack:///./node_modules/unist-util-remove-position/index.js","webpack:///./node_modules/unist-util-stringify-position/index.js","webpack:///./node_modules/unist-util-visit-parents/index.js","webpack:///./node_modules/unist-util-visit/index.js","webpack:///./node_modules/unist-util-visit/node_modules/unist-util-visit-parents/index.js","webpack:///./node_modules/vfile-location/index.js","webpack:///./node_modules/vfile-message/index.js","webpack:///./node_modules/vfile/core.js","webpack:///./node_modules/vfile/index.js","webpack:///./node_modules/x-is-string/index.js","webpack:///./node_modules/xtend/immutable.js"],"sourcesContent":["import PropTypes from 'prop-types';\nimport React, {Component} from 'react';\n\nimport lazyLoadMathJax from '../utils/LazyLoader/mathjax';\n\nexport default class DashMath extends Component {\n    constructor(props) {\n        super(props);\n        this.span_element = React.createRef();\n    }\n\n    componentDidMount() {\n        this.renderMath();\n    }\n\n    componentDidUpdate(prevProps) {\n        if (\n            prevProps.tex !== this.props.tex ||\n            prevProps.inline !== this.props.inline\n        ) {\n            this.renderMath();\n        }\n    }\n\n    renderMath() {\n        const current = this.span_element.current;\n        lazyLoadMathJax().then(function () {\n            window.MathJax.typeset([current]);\n        });\n    }\n\n    render() {\n        return (\n            <span ref={this.span_element}>\n                {this.props.inline ? '\\\\(' : '\\\\['}\n                {this.props.tex}\n                {this.props.inline ? '\\\\)' : '\\\\]'}\n            </span>\n        );\n    }\n}\n\nDashMath.propTypes = {\n    tex: PropTypes.string,\n    inline: PropTypes.bool,\n};\n\nDashMath.defaultProps = {\n    tex: '',\n    inline: true,\n};\n\nexport const propTypes = DashMath.propTypes;\nexport const defaultProps = DashMath.defaultProps;\n","import lazyhljs from './LazyLoader/hljs';\n\nconst MarkdownHighlighter = {\n    loadhljs: function () {\n        return lazyhljs().then(hljs => {\n            this.hljs = hljs;\n            this.hljsResolve();\n            this.isReady = true;\n        });\n    },\n};\n\nconst isReady = new Promise(resolve => {\n    MarkdownHighlighter.hljsResolve = resolve;\n});\n\nMarkdownHighlighter.isReady = isReady;\n\nexport default MarkdownHighlighter;\n","export default () => Promise.resolve(window.hljs ||\n    import(/* webpackChunkName: \"highlight\" */ '../../third-party/highlight.js').then(\n        result => result.default\n    ));\n","import React, {Component} from 'react';\nimport {mergeDeepRight, pick, type} from 'ramda';\nimport JsxParser from 'react-jsx-parser';\nimport Markdown from 'react-markdown';\nimport RemarkMath from 'remark-math';\n\nimport Math from './Math.react';\nimport MarkdownHighlighter from '../utils/MarkdownHighlighter';\nimport {propTypes, defaultProps} from '../components/Markdown.react';\n\nimport DccLink from './../components/Link.react';\n\nexport default class DashMarkdown extends Component {\n    constructor(props) {\n        super(props);\n\n        if (MarkdownHighlighter.isReady !== true) {\n            MarkdownHighlighter.isReady.then(() => {\n                this.setState({});\n            });\n        }\n        this.highlightCode = this.highlightCode.bind(this);\n        this.dedent = this.dedent.bind(this);\n    }\n\n    componentDidMount() {\n        this.highlightCode();\n    }\n\n    componentDidUpdate() {\n        this.highlightCode();\n    }\n\n    highlightCode() {\n        if (this.mdContainer) {\n            const nodes = this.mdContainer.querySelectorAll('pre code');\n\n            if (MarkdownHighlighter.hljs) {\n                for (let i = 0; i < nodes.length; i++) {\n                    MarkdownHighlighter.hljs.highlightElement(nodes[i]);\n                }\n            } else {\n                MarkdownHighlighter.loadhljs();\n            }\n        }\n    }\n\n    dedent(text) {\n        const lines = text.split(/\\r\\n|\\r|\\n/);\n        let commonPrefix = null;\n        for (const line of lines) {\n            const preMatch = line && line.match(/^\\s*(?=\\S)/);\n            if (preMatch) {\n                const prefix = preMatch[0];\n                if (commonPrefix !== null) {\n                    for (let i = 0; i < commonPrefix.length; i++) {\n                        // Like Python's textwrap.dedent, we'll remove both\n                        // space and tab characters, but only if they match\n                        if (prefix[i] !== commonPrefix[i]) {\n                            commonPrefix = commonPrefix.substr(0, i);\n                            break;\n                        }\n                    }\n                } else {\n                    commonPrefix = prefix;\n                }\n\n                if (!commonPrefix) {\n                    break;\n                }\n            }\n        }\n\n        const commonLen = commonPrefix ? commonPrefix.length : 0;\n        return lines\n            .map(line => {\n                return line.match(/\\S/) ? line.substr(commonLen) : '';\n            })\n            .join('\\n');\n    }\n\n    render() {\n        const {\n            id,\n            style,\n            className,\n            highlight_config,\n            loading_state,\n            dangerously_allow_html,\n            link_target,\n            mathjax,\n            children,\n            dedent,\n        } = this.props;\n\n        const textProp =\n            type(children) === 'Array' ? children.join('\\n') : children;\n        const displayText =\n            dedent && textProp ? this.dedent(textProp) : textProp;\n\n        const componentTransforms = {\n            dccLink: props => <DccLink {...props} />,\n            dccMarkdown: props => (\n                <Markdown\n                    {...mergeDeepRight(\n                        pick(['dangerously_allow_html', 'dedent'], this.props),\n                        pick(['children'], props)\n                    )}\n                />\n            ),\n            dashMathjax: props => (\n                <Math tex={props.value} inline={props.inline} />\n            ),\n        };\n\n        const regexMath = value => {\n            const newValue = value.replace(\n                /(\\${1,2})((?:\\\\.|[^$])+)\\1/g,\n                function (m, tag, src) {\n                    const inline = tag.length === 1 || src.indexOf('\\n') === -1;\n                    return `<dashMathjax value='${src}' inline='${inline}'/>`;\n                }\n            );\n            return newValue;\n        };\n\n        return (\n            <div\n                id={id}\n                ref={node => {\n                    this.mdContainer = node;\n                }}\n                style={style}\n                className={\n                    ((highlight_config && highlight_config.theme) ||\n                        className) &&\n                    `${className ? className : ''} ${\n                        highlight_config &&\n                        highlight_config.theme &&\n                        highlight_config.theme === 'dark'\n                            ? 'hljs-dark'\n                            : ''\n                    }`\n                }\n                data-dash-is-loading={\n                    (loading_state && loading_state.is_loading) || undefined\n                }\n            >\n                <Markdown\n                    source={displayText}\n                    escapeHtml={!dangerously_allow_html}\n                    linkTarget={link_target}\n                    plugins={mathjax ? [RemarkMath] : []}\n                    renderers={{\n                        math: props => (\n                            <Math tex={props.value} inline={false} />\n                        ),\n\n                        inlineMath: props => (\n                            <Math tex={props.value} inline={true} />\n                        ),\n\n                        html: props =>\n                            props.escapeHtml ? (\n                                props.value\n                            ) : (\n                                <JsxParser\n                                    jsx={\n                                        mathjax\n                                            ? regexMath(props.value)\n                                            : props.value\n                                    }\n                                    components={componentTransforms}\n                                    renderInWrapper={false}\n                                />\n                            ),\n                    }}\n                />\n            </div>\n        );\n    }\n}\n\nDashMarkdown.propTypes = propTypes;\nDashMarkdown.defaultProps = defaultProps;\n","'use strict';\nvar toString = Object.prototype.toString;\n\nmodule.exports = function (x) {\n\tvar prototype;\n\treturn toString.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));\n};\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"react\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"react-jsx-parser\", [\"react\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"react-jsx-parser\"] = factory(require(\"react\"));\n\telse\n\t\troot[\"react-jsx-parser\"] = factory(root[\"react\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE__0__) {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 4);\n","module.exports = __WEBPACK_EXTERNAL_MODULE__0__;","// Reserved word lists for various dialects of the language\n\nvar reservedWords = {\n  3: \"abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile\",\n  5: \"class enum extends super const export import\",\n  6: \"enum\",\n  strict: \"implements interface let package private protected public static yield\",\n  strictBind: \"eval arguments\"\n};\n\n// And the keywords\n\nvar ecma5AndLessKeywords = \"break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this\";\n\nvar keywords = {\n  5: ecma5AndLessKeywords,\n  \"5module\": ecma5AndLessKeywords + \" export import\",\n  6: ecma5AndLessKeywords + \" const class extends export import super\"\n};\n\nvar keywordRelationalOperator = /^in(stanceof)?$/;\n\n// ## Character categories\n\n// Big ugly regular expressions that match characters in the\n// whitespace, identifier, and identifier-start categories. These\n// are only applied when a character is found to actually have a\n// code point above 128.\n// Generated by `bin/generate-identifier-regex.js`.\nvar nonASCIIidentifierStartChars = \"\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u037f\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u052f\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086a\\u08a0-\\u08b4\\u08b6-\\u08bd\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u09fc\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0af9\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c39\\u0c3d\\u0c58-\\u0c5a\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d05-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e86-\\u0e8a\\u0e8c-\\u0ea3\\u0ea5\\u0ea7-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f5\\u13f8-\\u13fd\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f8\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c88\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf3\\u1cf5\\u1cf6\\u1cfa\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2118-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309b-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u31a0-\\u31ba\\u31f0-\\u31ff\\u3400-\\u4db5\\u4e00-\\u9fef\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7bf\\ua7c2-\\ua7c6\\ua7f7-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\ua9e0-\\ua9e4\\ua9e6-\\ua9ef\\ua9fa-\\ua9fe\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa7e-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uab30-\\uab5a\\uab5c-\\uab67\\uab70-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc\";\nvar nonASCIIidentifierChars = \"\\u200c\\u200d\\xb7\\u0300-\\u036f\\u0387\\u0483-\\u0487\\u0591-\\u05bd\\u05bf\\u05c1\\u05c2\\u05c4\\u05c5\\u05c7\\u0610-\\u061a\\u064b-\\u0669\\u0670\\u06d6-\\u06dc\\u06df-\\u06e4\\u06e7\\u06e8\\u06ea-\\u06ed\\u06f0-\\u06f9\\u0711\\u0730-\\u074a\\u07a6-\\u07b0\\u07c0-\\u07c9\\u07eb-\\u07f3\\u07fd\\u0816-\\u0819\\u081b-\\u0823\\u0825-\\u0827\\u0829-\\u082d\\u0859-\\u085b\\u08d3-\\u08e1\\u08e3-\\u0903\\u093a-\\u093c\\u093e-\\u094f\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096f\\u0981-\\u0983\\u09bc\\u09be-\\u09c4\\u09c7\\u09c8\\u09cb-\\u09cd\\u09d7\\u09e2\\u09e3\\u09e6-\\u09ef\\u09fe\\u0a01-\\u0a03\\u0a3c\\u0a3e-\\u0a42\\u0a47\\u0a48\\u0a4b-\\u0a4d\\u0a51\\u0a66-\\u0a71\\u0a75\\u0a81-\\u0a83\\u0abc\\u0abe-\\u0ac5\\u0ac7-\\u0ac9\\u0acb-\\u0acd\\u0ae2\\u0ae3\\u0ae6-\\u0aef\\u0afa-\\u0aff\\u0b01-\\u0b03\\u0b3c\\u0b3e-\\u0b44\\u0b47\\u0b48\\u0b4b-\\u0b4d\\u0b56\\u0b57\\u0b62\\u0b63\\u0b66-\\u0b6f\\u0b82\\u0bbe-\\u0bc2\\u0bc6-\\u0bc8\\u0bca-\\u0bcd\\u0bd7\\u0be6-\\u0bef\\u0c00-\\u0c04\\u0c3e-\\u0c44\\u0c46-\\u0c48\\u0c4a-\\u0c4d\\u0c55\\u0c56\\u0c62\\u0c63\\u0c66-\\u0c6f\\u0c81-\\u0c83\\u0cbc\\u0cbe-\\u0cc4\\u0cc6-\\u0cc8\\u0cca-\\u0ccd\\u0cd5\\u0cd6\\u0ce2\\u0ce3\\u0ce6-\\u0cef\\u0d00-\\u0d03\\u0d3b\\u0d3c\\u0d3e-\\u0d44\\u0d46-\\u0d48\\u0d4a-\\u0d4d\\u0d57\\u0d62\\u0d63\\u0d66-\\u0d6f\\u0d82\\u0d83\\u0dca\\u0dcf-\\u0dd4\\u0dd6\\u0dd8-\\u0ddf\\u0de6-\\u0def\\u0df2\\u0df3\\u0e31\\u0e34-\\u0e3a\\u0e47-\\u0e4e\\u0e50-\\u0e59\\u0eb1\\u0eb4-\\u0ebc\\u0ec8-\\u0ecd\\u0ed0-\\u0ed9\\u0f18\\u0f19\\u0f20-\\u0f29\\u0f35\\u0f37\\u0f39\\u0f3e\\u0f3f\\u0f71-\\u0f84\\u0f86\\u0f87\\u0f8d-\\u0f97\\u0f99-\\u0fbc\\u0fc6\\u102b-\\u103e\\u1040-\\u1049\\u1056-\\u1059\\u105e-\\u1060\\u1062-\\u1064\\u1067-\\u106d\\u1071-\\u1074\\u1082-\\u108d\\u108f-\\u109d\\u135d-\\u135f\\u1369-\\u1371\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17b4-\\u17d3\\u17dd\\u17e0-\\u17e9\\u180b-\\u180d\\u1810-\\u1819\\u18a9\\u1920-\\u192b\\u1930-\\u193b\\u1946-\\u194f\\u19d0-\\u19da\\u1a17-\\u1a1b\\u1a55-\\u1a5e\\u1a60-\\u1a7c\\u1a7f-\\u1a89\\u1a90-\\u1a99\\u1ab0-\\u1abd\\u1b00-\\u1b04\\u1b34-\\u1b44\\u1b50-\\u1b59\\u1b6b-\\u1b73\\u1b80-\\u1b82\\u1ba1-\\u1bad\\u1bb0-\\u1bb9\\u1be6-\\u1bf3\\u1c24-\\u1c37\\u1c40-\\u1c49\\u1c50-\\u1c59\\u1cd0-\\u1cd2\\u1cd4-\\u1ce8\\u1ced\\u1cf4\\u1cf7-\\u1cf9\\u1dc0-\\u1df9\\u1dfb-\\u1dff\\u203f\\u2040\\u2054\\u20d0-\\u20dc\\u20e1\\u20e5-\\u20f0\\u2cef-\\u2cf1\\u2d7f\\u2de0-\\u2dff\\u302a-\\u302f\\u3099\\u309a\\ua620-\\ua629\\ua66f\\ua674-\\ua67d\\ua69e\\ua69f\\ua6f0\\ua6f1\\ua802\\ua806\\ua80b\\ua823-\\ua827\\ua880\\ua881\\ua8b4-\\ua8c5\\ua8d0-\\ua8d9\\ua8e0-\\ua8f1\\ua8ff-\\ua909\\ua926-\\ua92d\\ua947-\\ua953\\ua980-\\ua983\\ua9b3-\\ua9c0\\ua9d0-\\ua9d9\\ua9e5\\ua9f0-\\ua9f9\\uaa29-\\uaa36\\uaa43\\uaa4c\\uaa4d\\uaa50-\\uaa59\\uaa7b-\\uaa7d\\uaab0\\uaab2-\\uaab4\\uaab7\\uaab8\\uaabe\\uaabf\\uaac1\\uaaeb-\\uaaef\\uaaf5\\uaaf6\\uabe3-\\uabea\\uabec\\uabed\\uabf0-\\uabf9\\ufb1e\\ufe00-\\ufe0f\\ufe20-\\ufe2f\\ufe33\\ufe34\\ufe4d-\\ufe4f\\uff10-\\uff19\\uff3f\";\n\nvar nonASCIIidentifierStart = new RegExp(\"[\" + nonASCIIidentifierStartChars + \"]\");\nvar nonASCIIidentifier = new RegExp(\"[\" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + \"]\");\n\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null;\n\n// These are a run-length and offset encoded representation of the\n// >0xffff code points that are a valid part of identifiers. The\n// offset starts at 0x10000, and each pair of numbers represents an\n// offset to the next range, and then a size of the range. They were\n// generated by bin/generate-identifier-regex.js\n\n// eslint-disable-next-line comma-spacing\nvar astralIdentifierStartCodes = [0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,155,22,13,52,76,44,33,24,27,35,30,0,12,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,0,33,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,230,43,117,63,32,0,161,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,754,9486,286,50,2,18,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,2357,44,11,6,17,0,370,43,1301,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,15,7472,3104,541];\n\n// eslint-disable-next-line comma-spacing\nvar astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,232,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1014,0,2,54,8,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,262,6,10,9,419,13,1495,6,110,6,6,9,792487,239];\n\n// This has a complexity linear to the value of the code. The\n// assumption is that looking up astral identifier characters is\n// rare.\nfunction isInAstralSet(code, set) {\n  var pos = 0x10000;\n  for (var i = 0; i < set.length; i += 2) {\n    pos += set[i];\n    if (pos > code) { return false }\n    pos += set[i + 1];\n    if (pos >= code) { return true }\n  }\n}\n\n// Test whether a given character code starts an identifier.\n\nfunction isIdentifierStart(code, astral) {\n  if (code < 65) { return code === 36 }\n  if (code < 91) { return true }\n  if (code < 97) { return code === 95 }\n  if (code < 123) { return true }\n  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) }\n  if (astral === false) { return false }\n  return isInAstralSet(code, astralIdentifierStartCodes)\n}\n\n// Test whether a given character is part of an identifier.\n\nfunction isIdentifierChar(code, astral) {\n  if (code < 48) { return code === 36 }\n  if (code < 58) { return true }\n  if (code < 65) { return false }\n  if (code < 91) { return true }\n  if (code < 97) { return code === 95 }\n  if (code < 123) { return true }\n  if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) }\n  if (astral === false) { return false }\n  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes)\n}\n\n// ## Token types\n\n// The assignment of fine-grained, information-carrying type objects\n// allows the tokenizer to store the information it has about a\n// token in a way that is very cheap for the parser to look up.\n\n// All token type variables start with an underscore, to make them\n// easy to recognize.\n\n// The `beforeExpr` property is used to disambiguate between regular\n// expressions and divisions. It is set on all token types that can\n// be followed by an expression (thus, a slash after them would be a\n// regular expression).\n//\n// The `startsExpr` property is used to check if the token ends a\n// `yield` expression. It is set on all token types that either can\n// directly start an expression (like a quotation mark) or can\n// continue an expression (like the body of a string).\n//\n// `isLoop` marks a keyword as starting a loop, which is important\n// to know when parsing a label, in order to allow or disallow\n// continue jumps to that label.\n\nvar TokenType = function TokenType(label, conf) {\n  if ( conf === void 0 ) conf = {};\n\n  this.label = label;\n  this.keyword = conf.keyword;\n  this.beforeExpr = !!conf.beforeExpr;\n  this.startsExpr = !!conf.startsExpr;\n  this.isLoop = !!conf.isLoop;\n  this.isAssign = !!conf.isAssign;\n  this.prefix = !!conf.prefix;\n  this.postfix = !!conf.postfix;\n  this.binop = conf.binop || null;\n  this.updateContext = null;\n};\n\nfunction binop(name, prec) {\n  return new TokenType(name, {beforeExpr: true, binop: prec})\n}\nvar beforeExpr = {beforeExpr: true}, startsExpr = {startsExpr: true};\n\n// Map keyword names to token types.\n\nvar keywords$1 = {};\n\n// Succinct definitions of keyword token types\nfunction kw(name, options) {\n  if ( options === void 0 ) options = {};\n\n  options.keyword = name;\n  return keywords$1[name] = new TokenType(name, options)\n}\n\nvar types = {\n  num: new TokenType(\"num\", startsExpr),\n  regexp: new TokenType(\"regexp\", startsExpr),\n  string: new TokenType(\"string\", startsExpr),\n  name: new TokenType(\"name\", startsExpr),\n  eof: new TokenType(\"eof\"),\n\n  // Punctuation token types.\n  bracketL: new TokenType(\"[\", {beforeExpr: true, startsExpr: true}),\n  bracketR: new TokenType(\"]\"),\n  braceL: new TokenType(\"{\", {beforeExpr: true, startsExpr: true}),\n  braceR: new TokenType(\"}\"),\n  parenL: new TokenType(\"(\", {beforeExpr: true, startsExpr: true}),\n  parenR: new TokenType(\")\"),\n  comma: new TokenType(\",\", beforeExpr),\n  semi: new TokenType(\";\", beforeExpr),\n  colon: new TokenType(\":\", beforeExpr),\n  dot: new TokenType(\".\"),\n  question: new TokenType(\"?\", beforeExpr),\n  arrow: new TokenType(\"=>\", beforeExpr),\n  template: new TokenType(\"template\"),\n  invalidTemplate: new TokenType(\"invalidTemplate\"),\n  ellipsis: new TokenType(\"...\", beforeExpr),\n  backQuote: new TokenType(\"`\", startsExpr),\n  dollarBraceL: new TokenType(\"${\", {beforeExpr: true, startsExpr: true}),\n\n  // Operators. These carry several kinds of properties to help the\n  // parser use them properly (the presence of these properties is\n  // what categorizes them as operators).\n  //\n  // `binop`, when present, specifies that this operator is a binary\n  // operator, and will refer to its precedence.\n  //\n  // `prefix` and `postfix` mark the operator as a prefix or postfix\n  // unary operator.\n  //\n  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as\n  // binary operators with a very low precedence, that should result\n  // in AssignmentExpression nodes.\n\n  eq: new TokenType(\"=\", {beforeExpr: true, isAssign: true}),\n  assign: new TokenType(\"_=\", {beforeExpr: true, isAssign: true}),\n  incDec: new TokenType(\"++/--\", {prefix: true, postfix: true, startsExpr: true}),\n  prefix: new TokenType(\"!/~\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  logicalOR: binop(\"||\", 1),\n  logicalAND: binop(\"&&\", 2),\n  bitwiseOR: binop(\"|\", 3),\n  bitwiseXOR: binop(\"^\", 4),\n  bitwiseAND: binop(\"&\", 5),\n  equality: binop(\"==/!=/===/!==\", 6),\n  relational: binop(\"</>/<=/>=\", 7),\n  bitShift: binop(\"<</>>/>>>\", 8),\n  plusMin: new TokenType(\"+/-\", {beforeExpr: true, binop: 9, prefix: true, startsExpr: true}),\n  modulo: binop(\"%\", 10),\n  star: binop(\"*\", 10),\n  slash: binop(\"/\", 10),\n  starstar: new TokenType(\"**\", {beforeExpr: true}),\n\n  // Keyword token types.\n  _break: kw(\"break\"),\n  _case: kw(\"case\", beforeExpr),\n  _catch: kw(\"catch\"),\n  _continue: kw(\"continue\"),\n  _debugger: kw(\"debugger\"),\n  _default: kw(\"default\", beforeExpr),\n  _do: kw(\"do\", {isLoop: true, beforeExpr: true}),\n  _else: kw(\"else\", beforeExpr),\n  _finally: kw(\"finally\"),\n  _for: kw(\"for\", {isLoop: true}),\n  _function: kw(\"function\", startsExpr),\n  _if: kw(\"if\"),\n  _return: kw(\"return\", beforeExpr),\n  _switch: kw(\"switch\"),\n  _throw: kw(\"throw\", beforeExpr),\n  _try: kw(\"try\"),\n  _var: kw(\"var\"),\n  _const: kw(\"const\"),\n  _while: kw(\"while\", {isLoop: true}),\n  _with: kw(\"with\"),\n  _new: kw(\"new\", {beforeExpr: true, startsExpr: true}),\n  _this: kw(\"this\", startsExpr),\n  _super: kw(\"super\", startsExpr),\n  _class: kw(\"class\", startsExpr),\n  _extends: kw(\"extends\", beforeExpr),\n  _export: kw(\"export\"),\n  _import: kw(\"import\", startsExpr),\n  _null: kw(\"null\", startsExpr),\n  _true: kw(\"true\", startsExpr),\n  _false: kw(\"false\", startsExpr),\n  _in: kw(\"in\", {beforeExpr: true, binop: 7}),\n  _instanceof: kw(\"instanceof\", {beforeExpr: true, binop: 7}),\n  _typeof: kw(\"typeof\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  _void: kw(\"void\", {beforeExpr: true, prefix: true, startsExpr: true}),\n  _delete: kw(\"delete\", {beforeExpr: true, prefix: true, startsExpr: true})\n};\n\n// Matches a whole line break (where CRLF is considered a single\n// line break). Used to count lines.\n\nvar lineBreak = /\\r\\n?|\\n|\\u2028|\\u2029/;\nvar lineBreakG = new RegExp(lineBreak.source, \"g\");\n\nfunction isNewLine(code, ecma2019String) {\n  return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))\n}\n\nvar nonASCIIwhitespace = /[\\u1680\\u2000-\\u200a\\u202f\\u205f\\u3000\\ufeff]/;\n\nvar skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g;\n\nvar ref = Object.prototype;\nvar hasOwnProperty = ref.hasOwnProperty;\nvar toString = ref.toString;\n\n// Checks if an object has a property.\n\nfunction has(obj, propName) {\n  return hasOwnProperty.call(obj, propName)\n}\n\nvar isArray = Array.isArray || (function (obj) { return (\n  toString.call(obj) === \"[object Array]\"\n); });\n\nfunction wordsRegexp(words) {\n  return new RegExp(\"^(?:\" + words.replace(/ /g, \"|\") + \")$\")\n}\n\n// These are used when `options.locations` is on, for the\n// `startLoc` and `endLoc` properties.\n\nvar Position = function Position(line, col) {\n  this.line = line;\n  this.column = col;\n};\n\nPosition.prototype.offset = function offset (n) {\n  return new Position(this.line, this.column + n)\n};\n\nvar SourceLocation = function SourceLocation(p, start, end) {\n  this.start = start;\n  this.end = end;\n  if (p.sourceFile !== null) { this.source = p.sourceFile; }\n};\n\n// The `getLineInfo` function is mostly useful when the\n// `locations` option is off (for performance reasons) and you\n// want to find the line/column position for a given character\n// offset. `input` should be the code string that the offset refers\n// into.\n\nfunction getLineInfo(input, offset) {\n  for (var line = 1, cur = 0;;) {\n    lineBreakG.lastIndex = cur;\n    var match = lineBreakG.exec(input);\n    if (match && match.index < offset) {\n      ++line;\n      cur = match.index + match[0].length;\n    } else {\n      return new Position(line, offset - cur)\n    }\n  }\n}\n\n// A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\nvar defaultOptions = {\n  // `ecmaVersion` indicates the ECMAScript version to parse. Must be\n  // either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10\n  // (2019). This influences support for strict mode, the set of\n  // reserved words, and support for new syntax features. The default\n  // is 10.\n  ecmaVersion: 10,\n  // `sourceType` indicates the mode the code should be parsed in.\n  // Can be either `\"script\"` or `\"module\"`. This influences global\n  // strict mode and parsing of `import` and `export` declarations.\n  sourceType: \"script\",\n  // `onInsertedSemicolon` can be a callback that will be called\n  // when a semicolon is automatically inserted. It will be passed\n  // the position of the comma as an offset, and if `locations` is\n  // enabled, it is given the location as a `{line, column}` object\n  // as second argument.\n  onInsertedSemicolon: null,\n  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for\n  // trailing commas.\n  onTrailingComma: null,\n  // By default, reserved words are only enforced if ecmaVersion >= 5.\n  // Set `allowReserved` to a boolean value to explicitly turn this on\n  // an off. When this option has the value \"never\", reserved words\n  // and keywords can also not be used as property names.\n  allowReserved: null,\n  // When enabled, a return at the top level is not considered an\n  // error.\n  allowReturnOutsideFunction: false,\n  // When enabled, import/export statements are not constrained to\n  // appearing at the top of the program.\n  allowImportExportEverywhere: false,\n  // When enabled, await identifiers are allowed to appear at the top-level scope,\n  // but they are still not allowed in non-async functions.\n  allowAwaitOutsideFunction: false,\n  // When enabled, hashbang directive in the beginning of file\n  // is allowed and treated as a line comment.\n  allowHashBang: false,\n  // When `locations` is on, `loc` properties holding objects with\n  // `start` and `end` properties in `{line, column}` form (with\n  // line being 1-based and column 0-based) will be attached to the\n  // nodes.\n  locations: false,\n  // A function can be passed as `onToken` option, which will\n  // cause Acorn to call that function with object in the same\n  // format as tokens returned from `tokenizer().getToken()`. Note\n  // that you are not allowed to call the parser from the\n  // callback—that will corrupt its internal state.\n  onToken: null,\n  // A function can be passed as `onComment` option, which will\n  // cause Acorn to call that function with `(block, text, start,\n  // end)` parameters whenever a comment is skipped. `block` is a\n  // boolean indicating whether this is a block (`/* */`) comment,\n  // `text` is the content of the comment, and `start` and `end` are\n  // character offsets that denote the start and end of the comment.\n  // When the `locations` option is on, two more parameters are\n  // passed, the full `{line, column}` locations of the start and\n  // end of the comments. Note that you are not allowed to call the\n  // parser from the callback—that will corrupt its internal state.\n  onComment: null,\n  // Nodes have their start and end characters offsets recorded in\n  // `start` and `end` properties (directly on the node, rather than\n  // the `loc` object, which holds line/column data. To also add a\n  // [semi-standardized][range] `range` property holding a `[start,\n  // end]` array with the same numbers, set the `ranges` option to\n  // `true`.\n  //\n  // [range]: https://bugzilla.mozilla.org/show_bug.cgi?id=745678\n  ranges: false,\n  // It is possible to parse multiple files into a single AST by\n  // passing the tree produced by parsing the first file as\n  // `program` option in subsequent parses. This will add the\n  // toplevel forms of the parsed file to the `Program` (top) node\n  // of an existing parse tree.\n  program: null,\n  // When `locations` is on, you can pass this to record the source\n  // file in every node's `loc` object.\n  sourceFile: null,\n  // This value, if given, is stored in every node, whether\n  // `locations` is on or off.\n  directSourceFile: null,\n  // When enabled, parenthesized expressions are represented by\n  // (non-standard) ParenthesizedExpression nodes\n  preserveParens: false\n};\n\n// Interpret and default an options object\n\nfunction getOptions(opts) {\n  var options = {};\n\n  for (var opt in defaultOptions)\n    { options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]; }\n\n  if (options.ecmaVersion >= 2015)\n    { options.ecmaVersion -= 2009; }\n\n  if (options.allowReserved == null)\n    { options.allowReserved = options.ecmaVersion < 5; }\n\n  if (isArray(options.onToken)) {\n    var tokens = options.onToken;\n    options.onToken = function (token) { return tokens.push(token); };\n  }\n  if (isArray(options.onComment))\n    { options.onComment = pushComment(options, options.onComment); }\n\n  return options\n}\n\nfunction pushComment(options, array) {\n  return function(block, text, start, end, startLoc, endLoc) {\n    var comment = {\n      type: block ? \"Block\" : \"Line\",\n      value: text,\n      start: start,\n      end: end\n    };\n    if (options.locations)\n      { comment.loc = new SourceLocation(this, startLoc, endLoc); }\n    if (options.ranges)\n      { comment.range = [start, end]; }\n    array.push(comment);\n  }\n}\n\n// Each scope gets a bitset that may contain these flags\nvar\n    SCOPE_TOP = 1,\n    SCOPE_FUNCTION = 2,\n    SCOPE_VAR = SCOPE_TOP | SCOPE_FUNCTION,\n    SCOPE_ASYNC = 4,\n    SCOPE_GENERATOR = 8,\n    SCOPE_ARROW = 16,\n    SCOPE_SIMPLE_CATCH = 32,\n    SCOPE_SUPER = 64,\n    SCOPE_DIRECT_SUPER = 128;\n\nfunction functionFlags(async, generator) {\n  return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0)\n}\n\n// Used in checkLVal and declareName to determine the type of a binding\nvar\n    BIND_NONE = 0, // Not a binding\n    BIND_VAR = 1, // Var-style binding\n    BIND_LEXICAL = 2, // Let- or const-style binding\n    BIND_FUNCTION = 3, // Function declaration\n    BIND_SIMPLE_CATCH = 4, // Simple (identifier pattern) catch binding\n    BIND_OUTSIDE = 5; // Special case for function names as bound inside the function\n\nvar Parser = function Parser(options, input, startPos) {\n  this.options = options = getOptions(options);\n  this.sourceFile = options.sourceFile;\n  this.keywords = wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : options.sourceType === \"module\" ? \"5module\" : 5]);\n  var reserved = \"\";\n  if (options.allowReserved !== true) {\n    for (var v = options.ecmaVersion;; v--)\n      { if (reserved = reservedWords[v]) { break } }\n    if (options.sourceType === \"module\") { reserved += \" await\"; }\n  }\n  this.reservedWords = wordsRegexp(reserved);\n  var reservedStrict = (reserved ? reserved + \" \" : \"\") + reservedWords.strict;\n  this.reservedWordsStrict = wordsRegexp(reservedStrict);\n  this.reservedWordsStrictBind = wordsRegexp(reservedStrict + \" \" + reservedWords.strictBind);\n  this.input = String(input);\n\n  // Used to signal to callers of `readWord1` whether the word\n  // contained any escape sequences. This is needed because words with\n  // escape sequences must not be interpreted as keywords.\n  this.containsEsc = false;\n\n  // Set up token state\n\n  // The current position of the tokenizer in the input.\n  if (startPos) {\n    this.pos = startPos;\n    this.lineStart = this.input.lastIndexOf(\"\\n\", startPos - 1) + 1;\n    this.curLine = this.input.slice(0, this.lineStart).split(lineBreak).length;\n  } else {\n    this.pos = this.lineStart = 0;\n    this.curLine = 1;\n  }\n\n  // Properties of the current token:\n  // Its type\n  this.type = types.eof;\n  // For tokens that include more information than their type, the value\n  this.value = null;\n  // Its start and end offset\n  this.start = this.end = this.pos;\n  // And, if locations are used, the {line, column} object\n  // corresponding to those offsets\n  this.startLoc = this.endLoc = this.curPosition();\n\n  // Position information for the previous token\n  this.lastTokEndLoc = this.lastTokStartLoc = null;\n  this.lastTokStart = this.lastTokEnd = this.pos;\n\n  // The context stack is used to superficially track syntactic\n  // context to predict whether a regular expression is allowed in a\n  // given position.\n  this.context = this.initialContext();\n  this.exprAllowed = true;\n\n  // Figure out if it's a module code.\n  this.inModule = options.sourceType === \"module\";\n  this.strict = this.inModule || this.strictDirective(this.pos);\n\n  // Used to signify the start of a potential arrow function\n  this.potentialArrowAt = -1;\n\n  // Positions to delayed-check that yield/await does not exist in default parameters.\n  this.yieldPos = this.awaitPos = this.awaitIdentPos = 0;\n  // Labels in scope.\n  this.labels = [];\n  // Thus-far undefined exports.\n  this.undefinedExports = {};\n\n  // If enabled, skip leading hashbang line.\n  if (this.pos === 0 && options.allowHashBang && this.input.slice(0, 2) === \"#!\")\n    { this.skipLineComment(2); }\n\n  // Scope tracking for duplicate variable names (see scope.js)\n  this.scopeStack = [];\n  this.enterScope(SCOPE_TOP);\n\n  // For RegExp validation\n  this.regexpState = null;\n};\n\nvar prototypeAccessors = { inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true } };\n\nParser.prototype.parse = function parse () {\n  var node = this.options.program || this.startNode();\n  this.nextToken();\n  return this.parseTopLevel(node)\n};\n\nprototypeAccessors.inFunction.get = function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };\nprototypeAccessors.inGenerator.get = function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 };\nprototypeAccessors.inAsync.get = function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 };\nprototypeAccessors.allowSuper.get = function () { return (this.currentThisScope().flags & SCOPE_SUPER) > 0 };\nprototypeAccessors.allowDirectSuper.get = function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };\nprototypeAccessors.treatFunctionsAsVar.get = function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };\n\n// Switch to a getter for 7.0.0.\nParser.prototype.inNonArrowFunction = function inNonArrowFunction () { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 };\n\nParser.extend = function extend () {\n    var plugins = [], len = arguments.length;\n    while ( len-- ) plugins[ len ] = arguments[ len ];\n\n  var cls = this;\n  for (var i = 0; i < plugins.length; i++) { cls = plugins[i](cls); }\n  return cls\n};\n\nParser.parse = function parse (input, options) {\n  return new this(options, input).parse()\n};\n\nParser.parseExpressionAt = function parseExpressionAt (input, pos, options) {\n  var parser = new this(options, input, pos);\n  parser.nextToken();\n  return parser.parseExpression()\n};\n\nParser.tokenizer = function tokenizer (input, options) {\n  return new this(options, input)\n};\n\nObject.defineProperties( Parser.prototype, prototypeAccessors );\n\nvar pp = Parser.prototype;\n\n// ## Parser utilities\n\nvar literal = /^(?:'((?:\\\\.|[^'])*?)'|\"((?:\\\\.|[^\"])*?)\")/;\npp.strictDirective = function(start) {\n  for (;;) {\n    // Try to find string literal.\n    skipWhiteSpace.lastIndex = start;\n    start += skipWhiteSpace.exec(this.input)[0].length;\n    var match = literal.exec(this.input.slice(start));\n    if (!match) { return false }\n    if ((match[1] || match[2]) === \"use strict\") { return true }\n    start += match[0].length;\n\n    // Skip semicolon, if any.\n    skipWhiteSpace.lastIndex = start;\n    start += skipWhiteSpace.exec(this.input)[0].length;\n    if (this.input[start] === \";\")\n      { start++; }\n  }\n};\n\n// Predicate that tests whether the next token is of the given\n// type, and if yes, consumes it as a side effect.\n\npp.eat = function(type) {\n  if (this.type === type) {\n    this.next();\n    return true\n  } else {\n    return false\n  }\n};\n\n// Tests whether parsed token is a contextual keyword.\n\npp.isContextual = function(name) {\n  return this.type === types.name && this.value === name && !this.containsEsc\n};\n\n// Consumes contextual keyword if possible.\n\npp.eatContextual = function(name) {\n  if (!this.isContextual(name)) { return false }\n  this.next();\n  return true\n};\n\n// Asserts that following token is given contextual keyword.\n\npp.expectContextual = function(name) {\n  if (!this.eatContextual(name)) { this.unexpected(); }\n};\n\n// Test whether a semicolon can be inserted at the current position.\n\npp.canInsertSemicolon = function() {\n  return this.type === types.eof ||\n    this.type === types.braceR ||\n    lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n};\n\npp.insertSemicolon = function() {\n  if (this.canInsertSemicolon()) {\n    if (this.options.onInsertedSemicolon)\n      { this.options.onInsertedSemicolon(this.lastTokEnd, this.lastTokEndLoc); }\n    return true\n  }\n};\n\n// Consume a semicolon, or, failing that, see if we are allowed to\n// pretend that there is a semicolon at this position.\n\npp.semicolon = function() {\n  if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }\n};\n\npp.afterTrailingComma = function(tokType, notNext) {\n  if (this.type === tokType) {\n    if (this.options.onTrailingComma)\n      { this.options.onTrailingComma(this.lastTokStart, this.lastTokStartLoc); }\n    if (!notNext)\n      { this.next(); }\n    return true\n  }\n};\n\n// Expect a token of a given type. If found, consume it, otherwise,\n// raise an unexpected token error.\n\npp.expect = function(type) {\n  this.eat(type) || this.unexpected();\n};\n\n// Raise an unexpected token error.\n\npp.unexpected = function(pos) {\n  this.raise(pos != null ? pos : this.start, \"Unexpected token\");\n};\n\nfunction DestructuringErrors() {\n  this.shorthandAssign =\n  this.trailingComma =\n  this.parenthesizedAssign =\n  this.parenthesizedBind =\n  this.doubleProto =\n    -1;\n}\n\npp.checkPatternErrors = function(refDestructuringErrors, isAssign) {\n  if (!refDestructuringErrors) { return }\n  if (refDestructuringErrors.trailingComma > -1)\n    { this.raiseRecoverable(refDestructuringErrors.trailingComma, \"Comma is not permitted after the rest element\"); }\n  var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;\n  if (parens > -1) { this.raiseRecoverable(parens, \"Parenthesized pattern\"); }\n};\n\npp.checkExpressionErrors = function(refDestructuringErrors, andThrow) {\n  if (!refDestructuringErrors) { return false }\n  var shorthandAssign = refDestructuringErrors.shorthandAssign;\n  var doubleProto = refDestructuringErrors.doubleProto;\n  if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 }\n  if (shorthandAssign >= 0)\n    { this.raise(shorthandAssign, \"Shorthand property assignments are valid only in destructuring patterns\"); }\n  if (doubleProto >= 0)\n    { this.raiseRecoverable(doubleProto, \"Redefinition of __proto__ property\"); }\n};\n\npp.checkYieldAwaitInDefaultParams = function() {\n  if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))\n    { this.raise(this.yieldPos, \"Yield expression cannot be a default value\"); }\n  if (this.awaitPos)\n    { this.raise(this.awaitPos, \"Await expression cannot be a default value\"); }\n};\n\npp.isSimpleAssignTarget = function(expr) {\n  if (expr.type === \"ParenthesizedExpression\")\n    { return this.isSimpleAssignTarget(expr.expression) }\n  return expr.type === \"Identifier\" || expr.type === \"MemberExpression\"\n};\n\nvar pp$1 = Parser.prototype;\n\n// ### Statement parsing\n\n// Parse a program. Initializes the parser, reads any number of\n// statements, and wraps them in a Program node.  Optionally takes a\n// `program` argument.  If present, the statements will be appended\n// to its body instead of creating a new node.\n\npp$1.parseTopLevel = function(node) {\n  var exports = {};\n  if (!node.body) { node.body = []; }\n  while (this.type !== types.eof) {\n    var stmt = this.parseStatement(null, true, exports);\n    node.body.push(stmt);\n  }\n  if (this.inModule)\n    { for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1)\n      {\n        var name = list[i];\n\n        this.raiseRecoverable(this.undefinedExports[name].start, (\"Export '\" + name + \"' is not defined\"));\n      } }\n  this.adaptDirectivePrologue(node.body);\n  this.next();\n  node.sourceType = this.options.sourceType;\n  return this.finishNode(node, \"Program\")\n};\n\nvar loopLabel = {kind: \"loop\"}, switchLabel = {kind: \"switch\"};\n\npp$1.isLet = function(context) {\n  if (this.options.ecmaVersion < 6 || !this.isContextual(\"let\")) { return false }\n  skipWhiteSpace.lastIndex = this.pos;\n  var skip = skipWhiteSpace.exec(this.input);\n  var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);\n  // For ambiguous cases, determine if a LexicalDeclaration (or only a\n  // Statement) is allowed here. If context is not empty then only a Statement\n  // is allowed. However, `let [` is an explicit negative lookahead for\n  // ExpressionStatement, so special-case it first.\n  if (nextCh === 91) { return true } // '['\n  if (context) { return false }\n\n  if (nextCh === 123) { return true } // '{'\n  if (isIdentifierStart(nextCh, true)) {\n    var pos = next + 1;\n    while (isIdentifierChar(this.input.charCodeAt(pos), true)) { ++pos; }\n    var ident = this.input.slice(next, pos);\n    if (!keywordRelationalOperator.test(ident)) { return true }\n  }\n  return false\n};\n\n// check 'async [no LineTerminator here] function'\n// - 'async /*foo*/ function' is OK.\n// - 'async /*\\n*/ function' is invalid.\npp$1.isAsyncFunction = function() {\n  if (this.options.ecmaVersion < 8 || !this.isContextual(\"async\"))\n    { return false }\n\n  skipWhiteSpace.lastIndex = this.pos;\n  var skip = skipWhiteSpace.exec(this.input);\n  var next = this.pos + skip[0].length;\n  return !lineBreak.test(this.input.slice(this.pos, next)) &&\n    this.input.slice(next, next + 8) === \"function\" &&\n    (next + 8 === this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))\n};\n\n// Parse a single statement.\n//\n// If expecting a statement and finding a slash operator, parse a\n// regular expression literal. This is to handle cases like\n// `if (foo) /blah/.exec(foo)`, where looking at the previous token\n// does not help.\n\npp$1.parseStatement = function(context, topLevel, exports) {\n  var starttype = this.type, node = this.startNode(), kind;\n\n  if (this.isLet(context)) {\n    starttype = types._var;\n    kind = \"let\";\n  }\n\n  // Most types of statements are recognized by the keyword they\n  // start with. Many are trivial to parse, some require a bit of\n  // complexity.\n\n  switch (starttype) {\n  case types._break: case types._continue: return this.parseBreakContinueStatement(node, starttype.keyword)\n  case types._debugger: return this.parseDebuggerStatement(node)\n  case types._do: return this.parseDoStatement(node)\n  case types._for: return this.parseForStatement(node)\n  case types._function:\n    // Function as sole body of either an if statement or a labeled statement\n    // works, but not when it is part of a labeled statement that is the sole\n    // body of an if statement.\n    if ((context && (this.strict || context !== \"if\" && context !== \"label\")) && this.options.ecmaVersion >= 6) { this.unexpected(); }\n    return this.parseFunctionStatement(node, false, !context)\n  case types._class:\n    if (context) { this.unexpected(); }\n    return this.parseClass(node, true)\n  case types._if: return this.parseIfStatement(node)\n  case types._return: return this.parseReturnStatement(node)\n  case types._switch: return this.parseSwitchStatement(node)\n  case types._throw: return this.parseThrowStatement(node)\n  case types._try: return this.parseTryStatement(node)\n  case types._const: case types._var:\n    kind = kind || this.value;\n    if (context && kind !== \"var\") { this.unexpected(); }\n    return this.parseVarStatement(node, kind)\n  case types._while: return this.parseWhileStatement(node)\n  case types._with: return this.parseWithStatement(node)\n  case types.braceL: return this.parseBlock(true, node)\n  case types.semi: return this.parseEmptyStatement(node)\n  case types._export:\n  case types._import:\n    if (this.options.ecmaVersion > 10 && starttype === types._import) {\n      skipWhiteSpace.lastIndex = this.pos;\n      var skip = skipWhiteSpace.exec(this.input);\n      var next = this.pos + skip[0].length, nextCh = this.input.charCodeAt(next);\n      if (nextCh === 40) // '('\n        { return this.parseExpressionStatement(node, this.parseExpression()) }\n    }\n\n    if (!this.options.allowImportExportEverywhere) {\n      if (!topLevel)\n        { this.raise(this.start, \"'import' and 'export' may only appear at the top level\"); }\n      if (!this.inModule)\n        { this.raise(this.start, \"'import' and 'export' may appear only with 'sourceType: module'\"); }\n    }\n    return starttype === types._import ? this.parseImport(node) : this.parseExport(node, exports)\n\n    // If the statement does not start with a statement keyword or a\n    // brace, it's an ExpressionStatement or LabeledStatement. We\n    // simply start parsing an expression, and afterwards, if the\n    // next token is a colon and the expression was a simple\n    // Identifier node, we switch to interpreting it as a label.\n  default:\n    if (this.isAsyncFunction()) {\n      if (context) { this.unexpected(); }\n      this.next();\n      return this.parseFunctionStatement(node, true, !context)\n    }\n\n    var maybeName = this.value, expr = this.parseExpression();\n    if (starttype === types.name && expr.type === \"Identifier\" && this.eat(types.colon))\n      { return this.parseLabeledStatement(node, maybeName, expr, context) }\n    else { return this.parseExpressionStatement(node, expr) }\n  }\n};\n\npp$1.parseBreakContinueStatement = function(node, keyword) {\n  var isBreak = keyword === \"break\";\n  this.next();\n  if (this.eat(types.semi) || this.insertSemicolon()) { node.label = null; }\n  else if (this.type !== types.name) { this.unexpected(); }\n  else {\n    node.label = this.parseIdent();\n    this.semicolon();\n  }\n\n  // Verify that there is an actual destination to break or\n  // continue to.\n  var i = 0;\n  for (; i < this.labels.length; ++i) {\n    var lab = this.labels[i];\n    if (node.label == null || lab.name === node.label.name) {\n      if (lab.kind != null && (isBreak || lab.kind === \"loop\")) { break }\n      if (node.label && isBreak) { break }\n    }\n  }\n  if (i === this.labels.length) { this.raise(node.start, \"Unsyntactic \" + keyword); }\n  return this.finishNode(node, isBreak ? \"BreakStatement\" : \"ContinueStatement\")\n};\n\npp$1.parseDebuggerStatement = function(node) {\n  this.next();\n  this.semicolon();\n  return this.finishNode(node, \"DebuggerStatement\")\n};\n\npp$1.parseDoStatement = function(node) {\n  this.next();\n  this.labels.push(loopLabel);\n  node.body = this.parseStatement(\"do\");\n  this.labels.pop();\n  this.expect(types._while);\n  node.test = this.parseParenExpression();\n  if (this.options.ecmaVersion >= 6)\n    { this.eat(types.semi); }\n  else\n    { this.semicolon(); }\n  return this.finishNode(node, \"DoWhileStatement\")\n};\n\n// Disambiguating between a `for` and a `for`/`in` or `for`/`of`\n// loop is non-trivial. Basically, we have to parse the init `var`\n// statement or expression, disallowing the `in` operator (see\n// the second parameter to `parseExpression`), and then check\n// whether the next token is `in` or `of`. When there is no init\n// part (semicolon immediately after the opening parenthesis), it\n// is a regular `for` loop.\n\npp$1.parseForStatement = function(node) {\n  this.next();\n  var awaitAt = (this.options.ecmaVersion >= 9 && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction)) && this.eatContextual(\"await\")) ? this.lastTokStart : -1;\n  this.labels.push(loopLabel);\n  this.enterScope(0);\n  this.expect(types.parenL);\n  if (this.type === types.semi) {\n    if (awaitAt > -1) { this.unexpected(awaitAt); }\n    return this.parseFor(node, null)\n  }\n  var isLet = this.isLet();\n  if (this.type === types._var || this.type === types._const || isLet) {\n    var init$1 = this.startNode(), kind = isLet ? \"let\" : this.value;\n    this.next();\n    this.parseVar(init$1, true, kind);\n    this.finishNode(init$1, \"VariableDeclaration\");\n    if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\"))) && init$1.declarations.length === 1) {\n      if (this.options.ecmaVersion >= 9) {\n        if (this.type === types._in) {\n          if (awaitAt > -1) { this.unexpected(awaitAt); }\n        } else { node.await = awaitAt > -1; }\n      }\n      return this.parseForIn(node, init$1)\n    }\n    if (awaitAt > -1) { this.unexpected(awaitAt); }\n    return this.parseFor(node, init$1)\n  }\n  var refDestructuringErrors = new DestructuringErrors;\n  var init = this.parseExpression(true, refDestructuringErrors);\n  if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\"))) {\n    if (this.options.ecmaVersion >= 9) {\n      if (this.type === types._in) {\n        if (awaitAt > -1) { this.unexpected(awaitAt); }\n      } else { node.await = awaitAt > -1; }\n    }\n    this.toAssignable(init, false, refDestructuringErrors);\n    this.checkLVal(init);\n    return this.parseForIn(node, init)\n  } else {\n    this.checkExpressionErrors(refDestructuringErrors, true);\n  }\n  if (awaitAt > -1) { this.unexpected(awaitAt); }\n  return this.parseFor(node, init)\n};\n\npp$1.parseFunctionStatement = function(node, isAsync, declarationPosition) {\n  this.next();\n  return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)\n};\n\npp$1.parseIfStatement = function(node) {\n  this.next();\n  node.test = this.parseParenExpression();\n  // allow function declarations in branches, but only in non-strict mode\n  node.consequent = this.parseStatement(\"if\");\n  node.alternate = this.eat(types._else) ? this.parseStatement(\"if\") : null;\n  return this.finishNode(node, \"IfStatement\")\n};\n\npp$1.parseReturnStatement = function(node) {\n  if (!this.inFunction && !this.options.allowReturnOutsideFunction)\n    { this.raise(this.start, \"'return' outside of function\"); }\n  this.next();\n\n  // In `return` (and `break`/`continue`), the keywords with\n  // optional arguments, we eagerly look for a semicolon or the\n  // possibility to insert one.\n\n  if (this.eat(types.semi) || this.insertSemicolon()) { node.argument = null; }\n  else { node.argument = this.parseExpression(); this.semicolon(); }\n  return this.finishNode(node, \"ReturnStatement\")\n};\n\npp$1.parseSwitchStatement = function(node) {\n  this.next();\n  node.discriminant = this.parseParenExpression();\n  node.cases = [];\n  this.expect(types.braceL);\n  this.labels.push(switchLabel);\n  this.enterScope(0);\n\n  // Statements under must be grouped (by label) in SwitchCase\n  // nodes. `cur` is used to keep the node that we are currently\n  // adding statements to.\n\n  var cur;\n  for (var sawDefault = false; this.type !== types.braceR;) {\n    if (this.type === types._case || this.type === types._default) {\n      var isCase = this.type === types._case;\n      if (cur) { this.finishNode(cur, \"SwitchCase\"); }\n      node.cases.push(cur = this.startNode());\n      cur.consequent = [];\n      this.next();\n      if (isCase) {\n        cur.test = this.parseExpression();\n      } else {\n        if (sawDefault) { this.raiseRecoverable(this.lastTokStart, \"Multiple default clauses\"); }\n        sawDefault = true;\n        cur.test = null;\n      }\n      this.expect(types.colon);\n    } else {\n      if (!cur) { this.unexpected(); }\n      cur.consequent.push(this.parseStatement(null));\n    }\n  }\n  this.exitScope();\n  if (cur) { this.finishNode(cur, \"SwitchCase\"); }\n  this.next(); // Closing brace\n  this.labels.pop();\n  return this.finishNode(node, \"SwitchStatement\")\n};\n\npp$1.parseThrowStatement = function(node) {\n  this.next();\n  if (lineBreak.test(this.input.slice(this.lastTokEnd, this.start)))\n    { this.raise(this.lastTokEnd, \"Illegal newline after throw\"); }\n  node.argument = this.parseExpression();\n  this.semicolon();\n  return this.finishNode(node, \"ThrowStatement\")\n};\n\n// Reused empty array added for node fields that are always empty.\n\nvar empty = [];\n\npp$1.parseTryStatement = function(node) {\n  this.next();\n  node.block = this.parseBlock();\n  node.handler = null;\n  if (this.type === types._catch) {\n    var clause = this.startNode();\n    this.next();\n    if (this.eat(types.parenL)) {\n      clause.param = this.parseBindingAtom();\n      var simple = clause.param.type === \"Identifier\";\n      this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);\n      this.checkLVal(clause.param, simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);\n      this.expect(types.parenR);\n    } else {\n      if (this.options.ecmaVersion < 10) { this.unexpected(); }\n      clause.param = null;\n      this.enterScope(0);\n    }\n    clause.body = this.parseBlock(false);\n    this.exitScope();\n    node.handler = this.finishNode(clause, \"CatchClause\");\n  }\n  node.finalizer = this.eat(types._finally) ? this.parseBlock() : null;\n  if (!node.handler && !node.finalizer)\n    { this.raise(node.start, \"Missing catch or finally clause\"); }\n  return this.finishNode(node, \"TryStatement\")\n};\n\npp$1.parseVarStatement = function(node, kind) {\n  this.next();\n  this.parseVar(node, false, kind);\n  this.semicolon();\n  return this.finishNode(node, \"VariableDeclaration\")\n};\n\npp$1.parseWhileStatement = function(node) {\n  this.next();\n  node.test = this.parseParenExpression();\n  this.labels.push(loopLabel);\n  node.body = this.parseStatement(\"while\");\n  this.labels.pop();\n  return this.finishNode(node, \"WhileStatement\")\n};\n\npp$1.parseWithStatement = function(node) {\n  if (this.strict) { this.raise(this.start, \"'with' in strict mode\"); }\n  this.next();\n  node.object = this.parseParenExpression();\n  node.body = this.parseStatement(\"with\");\n  return this.finishNode(node, \"WithStatement\")\n};\n\npp$1.parseEmptyStatement = function(node) {\n  this.next();\n  return this.finishNode(node, \"EmptyStatement\")\n};\n\npp$1.parseLabeledStatement = function(node, maybeName, expr, context) {\n  for (var i$1 = 0, list = this.labels; i$1 < list.length; i$1 += 1)\n    {\n    var label = list[i$1];\n\n    if (label.name === maybeName)\n      { this.raise(expr.start, \"Label '\" + maybeName + \"' is already declared\");\n  } }\n  var kind = this.type.isLoop ? \"loop\" : this.type === types._switch ? \"switch\" : null;\n  for (var i = this.labels.length - 1; i >= 0; i--) {\n    var label$1 = this.labels[i];\n    if (label$1.statementStart === node.start) {\n      // Update information about previous labels on this node\n      label$1.statementStart = this.start;\n      label$1.kind = kind;\n    } else { break }\n  }\n  this.labels.push({name: maybeName, kind: kind, statementStart: this.start});\n  node.body = this.parseStatement(context ? context.indexOf(\"label\") === -1 ? context + \"label\" : context : \"label\");\n  this.labels.pop();\n  node.label = expr;\n  return this.finishNode(node, \"LabeledStatement\")\n};\n\npp$1.parseExpressionStatement = function(node, expr) {\n  node.expression = expr;\n  this.semicolon();\n  return this.finishNode(node, \"ExpressionStatement\")\n};\n\n// Parse a semicolon-enclosed block of statements, handling `\"use\n// strict\"` declarations when `allowStrict` is true (used for\n// function bodies).\n\npp$1.parseBlock = function(createNewLexicalScope, node) {\n  if ( createNewLexicalScope === void 0 ) createNewLexicalScope = true;\n  if ( node === void 0 ) node = this.startNode();\n\n  node.body = [];\n  this.expect(types.braceL);\n  if (createNewLexicalScope) { this.enterScope(0); }\n  while (!this.eat(types.braceR)) {\n    var stmt = this.parseStatement(null);\n    node.body.push(stmt);\n  }\n  if (createNewLexicalScope) { this.exitScope(); }\n  return this.finishNode(node, \"BlockStatement\")\n};\n\n// Parse a regular `for` loop. The disambiguation code in\n// `parseStatement` will already have parsed the init statement or\n// expression.\n\npp$1.parseFor = function(node, init) {\n  node.init = init;\n  this.expect(types.semi);\n  node.test = this.type === types.semi ? null : this.parseExpression();\n  this.expect(types.semi);\n  node.update = this.type === types.parenR ? null : this.parseExpression();\n  this.expect(types.parenR);\n  node.body = this.parseStatement(\"for\");\n  this.exitScope();\n  this.labels.pop();\n  return this.finishNode(node, \"ForStatement\")\n};\n\n// Parse a `for`/`in` and `for`/`of` loop, which are almost\n// same from parser's perspective.\n\npp$1.parseForIn = function(node, init) {\n  var isForIn = this.type === types._in;\n  this.next();\n\n  if (\n    init.type === \"VariableDeclaration\" &&\n    init.declarations[0].init != null &&\n    (\n      !isForIn ||\n      this.options.ecmaVersion < 8 ||\n      this.strict ||\n      init.kind !== \"var\" ||\n      init.declarations[0].id.type !== \"Identifier\"\n    )\n  ) {\n    this.raise(\n      init.start,\n      ((isForIn ? \"for-in\" : \"for-of\") + \" loop variable declaration may not have an initializer\")\n    );\n  } else if (init.type === \"AssignmentPattern\") {\n    this.raise(init.start, \"Invalid left-hand side in for-loop\");\n  }\n  node.left = init;\n  node.right = isForIn ? this.parseExpression() : this.parseMaybeAssign();\n  this.expect(types.parenR);\n  node.body = this.parseStatement(\"for\");\n  this.exitScope();\n  this.labels.pop();\n  return this.finishNode(node, isForIn ? \"ForInStatement\" : \"ForOfStatement\")\n};\n\n// Parse a list of variable declarations.\n\npp$1.parseVar = function(node, isFor, kind) {\n  node.declarations = [];\n  node.kind = kind;\n  for (;;) {\n    var decl = this.startNode();\n    this.parseVarId(decl, kind);\n    if (this.eat(types.eq)) {\n      decl.init = this.parseMaybeAssign(isFor);\n    } else if (kind === \"const\" && !(this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual(\"of\")))) {\n      this.unexpected();\n    } else if (decl.id.type !== \"Identifier\" && !(isFor && (this.type === types._in || this.isContextual(\"of\")))) {\n      this.raise(this.lastTokEnd, \"Complex binding patterns require an initialization value\");\n    } else {\n      decl.init = null;\n    }\n    node.declarations.push(this.finishNode(decl, \"VariableDeclarator\"));\n    if (!this.eat(types.comma)) { break }\n  }\n  return node\n};\n\npp$1.parseVarId = function(decl, kind) {\n  decl.id = this.parseBindingAtom();\n  this.checkLVal(decl.id, kind === \"var\" ? BIND_VAR : BIND_LEXICAL, false);\n};\n\nvar FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4;\n\n// Parse a function declaration or literal (depending on the\n// `statement & FUNC_STATEMENT`).\n\n// Remove `allowExpressionBody` for 7.0.0, as it is only called with false\npp$1.parseFunction = function(node, statement, allowExpressionBody, isAsync) {\n  this.initFunction(node);\n  if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {\n    if (this.type === types.star && (statement & FUNC_HANGING_STATEMENT))\n      { this.unexpected(); }\n    node.generator = this.eat(types.star);\n  }\n  if (this.options.ecmaVersion >= 8)\n    { node.async = !!isAsync; }\n\n  if (statement & FUNC_STATEMENT) {\n    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types.name ? null : this.parseIdent();\n    if (node.id && !(statement & FUNC_HANGING_STATEMENT))\n      // If it is a regular function declaration in sloppy mode, then it is\n      // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding\n      // mode depends on properties of the current scope (see\n      // treatFunctionsAsVar).\n      { this.checkLVal(node.id, (this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION); }\n  }\n\n  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;\n  this.yieldPos = 0;\n  this.awaitPos = 0;\n  this.awaitIdentPos = 0;\n  this.enterScope(functionFlags(node.async, node.generator));\n\n  if (!(statement & FUNC_STATEMENT))\n    { node.id = this.type === types.name ? this.parseIdent() : null; }\n\n  this.parseFunctionParams(node);\n  this.parseFunctionBody(node, allowExpressionBody, false);\n\n  this.yieldPos = oldYieldPos;\n  this.awaitPos = oldAwaitPos;\n  this.awaitIdentPos = oldAwaitIdentPos;\n  return this.finishNode(node, (statement & FUNC_STATEMENT) ? \"FunctionDeclaration\" : \"FunctionExpression\")\n};\n\npp$1.parseFunctionParams = function(node) {\n  this.expect(types.parenL);\n  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);\n  this.checkYieldAwaitInDefaultParams();\n};\n\n// Parse a class declaration or literal (depending on the\n// `isStatement` parameter).\n\npp$1.parseClass = function(node, isStatement) {\n  this.next();\n\n  // ecma-262 14.6 Class Definitions\n  // A class definition is always strict mode code.\n  var oldStrict = this.strict;\n  this.strict = true;\n\n  this.parseClassId(node, isStatement);\n  this.parseClassSuper(node);\n  var classBody = this.startNode();\n  var hadConstructor = false;\n  classBody.body = [];\n  this.expect(types.braceL);\n  while (!this.eat(types.braceR)) {\n    var element = this.parseClassElement(node.superClass !== null);\n    if (element) {\n      classBody.body.push(element);\n      if (element.type === \"MethodDefinition\" && element.kind === \"constructor\") {\n        if (hadConstructor) { this.raise(element.start, \"Duplicate constructor in the same class\"); }\n        hadConstructor = true;\n      }\n    }\n  }\n  node.body = this.finishNode(classBody, \"ClassBody\");\n  this.strict = oldStrict;\n  return this.finishNode(node, isStatement ? \"ClassDeclaration\" : \"ClassExpression\")\n};\n\npp$1.parseClassElement = function(constructorAllowsSuper) {\n  var this$1 = this;\n\n  if (this.eat(types.semi)) { return null }\n\n  var method = this.startNode();\n  var tryContextual = function (k, noLineBreak) {\n    if ( noLineBreak === void 0 ) noLineBreak = false;\n\n    var start = this$1.start, startLoc = this$1.startLoc;\n    if (!this$1.eatContextual(k)) { return false }\n    if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }\n    if (method.key) { this$1.unexpected(); }\n    method.computed = false;\n    method.key = this$1.startNodeAt(start, startLoc);\n    method.key.name = k;\n    this$1.finishNode(method.key, \"Identifier\");\n    return false\n  };\n\n  method.kind = \"method\";\n  method.static = tryContextual(\"static\");\n  var isGenerator = this.eat(types.star);\n  var isAsync = false;\n  if (!isGenerator) {\n    if (this.options.ecmaVersion >= 8 && tryContextual(\"async\", true)) {\n      isAsync = true;\n      isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);\n    } else if (tryContextual(\"get\")) {\n      method.kind = \"get\";\n    } else if (tryContextual(\"set\")) {\n      method.kind = \"set\";\n    }\n  }\n  if (!method.key) { this.parsePropertyName(method); }\n  var key = method.key;\n  var allowsDirectSuper = false;\n  if (!method.computed && !method.static && (key.type === \"Identifier\" && key.name === \"constructor\" ||\n      key.type === \"Literal\" && key.value === \"constructor\")) {\n    if (method.kind !== \"method\") { this.raise(key.start, \"Constructor can't have get/set modifier\"); }\n    if (isGenerator) { this.raise(key.start, \"Constructor can't be a generator\"); }\n    if (isAsync) { this.raise(key.start, \"Constructor can't be an async method\"); }\n    method.kind = \"constructor\";\n    allowsDirectSuper = constructorAllowsSuper;\n  } else if (method.static && key.type === \"Identifier\" && key.name === \"prototype\") {\n    this.raise(key.start, \"Classes may not have a static property named prototype\");\n  }\n  this.parseClassMethod(method, isGenerator, isAsync, allowsDirectSuper);\n  if (method.kind === \"get\" && method.value.params.length !== 0)\n    { this.raiseRecoverable(method.value.start, \"getter should have no params\"); }\n  if (method.kind === \"set\" && method.value.params.length !== 1)\n    { this.raiseRecoverable(method.value.start, \"setter should have exactly one param\"); }\n  if (method.kind === \"set\" && method.value.params[0].type === \"RestElement\")\n    { this.raiseRecoverable(method.value.params[0].start, \"Setter cannot use rest params\"); }\n  return method\n};\n\npp$1.parseClassMethod = function(method, isGenerator, isAsync, allowsDirectSuper) {\n  method.value = this.parseMethod(isGenerator, isAsync, allowsDirectSuper);\n  return this.finishNode(method, \"MethodDefinition\")\n};\n\npp$1.parseClassId = function(node, isStatement) {\n  if (this.type === types.name) {\n    node.id = this.parseIdent();\n    if (isStatement)\n      { this.checkLVal(node.id, BIND_LEXICAL, false); }\n  } else {\n    if (isStatement === true)\n      { this.unexpected(); }\n    node.id = null;\n  }\n};\n\npp$1.parseClassSuper = function(node) {\n  node.superClass = this.eat(types._extends) ? this.parseExprSubscripts() : null;\n};\n\n// Parses module export declaration.\n\npp$1.parseExport = function(node, exports) {\n  this.next();\n  // export * from '...'\n  if (this.eat(types.star)) {\n    this.expectContextual(\"from\");\n    if (this.type !== types.string) { this.unexpected(); }\n    node.source = this.parseExprAtom();\n    this.semicolon();\n    return this.finishNode(node, \"ExportAllDeclaration\")\n  }\n  if (this.eat(types._default)) { // export default ...\n    this.checkExport(exports, \"default\", this.lastTokStart);\n    var isAsync;\n    if (this.type === types._function || (isAsync = this.isAsyncFunction())) {\n      var fNode = this.startNode();\n      this.next();\n      if (isAsync) { this.next(); }\n      node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);\n    } else if (this.type === types._class) {\n      var cNode = this.startNode();\n      node.declaration = this.parseClass(cNode, \"nullableID\");\n    } else {\n      node.declaration = this.parseMaybeAssign();\n      this.semicolon();\n    }\n    return this.finishNode(node, \"ExportDefaultDeclaration\")\n  }\n  // export var|const|let|function|class ...\n  if (this.shouldParseExportStatement()) {\n    node.declaration = this.parseStatement(null);\n    if (node.declaration.type === \"VariableDeclaration\")\n      { this.checkVariableExport(exports, node.declaration.declarations); }\n    else\n      { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }\n    node.specifiers = [];\n    node.source = null;\n  } else { // export { x, y as z } [from '...']\n    node.declaration = null;\n    node.specifiers = this.parseExportSpecifiers(exports);\n    if (this.eatContextual(\"from\")) {\n      if (this.type !== types.string) { this.unexpected(); }\n      node.source = this.parseExprAtom();\n    } else {\n      for (var i = 0, list = node.specifiers; i < list.length; i += 1) {\n        // check for keywords used as local names\n        var spec = list[i];\n\n        this.checkUnreserved(spec.local);\n        // check if export is defined\n        this.checkLocalExport(spec.local);\n      }\n\n      node.source = null;\n    }\n    this.semicolon();\n  }\n  return this.finishNode(node, \"ExportNamedDeclaration\")\n};\n\npp$1.checkExport = function(exports, name, pos) {\n  if (!exports) { return }\n  if (has(exports, name))\n    { this.raiseRecoverable(pos, \"Duplicate export '\" + name + \"'\"); }\n  exports[name] = true;\n};\n\npp$1.checkPatternExport = function(exports, pat) {\n  var type = pat.type;\n  if (type === \"Identifier\")\n    { this.checkExport(exports, pat.name, pat.start); }\n  else if (type === \"ObjectPattern\")\n    { for (var i = 0, list = pat.properties; i < list.length; i += 1)\n      {\n        var prop = list[i];\n\n        this.checkPatternExport(exports, prop);\n      } }\n  else if (type === \"ArrayPattern\")\n    { for (var i$1 = 0, list$1 = pat.elements; i$1 < list$1.length; i$1 += 1) {\n      var elt = list$1[i$1];\n\n        if (elt) { this.checkPatternExport(exports, elt); }\n    } }\n  else if (type === \"Property\")\n    { this.checkPatternExport(exports, pat.value); }\n  else if (type === \"AssignmentPattern\")\n    { this.checkPatternExport(exports, pat.left); }\n  else if (type === \"RestElement\")\n    { this.checkPatternExport(exports, pat.argument); }\n  else if (type === \"ParenthesizedExpression\")\n    { this.checkPatternExport(exports, pat.expression); }\n};\n\npp$1.checkVariableExport = function(exports, decls) {\n  if (!exports) { return }\n  for (var i = 0, list = decls; i < list.length; i += 1)\n    {\n    var decl = list[i];\n\n    this.checkPatternExport(exports, decl.id);\n  }\n};\n\npp$1.shouldParseExportStatement = function() {\n  return this.type.keyword === \"var\" ||\n    this.type.keyword === \"const\" ||\n    this.type.keyword === \"class\" ||\n    this.type.keyword === \"function\" ||\n    this.isLet() ||\n    this.isAsyncFunction()\n};\n\n// Parses a comma-separated list of module exports.\n\npp$1.parseExportSpecifiers = function(exports) {\n  var nodes = [], first = true;\n  // export { x, y as z } [from '...']\n  this.expect(types.braceL);\n  while (!this.eat(types.braceR)) {\n    if (!first) {\n      this.expect(types.comma);\n      if (this.afterTrailingComma(types.braceR)) { break }\n    } else { first = false; }\n\n    var node = this.startNode();\n    node.local = this.parseIdent(true);\n    node.exported = this.eatContextual(\"as\") ? this.parseIdent(true) : node.local;\n    this.checkExport(exports, node.exported.name, node.exported.start);\n    nodes.push(this.finishNode(node, \"ExportSpecifier\"));\n  }\n  return nodes\n};\n\n// Parses import declaration.\n\npp$1.parseImport = function(node) {\n  this.next();\n  // import '...'\n  if (this.type === types.string) {\n    node.specifiers = empty;\n    node.source = this.parseExprAtom();\n  } else {\n    node.specifiers = this.parseImportSpecifiers();\n    this.expectContextual(\"from\");\n    node.source = this.type === types.string ? this.parseExprAtom() : this.unexpected();\n  }\n  this.semicolon();\n  return this.finishNode(node, \"ImportDeclaration\")\n};\n\n// Parses a comma-separated list of module imports.\n\npp$1.parseImportSpecifiers = function() {\n  var nodes = [], first = true;\n  if (this.type === types.name) {\n    // import defaultObj, { x, y as z } from '...'\n    var node = this.startNode();\n    node.local = this.parseIdent();\n    this.checkLVal(node.local, BIND_LEXICAL);\n    nodes.push(this.finishNode(node, \"ImportDefaultSpecifier\"));\n    if (!this.eat(types.comma)) { return nodes }\n  }\n  if (this.type === types.star) {\n    var node$1 = this.startNode();\n    this.next();\n    this.expectContextual(\"as\");\n    node$1.local = this.parseIdent();\n    this.checkLVal(node$1.local, BIND_LEXICAL);\n    nodes.push(this.finishNode(node$1, \"ImportNamespaceSpecifier\"));\n    return nodes\n  }\n  this.expect(types.braceL);\n  while (!this.eat(types.braceR)) {\n    if (!first) {\n      this.expect(types.comma);\n      if (this.afterTrailingComma(types.braceR)) { break }\n    } else { first = false; }\n\n    var node$2 = this.startNode();\n    node$2.imported = this.parseIdent(true);\n    if (this.eatContextual(\"as\")) {\n      node$2.local = this.parseIdent();\n    } else {\n      this.checkUnreserved(node$2.imported);\n      node$2.local = node$2.imported;\n    }\n    this.checkLVal(node$2.local, BIND_LEXICAL);\n    nodes.push(this.finishNode(node$2, \"ImportSpecifier\"));\n  }\n  return nodes\n};\n\n// Set `ExpressionStatement#directive` property for directive prologues.\npp$1.adaptDirectivePrologue = function(statements) {\n  for (var i = 0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {\n    statements[i].directive = statements[i].expression.raw.slice(1, -1);\n  }\n};\npp$1.isDirectiveCandidate = function(statement) {\n  return (\n    statement.type === \"ExpressionStatement\" &&\n    statement.expression.type === \"Literal\" &&\n    typeof statement.expression.value === \"string\" &&\n    // Reject parenthesized strings.\n    (this.input[statement.start] === \"\\\"\" || this.input[statement.start] === \"'\")\n  )\n};\n\nvar pp$2 = Parser.prototype;\n\n// Convert existing expression atom to assignable pattern\n// if possible.\n\npp$2.toAssignable = function(node, isBinding, refDestructuringErrors) {\n  if (this.options.ecmaVersion >= 6 && node) {\n    switch (node.type) {\n    case \"Identifier\":\n      if (this.inAsync && node.name === \"await\")\n        { this.raise(node.start, \"Cannot use 'await' as identifier inside an async function\"); }\n      break\n\n    case \"ObjectPattern\":\n    case \"ArrayPattern\":\n    case \"RestElement\":\n      break\n\n    case \"ObjectExpression\":\n      node.type = \"ObjectPattern\";\n      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }\n      for (var i = 0, list = node.properties; i < list.length; i += 1) {\n        var prop = list[i];\n\n      this.toAssignable(prop, isBinding);\n        // Early error:\n        //   AssignmentRestProperty[Yield, Await] :\n        //     `...` DestructuringAssignmentTarget[Yield, Await]\n        //\n        //   It is a Syntax Error if |DestructuringAssignmentTarget| is an |ArrayLiteral| or an |ObjectLiteral|.\n        if (\n          prop.type === \"RestElement\" &&\n          (prop.argument.type === \"ArrayPattern\" || prop.argument.type === \"ObjectPattern\")\n        ) {\n          this.raise(prop.argument.start, \"Unexpected token\");\n        }\n      }\n      break\n\n    case \"Property\":\n      // AssignmentProperty has type === \"Property\"\n      if (node.kind !== \"init\") { this.raise(node.key.start, \"Object pattern can't contain getter or setter\"); }\n      this.toAssignable(node.value, isBinding);\n      break\n\n    case \"ArrayExpression\":\n      node.type = \"ArrayPattern\";\n      if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }\n      this.toAssignableList(node.elements, isBinding);\n      break\n\n    case \"SpreadElement\":\n      node.type = \"RestElement\";\n      this.toAssignable(node.argument, isBinding);\n      if (node.argument.type === \"AssignmentPattern\")\n        { this.raise(node.argument.start, \"Rest elements cannot have a default value\"); }\n      break\n\n    case \"AssignmentExpression\":\n      if (node.operator !== \"=\") { this.raise(node.left.end, \"Only '=' operator can be used for specifying default value.\"); }\n      node.type = \"AssignmentPattern\";\n      delete node.operator;\n      this.toAssignable(node.left, isBinding);\n      // falls through to AssignmentPattern\n\n    case \"AssignmentPattern\":\n      break\n\n    case \"ParenthesizedExpression\":\n      this.toAssignable(node.expression, isBinding, refDestructuringErrors);\n      break\n\n    case \"MemberExpression\":\n      if (!isBinding) { break }\n\n    default:\n      this.raise(node.start, \"Assigning to rvalue\");\n    }\n  } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors, true); }\n  return node\n};\n\n// Convert list of expression atoms to binding list.\n\npp$2.toAssignableList = function(exprList, isBinding) {\n  var end = exprList.length;\n  for (var i = 0; i < end; i++) {\n    var elt = exprList[i];\n    if (elt) { this.toAssignable(elt, isBinding); }\n  }\n  if (end) {\n    var last = exprList[end - 1];\n    if (this.options.ecmaVersion === 6 && isBinding && last && last.type === \"RestElement\" && last.argument.type !== \"Identifier\")\n      { this.unexpected(last.argument.start); }\n  }\n  return exprList\n};\n\n// Parses spread element.\n\npp$2.parseSpread = function(refDestructuringErrors) {\n  var node = this.startNode();\n  this.next();\n  node.argument = this.parseMaybeAssign(false, refDestructuringErrors);\n  return this.finishNode(node, \"SpreadElement\")\n};\n\npp$2.parseRestBinding = function() {\n  var node = this.startNode();\n  this.next();\n\n  // RestElement inside of a function parameter must be an identifier\n  if (this.options.ecmaVersion === 6 && this.type !== types.name)\n    { this.unexpected(); }\n\n  node.argument = this.parseBindingAtom();\n\n  return this.finishNode(node, \"RestElement\")\n};\n\n// Parses lvalue (assignable) atom.\n\npp$2.parseBindingAtom = function() {\n  if (this.options.ecmaVersion >= 6) {\n    switch (this.type) {\n    case types.bracketL:\n      var node = this.startNode();\n      this.next();\n      node.elements = this.parseBindingList(types.bracketR, true, true);\n      return this.finishNode(node, \"ArrayPattern\")\n\n    case types.braceL:\n      return this.parseObj(true)\n    }\n  }\n  return this.parseIdent()\n};\n\npp$2.parseBindingList = function(close, allowEmpty, allowTrailingComma) {\n  var elts = [], first = true;\n  while (!this.eat(close)) {\n    if (first) { first = false; }\n    else { this.expect(types.comma); }\n    if (allowEmpty && this.type === types.comma) {\n      elts.push(null);\n    } else if (allowTrailingComma && this.afterTrailingComma(close)) {\n      break\n    } else if (this.type === types.ellipsis) {\n      var rest = this.parseRestBinding();\n      this.parseBindingListItem(rest);\n      elts.push(rest);\n      if (this.type === types.comma) { this.raise(this.start, \"Comma is not permitted after the rest element\"); }\n      this.expect(close);\n      break\n    } else {\n      var elem = this.parseMaybeDefault(this.start, this.startLoc);\n      this.parseBindingListItem(elem);\n      elts.push(elem);\n    }\n  }\n  return elts\n};\n\npp$2.parseBindingListItem = function(param) {\n  return param\n};\n\n// Parses assignment pattern around given atom if possible.\n\npp$2.parseMaybeDefault = function(startPos, startLoc, left) {\n  left = left || this.parseBindingAtom();\n  if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }\n  var node = this.startNodeAt(startPos, startLoc);\n  node.left = left;\n  node.right = this.parseMaybeAssign();\n  return this.finishNode(node, \"AssignmentPattern\")\n};\n\n// Verify that a node is an lval — something that can be assigned\n// to.\n// bindingType can be either:\n// 'var' indicating that the lval creates a 'var' binding\n// 'let' indicating that the lval creates a lexical ('let' or 'const') binding\n// 'none' indicating that the binding should be checked for illegal identifiers, but not for duplicate references\n\npp$2.checkLVal = function(expr, bindingType, checkClashes) {\n  if ( bindingType === void 0 ) bindingType = BIND_NONE;\n\n  switch (expr.type) {\n  case \"Identifier\":\n    if (bindingType === BIND_LEXICAL && expr.name === \"let\")\n      { this.raiseRecoverable(expr.start, \"let is disallowed as a lexically bound name\"); }\n    if (this.strict && this.reservedWordsStrictBind.test(expr.name))\n      { this.raiseRecoverable(expr.start, (bindingType ? \"Binding \" : \"Assigning to \") + expr.name + \" in strict mode\"); }\n    if (checkClashes) {\n      if (has(checkClashes, expr.name))\n        { this.raiseRecoverable(expr.start, \"Argument name clash\"); }\n      checkClashes[expr.name] = true;\n    }\n    if (bindingType !== BIND_NONE && bindingType !== BIND_OUTSIDE) { this.declareName(expr.name, bindingType, expr.start); }\n    break\n\n  case \"MemberExpression\":\n    if (bindingType) { this.raiseRecoverable(expr.start, \"Binding member expression\"); }\n    break\n\n  case \"ObjectPattern\":\n    for (var i = 0, list = expr.properties; i < list.length; i += 1)\n      {\n    var prop = list[i];\n\n    this.checkLVal(prop, bindingType, checkClashes);\n  }\n    break\n\n  case \"Property\":\n    // AssignmentProperty has type === \"Property\"\n    this.checkLVal(expr.value, bindingType, checkClashes);\n    break\n\n  case \"ArrayPattern\":\n    for (var i$1 = 0, list$1 = expr.elements; i$1 < list$1.length; i$1 += 1) {\n      var elem = list$1[i$1];\n\n    if (elem) { this.checkLVal(elem, bindingType, checkClashes); }\n    }\n    break\n\n  case \"AssignmentPattern\":\n    this.checkLVal(expr.left, bindingType, checkClashes);\n    break\n\n  case \"RestElement\":\n    this.checkLVal(expr.argument, bindingType, checkClashes);\n    break\n\n  case \"ParenthesizedExpression\":\n    this.checkLVal(expr.expression, bindingType, checkClashes);\n    break\n\n  default:\n    this.raise(expr.start, (bindingType ? \"Binding\" : \"Assigning to\") + \" rvalue\");\n  }\n};\n\n// A recursive descent parser operates by defining functions for all\n\nvar pp$3 = Parser.prototype;\n\n// Check if property name clashes with already added.\n// Object/class getters and setters are not allowed to clash —\n// either with each other or with an init property — and in\n// strict mode, init properties are also not allowed to be repeated.\n\npp$3.checkPropClash = function(prop, propHash, refDestructuringErrors) {\n  if (this.options.ecmaVersion >= 9 && prop.type === \"SpreadElement\")\n    { return }\n  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))\n    { return }\n  var key = prop.key;\n  var name;\n  switch (key.type) {\n  case \"Identifier\": name = key.name; break\n  case \"Literal\": name = String(key.value); break\n  default: return\n  }\n  var kind = prop.kind;\n  if (this.options.ecmaVersion >= 6) {\n    if (name === \"__proto__\" && kind === \"init\") {\n      if (propHash.proto) {\n        if (refDestructuringErrors && refDestructuringErrors.doubleProto < 0) { refDestructuringErrors.doubleProto = key.start; }\n        // Backwards-compat kludge. Can be removed in version 6.0\n        else { this.raiseRecoverable(key.start, \"Redefinition of __proto__ property\"); }\n      }\n      propHash.proto = true;\n    }\n    return\n  }\n  name = \"$\" + name;\n  var other = propHash[name];\n  if (other) {\n    var redefinition;\n    if (kind === \"init\") {\n      redefinition = this.strict && other.init || other.get || other.set;\n    } else {\n      redefinition = other.init || other[kind];\n    }\n    if (redefinition)\n      { this.raiseRecoverable(key.start, \"Redefinition of property\"); }\n  } else {\n    other = propHash[name] = {\n      init: false,\n      get: false,\n      set: false\n    };\n  }\n  other[kind] = true;\n};\n\n// ### Expression parsing\n\n// These nest, from the most general expression type at the top to\n// 'atomic', nondivisible expression types at the bottom. Most of\n// the functions will simply let the function(s) below them parse,\n// and, *if* the syntactic construct they handle is present, wrap\n// the AST node that the inner parser gave them in another node.\n\n// Parse a full expression. The optional arguments are used to\n// forbid the `in` operator (in for loops initalization expressions)\n// and provide reference for storing '=' operator inside shorthand\n// property assignment in contexts where both object expression\n// and object pattern might appear (so it's possible to raise\n// delayed syntax error at correct position).\n\npp$3.parseExpression = function(noIn, refDestructuringErrors) {\n  var startPos = this.start, startLoc = this.startLoc;\n  var expr = this.parseMaybeAssign(noIn, refDestructuringErrors);\n  if (this.type === types.comma) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.expressions = [expr];\n    while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(noIn, refDestructuringErrors)); }\n    return this.finishNode(node, \"SequenceExpression\")\n  }\n  return expr\n};\n\n// Parse an assignment expression. This includes applications of\n// operators like `+=`.\n\npp$3.parseMaybeAssign = function(noIn, refDestructuringErrors, afterLeftParse) {\n  if (this.isContextual(\"yield\")) {\n    if (this.inGenerator) { return this.parseYield(noIn) }\n    // The tokenizer will assume an expression is allowed after\n    // `yield`, but this isn't that kind of yield\n    else { this.exprAllowed = false; }\n  }\n\n  var ownDestructuringErrors = false, oldParenAssign = -1, oldTrailingComma = -1, oldShorthandAssign = -1;\n  if (refDestructuringErrors) {\n    oldParenAssign = refDestructuringErrors.parenthesizedAssign;\n    oldTrailingComma = refDestructuringErrors.trailingComma;\n    oldShorthandAssign = refDestructuringErrors.shorthandAssign;\n    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.shorthandAssign = -1;\n  } else {\n    refDestructuringErrors = new DestructuringErrors;\n    ownDestructuringErrors = true;\n  }\n\n  var startPos = this.start, startLoc = this.startLoc;\n  if (this.type === types.parenL || this.type === types.name)\n    { this.potentialArrowAt = this.start; }\n  var left = this.parseMaybeConditional(noIn, refDestructuringErrors);\n  if (afterLeftParse) { left = afterLeftParse.call(this, left, startPos, startLoc); }\n  if (this.type.isAssign) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.operator = this.value;\n    node.left = this.type === types.eq ? this.toAssignable(left, false, refDestructuringErrors) : left;\n    if (!ownDestructuringErrors) { DestructuringErrors.call(refDestructuringErrors); }\n    refDestructuringErrors.shorthandAssign = -1; // reset because shorthand default was used correctly\n    this.checkLVal(left);\n    this.next();\n    node.right = this.parseMaybeAssign(noIn);\n    return this.finishNode(node, \"AssignmentExpression\")\n  } else {\n    if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors, true); }\n  }\n  if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign = oldParenAssign; }\n  if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma = oldTrailingComma; }\n  if (oldShorthandAssign > -1) { refDestructuringErrors.shorthandAssign = oldShorthandAssign; }\n  return left\n};\n\n// Parse a ternary conditional (`?:`) operator.\n\npp$3.parseMaybeConditional = function(noIn, refDestructuringErrors) {\n  var startPos = this.start, startLoc = this.startLoc;\n  var expr = this.parseExprOps(noIn, refDestructuringErrors);\n  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }\n  if (this.eat(types.question)) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.test = expr;\n    node.consequent = this.parseMaybeAssign();\n    this.expect(types.colon);\n    node.alternate = this.parseMaybeAssign(noIn);\n    return this.finishNode(node, \"ConditionalExpression\")\n  }\n  return expr\n};\n\n// Start the precedence parser.\n\npp$3.parseExprOps = function(noIn, refDestructuringErrors) {\n  var startPos = this.start, startLoc = this.startLoc;\n  var expr = this.parseMaybeUnary(refDestructuringErrors, false);\n  if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }\n  return expr.start === startPos && expr.type === \"ArrowFunctionExpression\" ? expr : this.parseExprOp(expr, startPos, startLoc, -1, noIn)\n};\n\n// Parse binary operators with the operator precedence parsing\n// algorithm. `left` is the left-hand side of the operator.\n// `minPrec` provides context that allows the function to stop and\n// defer further parser to one of its callers when it encounters an\n// operator that has a lower precedence than the set it is parsing.\n\npp$3.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {\n  var prec = this.type.binop;\n  if (prec != null && (!noIn || this.type !== types._in)) {\n    if (prec > minPrec) {\n      var logical = this.type === types.logicalOR || this.type === types.logicalAND;\n      var op = this.value;\n      this.next();\n      var startPos = this.start, startLoc = this.startLoc;\n      var right = this.parseExprOp(this.parseMaybeUnary(null, false), startPos, startLoc, prec, noIn);\n      var node = this.buildBinary(leftStartPos, leftStartLoc, left, right, op, logical);\n      return this.parseExprOp(node, leftStartPos, leftStartLoc, minPrec, noIn)\n    }\n  }\n  return left\n};\n\npp$3.buildBinary = function(startPos, startLoc, left, right, op, logical) {\n  var node = this.startNodeAt(startPos, startLoc);\n  node.left = left;\n  node.operator = op;\n  node.right = right;\n  return this.finishNode(node, logical ? \"LogicalExpression\" : \"BinaryExpression\")\n};\n\n// Parse unary operators, both prefix and postfix.\n\npp$3.parseMaybeUnary = function(refDestructuringErrors, sawUnary) {\n  var startPos = this.start, startLoc = this.startLoc, expr;\n  if (this.isContextual(\"await\") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {\n    expr = this.parseAwait();\n    sawUnary = true;\n  } else if (this.type.prefix) {\n    var node = this.startNode(), update = this.type === types.incDec;\n    node.operator = this.value;\n    node.prefix = true;\n    this.next();\n    node.argument = this.parseMaybeUnary(null, true);\n    this.checkExpressionErrors(refDestructuringErrors, true);\n    if (update) { this.checkLVal(node.argument); }\n    else if (this.strict && node.operator === \"delete\" &&\n             node.argument.type === \"Identifier\")\n      { this.raiseRecoverable(node.start, \"Deleting local variable in strict mode\"); }\n    else { sawUnary = true; }\n    expr = this.finishNode(node, update ? \"UpdateExpression\" : \"UnaryExpression\");\n  } else {\n    expr = this.parseExprSubscripts(refDestructuringErrors);\n    if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }\n    while (this.type.postfix && !this.canInsertSemicolon()) {\n      var node$1 = this.startNodeAt(startPos, startLoc);\n      node$1.operator = this.value;\n      node$1.prefix = false;\n      node$1.argument = expr;\n      this.checkLVal(expr);\n      this.next();\n      expr = this.finishNode(node$1, \"UpdateExpression\");\n    }\n  }\n\n  if (!sawUnary && this.eat(types.starstar))\n    { return this.buildBinary(startPos, startLoc, expr, this.parseMaybeUnary(null, false), \"**\", false) }\n  else\n    { return expr }\n};\n\n// Parse call, dot, and `[]`-subscript expressions.\n\npp$3.parseExprSubscripts = function(refDestructuringErrors) {\n  var startPos = this.start, startLoc = this.startLoc;\n  var expr = this.parseExprAtom(refDestructuringErrors);\n  var skipArrowSubscripts = expr.type === \"ArrowFunctionExpression\" && this.input.slice(this.lastTokStart, this.lastTokEnd) !== \")\";\n  if (this.checkExpressionErrors(refDestructuringErrors) || skipArrowSubscripts) { return expr }\n  var result = this.parseSubscripts(expr, startPos, startLoc);\n  if (refDestructuringErrors && result.type === \"MemberExpression\") {\n    if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign = -1; }\n    if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind = -1; }\n  }\n  return result\n};\n\npp$3.parseSubscripts = function(base, startPos, startLoc, noCalls) {\n  var maybeAsyncArrow = this.options.ecmaVersion >= 8 && base.type === \"Identifier\" && base.name === \"async\" &&\n      this.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start, base.end) === \"async\";\n  while (true) {\n    var element = this.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow);\n    if (element === base || element.type === \"ArrowFunctionExpression\") { return element }\n    base = element;\n  }\n};\n\npp$3.parseSubscript = function(base, startPos, startLoc, noCalls, maybeAsyncArrow) {\n  var computed = this.eat(types.bracketL);\n  if (computed || this.eat(types.dot)) {\n    var node = this.startNodeAt(startPos, startLoc);\n    node.object = base;\n    node.property = computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== \"never\");\n    node.computed = !!computed;\n    if (computed) { this.expect(types.bracketR); }\n    base = this.finishNode(node, \"MemberExpression\");\n  } else if (!noCalls && this.eat(types.parenL)) {\n    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;\n    this.yieldPos = 0;\n    this.awaitPos = 0;\n    this.awaitIdentPos = 0;\n    var exprList = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false, refDestructuringErrors);\n    if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {\n      this.checkPatternErrors(refDestructuringErrors, false);\n      this.checkYieldAwaitInDefaultParams();\n      if (this.awaitIdentPos > 0)\n        { this.raise(this.awaitIdentPos, \"Cannot use 'await' as identifier inside an async function\"); }\n      this.yieldPos = oldYieldPos;\n      this.awaitPos = oldAwaitPos;\n      this.awaitIdentPos = oldAwaitIdentPos;\n      return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList, true)\n    }\n    this.checkExpressionErrors(refDestructuringErrors, true);\n    this.yieldPos = oldYieldPos || this.yieldPos;\n    this.awaitPos = oldAwaitPos || this.awaitPos;\n    this.awaitIdentPos = oldAwaitIdentPos || this.awaitIdentPos;\n    var node$1 = this.startNodeAt(startPos, startLoc);\n    node$1.callee = base;\n    node$1.arguments = exprList;\n    base = this.finishNode(node$1, \"CallExpression\");\n  } else if (this.type === types.backQuote) {\n    var node$2 = this.startNodeAt(startPos, startLoc);\n    node$2.tag = base;\n    node$2.quasi = this.parseTemplate({isTagged: true});\n    base = this.finishNode(node$2, \"TaggedTemplateExpression\");\n  }\n  return base\n};\n\n// Parse an atomic expression — either a single token that is an\n// expression, an expression started by a keyword like `function` or\n// `new`, or an expression wrapped in punctuation like `()`, `[]`,\n// or `{}`.\n\npp$3.parseExprAtom = function(refDestructuringErrors) {\n  // If a division operator appears in an expression position, the\n  // tokenizer got confused, and we force it to read a regexp instead.\n  if (this.type === types.slash) { this.readRegexp(); }\n\n  var node, canBeArrow = this.potentialArrowAt === this.start;\n  switch (this.type) {\n  case types._super:\n    if (!this.allowSuper)\n      { this.raise(this.start, \"'super' keyword outside a method\"); }\n    node = this.startNode();\n    this.next();\n    if (this.type === types.parenL && !this.allowDirectSuper)\n      { this.raise(node.start, \"super() call outside constructor of a subclass\"); }\n    // The `super` keyword can appear at below:\n    // SuperProperty:\n    //     super [ Expression ]\n    //     super . IdentifierName\n    // SuperCall:\n    //     super ( Arguments )\n    if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)\n      { this.unexpected(); }\n    return this.finishNode(node, \"Super\")\n\n  case types._this:\n    node = this.startNode();\n    this.next();\n    return this.finishNode(node, \"ThisExpression\")\n\n  case types.name:\n    var startPos = this.start, startLoc = this.startLoc, containsEsc = this.containsEsc;\n    var id = this.parseIdent(false);\n    if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === \"async\" && !this.canInsertSemicolon() && this.eat(types._function))\n      { return this.parseFunction(this.startNodeAt(startPos, startLoc), 0, false, true) }\n    if (canBeArrow && !this.canInsertSemicolon()) {\n      if (this.eat(types.arrow))\n        { return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], false) }\n      if (this.options.ecmaVersion >= 8 && id.name === \"async\" && this.type === types.name && !containsEsc) {\n        id = this.parseIdent(false);\n        if (this.canInsertSemicolon() || !this.eat(types.arrow))\n          { this.unexpected(); }\n        return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), [id], true)\n      }\n    }\n    return id\n\n  case types.regexp:\n    var value = this.value;\n    node = this.parseLiteral(value.value);\n    node.regex = {pattern: value.pattern, flags: value.flags};\n    return node\n\n  case types.num: case types.string:\n    return this.parseLiteral(this.value)\n\n  case types._null: case types._true: case types._false:\n    node = this.startNode();\n    node.value = this.type === types._null ? null : this.type === types._true;\n    node.raw = this.type.keyword;\n    this.next();\n    return this.finishNode(node, \"Literal\")\n\n  case types.parenL:\n    var start = this.start, expr = this.parseParenAndDistinguishExpression(canBeArrow);\n    if (refDestructuringErrors) {\n      if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))\n        { refDestructuringErrors.parenthesizedAssign = start; }\n      if (refDestructuringErrors.parenthesizedBind < 0)\n        { refDestructuringErrors.parenthesizedBind = start; }\n    }\n    return expr\n\n  case types.bracketL:\n    node = this.startNode();\n    this.next();\n    node.elements = this.parseExprList(types.bracketR, true, true, refDestructuringErrors);\n    return this.finishNode(node, \"ArrayExpression\")\n\n  case types.braceL:\n    return this.parseObj(false, refDestructuringErrors)\n\n  case types._function:\n    node = this.startNode();\n    this.next();\n    return this.parseFunction(node, 0)\n\n  case types._class:\n    return this.parseClass(this.startNode(), false)\n\n  case types._new:\n    return this.parseNew()\n\n  case types.backQuote:\n    return this.parseTemplate()\n\n  case types._import:\n    if (this.options.ecmaVersion >= 11) {\n      return this.parseExprImport()\n    } else {\n      return this.unexpected()\n    }\n\n  default:\n    this.unexpected();\n  }\n};\n\npp$3.parseExprImport = function() {\n  var node = this.startNode();\n  this.next(); // skip `import`\n  switch (this.type) {\n  case types.parenL:\n    return this.parseDynamicImport(node)\n  default:\n    this.unexpected();\n  }\n};\n\npp$3.parseDynamicImport = function(node) {\n  this.next(); // skip `(`\n\n  // Parse node.source.\n  node.source = this.parseMaybeAssign();\n\n  // Verify ending.\n  if (!this.eat(types.parenR)) {\n    var errorPos = this.start;\n    if (this.eat(types.comma) && this.eat(types.parenR)) {\n      this.raiseRecoverable(errorPos, \"Trailing comma is not allowed in import()\");\n    } else {\n      this.unexpected(errorPos);\n    }\n  }\n\n  return this.finishNode(node, \"ImportExpression\")\n};\n\npp$3.parseLiteral = function(value) {\n  var node = this.startNode();\n  node.value = value;\n  node.raw = this.input.slice(this.start, this.end);\n  if (node.raw.charCodeAt(node.raw.length - 1) === 110) { node.bigint = node.raw.slice(0, -1); }\n  this.next();\n  return this.finishNode(node, \"Literal\")\n};\n\npp$3.parseParenExpression = function() {\n  this.expect(types.parenL);\n  var val = this.parseExpression();\n  this.expect(types.parenR);\n  return val\n};\n\npp$3.parseParenAndDistinguishExpression = function(canBeArrow) {\n  var startPos = this.start, startLoc = this.startLoc, val, allowTrailingComma = this.options.ecmaVersion >= 8;\n  if (this.options.ecmaVersion >= 6) {\n    this.next();\n\n    var innerStartPos = this.start, innerStartLoc = this.startLoc;\n    var exprList = [], first = true, lastIsComma = false;\n    var refDestructuringErrors = new DestructuringErrors, oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, spreadStart;\n    this.yieldPos = 0;\n    this.awaitPos = 0;\n    // Do not save awaitIdentPos to allow checking awaits nested in parameters\n    while (this.type !== types.parenR) {\n      first ? first = false : this.expect(types.comma);\n      if (allowTrailingComma && this.afterTrailingComma(types.parenR, true)) {\n        lastIsComma = true;\n        break\n      } else if (this.type === types.ellipsis) {\n        spreadStart = this.start;\n        exprList.push(this.parseParenItem(this.parseRestBinding()));\n        if (this.type === types.comma) { this.raise(this.start, \"Comma is not permitted after the rest element\"); }\n        break\n      } else {\n        exprList.push(this.parseMaybeAssign(false, refDestructuringErrors, this.parseParenItem));\n      }\n    }\n    var innerEndPos = this.start, innerEndLoc = this.startLoc;\n    this.expect(types.parenR);\n\n    if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {\n      this.checkPatternErrors(refDestructuringErrors, false);\n      this.checkYieldAwaitInDefaultParams();\n      this.yieldPos = oldYieldPos;\n      this.awaitPos = oldAwaitPos;\n      return this.parseParenArrowList(startPos, startLoc, exprList)\n    }\n\n    if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); }\n    if (spreadStart) { this.unexpected(spreadStart); }\n    this.checkExpressionErrors(refDestructuringErrors, true);\n    this.yieldPos = oldYieldPos || this.yieldPos;\n    this.awaitPos = oldAwaitPos || this.awaitPos;\n\n    if (exprList.length > 1) {\n      val = this.startNodeAt(innerStartPos, innerStartLoc);\n      val.expressions = exprList;\n      this.finishNodeAt(val, \"SequenceExpression\", innerEndPos, innerEndLoc);\n    } else {\n      val = exprList[0];\n    }\n  } else {\n    val = this.parseParenExpression();\n  }\n\n  if (this.options.preserveParens) {\n    var par = this.startNodeAt(startPos, startLoc);\n    par.expression = val;\n    return this.finishNode(par, \"ParenthesizedExpression\")\n  } else {\n    return val\n  }\n};\n\npp$3.parseParenItem = function(item) {\n  return item\n};\n\npp$3.parseParenArrowList = function(startPos, startLoc, exprList) {\n  return this.parseArrowExpression(this.startNodeAt(startPos, startLoc), exprList)\n};\n\n// New's precedence is slightly tricky. It must allow its argument to\n// be a `[]` or dot subscript expression, but not a call — at least,\n// not without wrapping it in parentheses. Thus, it uses the noCalls\n// argument to parseSubscripts to prevent it from consuming the\n// argument list.\n\nvar empty$1 = [];\n\npp$3.parseNew = function() {\n  var node = this.startNode();\n  var meta = this.parseIdent(true);\n  if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {\n    node.meta = meta;\n    var containsEsc = this.containsEsc;\n    node.property = this.parseIdent(true);\n    if (node.property.name !== \"target\" || containsEsc)\n      { this.raiseRecoverable(node.property.start, \"The only valid meta property for new is new.target\"); }\n    if (!this.inNonArrowFunction())\n      { this.raiseRecoverable(node.start, \"new.target can only be used in functions\"); }\n    return this.finishNode(node, \"MetaProperty\")\n  }\n  var startPos = this.start, startLoc = this.startLoc, isImport = this.type === types._import;\n  node.callee = this.parseSubscripts(this.parseExprAtom(), startPos, startLoc, true);\n  if (isImport && node.callee.type === \"ImportExpression\") {\n    this.raise(startPos, \"Cannot use new with import()\");\n  }\n  if (this.eat(types.parenL)) { node.arguments = this.parseExprList(types.parenR, this.options.ecmaVersion >= 8, false); }\n  else { node.arguments = empty$1; }\n  return this.finishNode(node, \"NewExpression\")\n};\n\n// Parse template expression.\n\npp$3.parseTemplateElement = function(ref) {\n  var isTagged = ref.isTagged;\n\n  var elem = this.startNode();\n  if (this.type === types.invalidTemplate) {\n    if (!isTagged) {\n      this.raiseRecoverable(this.start, \"Bad escape sequence in untagged template literal\");\n    }\n    elem.value = {\n      raw: this.value,\n      cooked: null\n    };\n  } else {\n    elem.value = {\n      raw: this.input.slice(this.start, this.end).replace(/\\r\\n?/g, \"\\n\"),\n      cooked: this.value\n    };\n  }\n  this.next();\n  elem.tail = this.type === types.backQuote;\n  return this.finishNode(elem, \"TemplateElement\")\n};\n\npp$3.parseTemplate = function(ref) {\n  if ( ref === void 0 ) ref = {};\n  var isTagged = ref.isTagged; if ( isTagged === void 0 ) isTagged = false;\n\n  var node = this.startNode();\n  this.next();\n  node.expressions = [];\n  var curElt = this.parseTemplateElement({isTagged: isTagged});\n  node.quasis = [curElt];\n  while (!curElt.tail) {\n    if (this.type === types.eof) { this.raise(this.pos, \"Unterminated template literal\"); }\n    this.expect(types.dollarBraceL);\n    node.expressions.push(this.parseExpression());\n    this.expect(types.braceR);\n    node.quasis.push(curElt = this.parseTemplateElement({isTagged: isTagged}));\n  }\n  this.next();\n  return this.finishNode(node, \"TemplateLiteral\")\n};\n\npp$3.isAsyncProp = function(prop) {\n  return !prop.computed && prop.key.type === \"Identifier\" && prop.key.name === \"async\" &&\n    (this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types.star)) &&\n    !lineBreak.test(this.input.slice(this.lastTokEnd, this.start))\n};\n\n// Parse an object literal or binding pattern.\n\npp$3.parseObj = function(isPattern, refDestructuringErrors) {\n  var node = this.startNode(), first = true, propHash = {};\n  node.properties = [];\n  this.next();\n  while (!this.eat(types.braceR)) {\n    if (!first) {\n      this.expect(types.comma);\n      if (this.options.ecmaVersion >= 5 && this.afterTrailingComma(types.braceR)) { break }\n    } else { first = false; }\n\n    var prop = this.parseProperty(isPattern, refDestructuringErrors);\n    if (!isPattern) { this.checkPropClash(prop, propHash, refDestructuringErrors); }\n    node.properties.push(prop);\n  }\n  return this.finishNode(node, isPattern ? \"ObjectPattern\" : \"ObjectExpression\")\n};\n\npp$3.parseProperty = function(isPattern, refDestructuringErrors) {\n  var prop = this.startNode(), isGenerator, isAsync, startPos, startLoc;\n  if (this.options.ecmaVersion >= 9 && this.eat(types.ellipsis)) {\n    if (isPattern) {\n      prop.argument = this.parseIdent(false);\n      if (this.type === types.comma) {\n        this.raise(this.start, \"Comma is not permitted after the rest element\");\n      }\n      return this.finishNode(prop, \"RestElement\")\n    }\n    // To disallow parenthesized identifier via `this.toAssignable()`.\n    if (this.type === types.parenL && refDestructuringErrors) {\n      if (refDestructuringErrors.parenthesizedAssign < 0) {\n        refDestructuringErrors.parenthesizedAssign = this.start;\n      }\n      if (refDestructuringErrors.parenthesizedBind < 0) {\n        refDestructuringErrors.parenthesizedBind = this.start;\n      }\n    }\n    // Parse argument.\n    prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);\n    // To disallow trailing comma via `this.toAssignable()`.\n    if (this.type === types.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {\n      refDestructuringErrors.trailingComma = this.start;\n    }\n    // Finish\n    return this.finishNode(prop, \"SpreadElement\")\n  }\n  if (this.options.ecmaVersion >= 6) {\n    prop.method = false;\n    prop.shorthand = false;\n    if (isPattern || refDestructuringErrors) {\n      startPos = this.start;\n      startLoc = this.startLoc;\n    }\n    if (!isPattern)\n      { isGenerator = this.eat(types.star); }\n  }\n  var containsEsc = this.containsEsc;\n  this.parsePropertyName(prop);\n  if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {\n    isAsync = true;\n    isGenerator = this.options.ecmaVersion >= 9 && this.eat(types.star);\n    this.parsePropertyName(prop, refDestructuringErrors);\n  } else {\n    isAsync = false;\n  }\n  this.parsePropertyValue(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc);\n  return this.finishNode(prop, \"Property\")\n};\n\npp$3.parsePropertyValue = function(prop, isPattern, isGenerator, isAsync, startPos, startLoc, refDestructuringErrors, containsEsc) {\n  if ((isGenerator || isAsync) && this.type === types.colon)\n    { this.unexpected(); }\n\n  if (this.eat(types.colon)) {\n    prop.value = isPattern ? this.parseMaybeDefault(this.start, this.startLoc) : this.parseMaybeAssign(false, refDestructuringErrors);\n    prop.kind = \"init\";\n  } else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {\n    if (isPattern) { this.unexpected(); }\n    prop.kind = \"init\";\n    prop.method = true;\n    prop.value = this.parseMethod(isGenerator, isAsync);\n  } else if (!isPattern && !containsEsc &&\n             this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === \"Identifier\" &&\n             (prop.key.name === \"get\" || prop.key.name === \"set\") &&\n             (this.type !== types.comma && this.type !== types.braceR)) {\n    if (isGenerator || isAsync) { this.unexpected(); }\n    prop.kind = prop.key.name;\n    this.parsePropertyName(prop);\n    prop.value = this.parseMethod(false);\n    var paramCount = prop.kind === \"get\" ? 0 : 1;\n    if (prop.value.params.length !== paramCount) {\n      var start = prop.value.start;\n      if (prop.kind === \"get\")\n        { this.raiseRecoverable(start, \"getter should have no params\"); }\n      else\n        { this.raiseRecoverable(start, \"setter should have exactly one param\"); }\n    } else {\n      if (prop.kind === \"set\" && prop.value.params[0].type === \"RestElement\")\n        { this.raiseRecoverable(prop.value.params[0].start, \"Setter cannot use rest params\"); }\n    }\n  } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === \"Identifier\") {\n    if (isGenerator || isAsync) { this.unexpected(); }\n    this.checkUnreserved(prop.key);\n    if (prop.key.name === \"await\" && !this.awaitIdentPos)\n      { this.awaitIdentPos = startPos; }\n    prop.kind = \"init\";\n    if (isPattern) {\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);\n    } else if (this.type === types.eq && refDestructuringErrors) {\n      if (refDestructuringErrors.shorthandAssign < 0)\n        { refDestructuringErrors.shorthandAssign = this.start; }\n      prop.value = this.parseMaybeDefault(startPos, startLoc, prop.key);\n    } else {\n      prop.value = prop.key;\n    }\n    prop.shorthand = true;\n  } else { this.unexpected(); }\n};\n\npp$3.parsePropertyName = function(prop) {\n  if (this.options.ecmaVersion >= 6) {\n    if (this.eat(types.bracketL)) {\n      prop.computed = true;\n      prop.key = this.parseMaybeAssign();\n      this.expect(types.bracketR);\n      return prop.key\n    } else {\n      prop.computed = false;\n    }\n  }\n  return prop.key = this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== \"never\")\n};\n\n// Initialize empty function node.\n\npp$3.initFunction = function(node) {\n  node.id = null;\n  if (this.options.ecmaVersion >= 6) { node.generator = node.expression = false; }\n  if (this.options.ecmaVersion >= 8) { node.async = false; }\n};\n\n// Parse object or class method.\n\npp$3.parseMethod = function(isGenerator, isAsync, allowDirectSuper) {\n  var node = this.startNode(), oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;\n\n  this.initFunction(node);\n  if (this.options.ecmaVersion >= 6)\n    { node.generator = isGenerator; }\n  if (this.options.ecmaVersion >= 8)\n    { node.async = !!isAsync; }\n\n  this.yieldPos = 0;\n  this.awaitPos = 0;\n  this.awaitIdentPos = 0;\n  this.enterScope(functionFlags(isAsync, node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));\n\n  this.expect(types.parenL);\n  node.params = this.parseBindingList(types.parenR, false, this.options.ecmaVersion >= 8);\n  this.checkYieldAwaitInDefaultParams();\n  this.parseFunctionBody(node, false, true);\n\n  this.yieldPos = oldYieldPos;\n  this.awaitPos = oldAwaitPos;\n  this.awaitIdentPos = oldAwaitIdentPos;\n  return this.finishNode(node, \"FunctionExpression\")\n};\n\n// Parse arrow function expression with given parameters.\n\npp$3.parseArrowExpression = function(node, params, isAsync) {\n  var oldYieldPos = this.yieldPos, oldAwaitPos = this.awaitPos, oldAwaitIdentPos = this.awaitIdentPos;\n\n  this.enterScope(functionFlags(isAsync, false) | SCOPE_ARROW);\n  this.initFunction(node);\n  if (this.options.ecmaVersion >= 8) { node.async = !!isAsync; }\n\n  this.yieldPos = 0;\n  this.awaitPos = 0;\n  this.awaitIdentPos = 0;\n\n  node.params = this.toAssignableList(params, true);\n  this.parseFunctionBody(node, true, false);\n\n  this.yieldPos = oldYieldPos;\n  this.awaitPos = oldAwaitPos;\n  this.awaitIdentPos = oldAwaitIdentPos;\n  return this.finishNode(node, \"ArrowFunctionExpression\")\n};\n\n// Parse function body and check parameters.\n\npp$3.parseFunctionBody = function(node, isArrowFunction, isMethod) {\n  var isExpression = isArrowFunction && this.type !== types.braceL;\n  var oldStrict = this.strict, useStrict = false;\n\n  if (isExpression) {\n    node.body = this.parseMaybeAssign();\n    node.expression = true;\n    this.checkParams(node, false);\n  } else {\n    var nonSimple = this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);\n    if (!oldStrict || nonSimple) {\n      useStrict = this.strictDirective(this.end);\n      // If this is a strict mode function, verify that argument names\n      // are not repeated, and it does not try to bind the words `eval`\n      // or `arguments`.\n      if (useStrict && nonSimple)\n        { this.raiseRecoverable(node.start, \"Illegal 'use strict' directive in function with non-simple parameter list\"); }\n    }\n    // Start a new scope with regard to labels and the `inFunction`\n    // flag (restore them to their old value afterwards).\n    var oldLabels = this.labels;\n    this.labels = [];\n    if (useStrict) { this.strict = true; }\n\n    // Add the params to varDeclaredNames to ensure that an error is thrown\n    // if a let/const declaration in the function clashes with one of the params.\n    this.checkParams(node, !oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params));\n    node.body = this.parseBlock(false);\n    node.expression = false;\n    this.adaptDirectivePrologue(node.body.body);\n    this.labels = oldLabels;\n  }\n  this.exitScope();\n\n  // Ensure the function name isn't a forbidden identifier in strict mode, e.g. 'eval'\n  if (this.strict && node.id) { this.checkLVal(node.id, BIND_OUTSIDE); }\n  this.strict = oldStrict;\n};\n\npp$3.isSimpleParamList = function(params) {\n  for (var i = 0, list = params; i < list.length; i += 1)\n    {\n    var param = list[i];\n\n    if (param.type !== \"Identifier\") { return false\n  } }\n  return true\n};\n\n// Checks function params for various disallowed patterns such as using \"eval\"\n// or \"arguments\" and duplicate parameters.\n\npp$3.checkParams = function(node, allowDuplicates) {\n  var nameHash = {};\n  for (var i = 0, list = node.params; i < list.length; i += 1)\n    {\n    var param = list[i];\n\n    this.checkLVal(param, BIND_VAR, allowDuplicates ? null : nameHash);\n  }\n};\n\n// Parses a comma-separated list of expressions, and returns them as\n// an array. `close` is the token type that ends the list, and\n// `allowEmpty` can be turned on to allow subsequent commas with\n// nothing in between them to be parsed as `null` (which is needed\n// for array literals).\n\npp$3.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestructuringErrors) {\n  var elts = [], first = true;\n  while (!this.eat(close)) {\n    if (!first) {\n      this.expect(types.comma);\n      if (allowTrailingComma && this.afterTrailingComma(close)) { break }\n    } else { first = false; }\n\n    var elt = (void 0);\n    if (allowEmpty && this.type === types.comma)\n      { elt = null; }\n    else if (this.type === types.ellipsis) {\n      elt = this.parseSpread(refDestructuringErrors);\n      if (refDestructuringErrors && this.type === types.comma && refDestructuringErrors.trailingComma < 0)\n        { refDestructuringErrors.trailingComma = this.start; }\n    } else {\n      elt = this.parseMaybeAssign(false, refDestructuringErrors);\n    }\n    elts.push(elt);\n  }\n  return elts\n};\n\npp$3.checkUnreserved = function(ref) {\n  var start = ref.start;\n  var end = ref.end;\n  var name = ref.name;\n\n  if (this.inGenerator && name === \"yield\")\n    { this.raiseRecoverable(start, \"Cannot use 'yield' as identifier inside a generator\"); }\n  if (this.inAsync && name === \"await\")\n    { this.raiseRecoverable(start, \"Cannot use 'await' as identifier inside an async function\"); }\n  if (this.keywords.test(name))\n    { this.raise(start, (\"Unexpected keyword '\" + name + \"'\")); }\n  if (this.options.ecmaVersion < 6 &&\n    this.input.slice(start, end).indexOf(\"\\\\\") !== -1) { return }\n  var re = this.strict ? this.reservedWordsStrict : this.reservedWords;\n  if (re.test(name)) {\n    if (!this.inAsync && name === \"await\")\n      { this.raiseRecoverable(start, \"Cannot use keyword 'await' outside an async function\"); }\n    this.raiseRecoverable(start, (\"The keyword '\" + name + \"' is reserved\"));\n  }\n};\n\n// Parse the next token as an identifier. If `liberal` is true (used\n// when parsing properties), it will also convert keywords into\n// identifiers.\n\npp$3.parseIdent = function(liberal, isBinding) {\n  var node = this.startNode();\n  if (this.type === types.name) {\n    node.name = this.value;\n  } else if (this.type.keyword) {\n    node.name = this.type.keyword;\n\n    // To fix https://github.com/acornjs/acorn/issues/575\n    // `class` and `function` keywords push new context into this.context.\n    // But there is no chance to pop the context if the keyword is consumed as an identifier such as a property name.\n    // If the previous token is a dot, this does not apply because the context-managing code already ignored the keyword\n    if ((node.name === \"class\" || node.name === \"function\") &&\n        (this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {\n      this.context.pop();\n    }\n  } else {\n    this.unexpected();\n  }\n  this.next();\n  this.finishNode(node, \"Identifier\");\n  if (!liberal) {\n    this.checkUnreserved(node);\n    if (node.name === \"await\" && !this.awaitIdentPos)\n      { this.awaitIdentPos = node.start; }\n  }\n  return node\n};\n\n// Parses yield expression inside generator.\n\npp$3.parseYield = function(noIn) {\n  if (!this.yieldPos) { this.yieldPos = this.start; }\n\n  var node = this.startNode();\n  this.next();\n  if (this.type === types.semi || this.canInsertSemicolon() || (this.type !== types.star && !this.type.startsExpr)) {\n    node.delegate = false;\n    node.argument = null;\n  } else {\n    node.delegate = this.eat(types.star);\n    node.argument = this.parseMaybeAssign(noIn);\n  }\n  return this.finishNode(node, \"YieldExpression\")\n};\n\npp$3.parseAwait = function() {\n  if (!this.awaitPos) { this.awaitPos = this.start; }\n\n  var node = this.startNode();\n  this.next();\n  node.argument = this.parseMaybeUnary(null, true);\n  return this.finishNode(node, \"AwaitExpression\")\n};\n\nvar pp$4 = Parser.prototype;\n\n// This function is used to raise exceptions on parse errors. It\n// takes an offset integer (into the current `input`) to indicate\n// the location of the error, attaches the position to the end\n// of the error message, and then raises a `SyntaxError` with that\n// message.\n\npp$4.raise = function(pos, message) {\n  var loc = getLineInfo(this.input, pos);\n  message += \" (\" + loc.line + \":\" + loc.column + \")\";\n  var err = new SyntaxError(message);\n  err.pos = pos; err.loc = loc; err.raisedAt = this.pos;\n  throw err\n};\n\npp$4.raiseRecoverable = pp$4.raise;\n\npp$4.curPosition = function() {\n  if (this.options.locations) {\n    return new Position(this.curLine, this.pos - this.lineStart)\n  }\n};\n\nvar pp$5 = Parser.prototype;\n\nvar Scope = function Scope(flags) {\n  this.flags = flags;\n  // A list of var-declared names in the current lexical scope\n  this.var = [];\n  // A list of lexically-declared names in the current lexical scope\n  this.lexical = [];\n  // A list of lexically-declared FunctionDeclaration names in the current lexical scope\n  this.functions = [];\n};\n\n// The functions in this module keep track of declared variables in the current scope in order to detect duplicate variable names.\n\npp$5.enterScope = function(flags) {\n  this.scopeStack.push(new Scope(flags));\n};\n\npp$5.exitScope = function() {\n  this.scopeStack.pop();\n};\n\n// The spec says:\n// > At the top level of a function, or script, function declarations are\n// > treated like var declarations rather than like lexical declarations.\npp$5.treatFunctionsAsVarInScope = function(scope) {\n  return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP)\n};\n\npp$5.declareName = function(name, bindingType, pos) {\n  var redeclared = false;\n  if (bindingType === BIND_LEXICAL) {\n    var scope = this.currentScope();\n    redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;\n    scope.lexical.push(name);\n    if (this.inModule && (scope.flags & SCOPE_TOP))\n      { delete this.undefinedExports[name]; }\n  } else if (bindingType === BIND_SIMPLE_CATCH) {\n    var scope$1 = this.currentScope();\n    scope$1.lexical.push(name);\n  } else if (bindingType === BIND_FUNCTION) {\n    var scope$2 = this.currentScope();\n    if (this.treatFunctionsAsVar)\n      { redeclared = scope$2.lexical.indexOf(name) > -1; }\n    else\n      { redeclared = scope$2.lexical.indexOf(name) > -1 || scope$2.var.indexOf(name) > -1; }\n    scope$2.functions.push(name);\n  } else {\n    for (var i = this.scopeStack.length - 1; i >= 0; --i) {\n      var scope$3 = this.scopeStack[i];\n      if (scope$3.lexical.indexOf(name) > -1 && !((scope$3.flags & SCOPE_SIMPLE_CATCH) && scope$3.lexical[0] === name) ||\n          !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name) > -1) {\n        redeclared = true;\n        break\n      }\n      scope$3.var.push(name);\n      if (this.inModule && (scope$3.flags & SCOPE_TOP))\n        { delete this.undefinedExports[name]; }\n      if (scope$3.flags & SCOPE_VAR) { break }\n    }\n  }\n  if (redeclared) { this.raiseRecoverable(pos, (\"Identifier '\" + name + \"' has already been declared\")); }\n};\n\npp$5.checkLocalExport = function(id) {\n  // scope.functions must be empty as Module code is always strict.\n  if (this.scopeStack[0].lexical.indexOf(id.name) === -1 &&\n      this.scopeStack[0].var.indexOf(id.name) === -1) {\n    this.undefinedExports[id.name] = id;\n  }\n};\n\npp$5.currentScope = function() {\n  return this.scopeStack[this.scopeStack.length - 1]\n};\n\npp$5.currentVarScope = function() {\n  for (var i = this.scopeStack.length - 1;; i--) {\n    var scope = this.scopeStack[i];\n    if (scope.flags & SCOPE_VAR) { return scope }\n  }\n};\n\n// Could be useful for `this`, `new.target`, `super()`, `super.property`, and `super[property]`.\npp$5.currentThisScope = function() {\n  for (var i = this.scopeStack.length - 1;; i--) {\n    var scope = this.scopeStack[i];\n    if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) { return scope }\n  }\n};\n\nvar Node = function Node(parser, pos, loc) {\n  this.type = \"\";\n  this.start = pos;\n  this.end = 0;\n  if (parser.options.locations)\n    { this.loc = new SourceLocation(parser, loc); }\n  if (parser.options.directSourceFile)\n    { this.sourceFile = parser.options.directSourceFile; }\n  if (parser.options.ranges)\n    { this.range = [pos, 0]; }\n};\n\n// Start an AST node, attaching a start offset.\n\nvar pp$6 = Parser.prototype;\n\npp$6.startNode = function() {\n  return new Node(this, this.start, this.startLoc)\n};\n\npp$6.startNodeAt = function(pos, loc) {\n  return new Node(this, pos, loc)\n};\n\n// Finish an AST node, adding `type` and `end` properties.\n\nfunction finishNodeAt(node, type, pos, loc) {\n  node.type = type;\n  node.end = pos;\n  if (this.options.locations)\n    { node.loc.end = loc; }\n  if (this.options.ranges)\n    { node.range[1] = pos; }\n  return node\n}\n\npp$6.finishNode = function(node, type) {\n  return finishNodeAt.call(this, node, type, this.lastTokEnd, this.lastTokEndLoc)\n};\n\n// Finish node at given position\n\npp$6.finishNodeAt = function(node, type, pos, loc) {\n  return finishNodeAt.call(this, node, type, pos, loc)\n};\n\n// The algorithm used to determine whether a regexp can appear at a\n\nvar TokContext = function TokContext(token, isExpr, preserveSpace, override, generator) {\n  this.token = token;\n  this.isExpr = !!isExpr;\n  this.preserveSpace = !!preserveSpace;\n  this.override = override;\n  this.generator = !!generator;\n};\n\nvar types$1 = {\n  b_stat: new TokContext(\"{\", false),\n  b_expr: new TokContext(\"{\", true),\n  b_tmpl: new TokContext(\"${\", false),\n  p_stat: new TokContext(\"(\", false),\n  p_expr: new TokContext(\"(\", true),\n  q_tmpl: new TokContext(\"`\", true, true, function (p) { return p.tryReadTemplateToken(); }),\n  f_stat: new TokContext(\"function\", false),\n  f_expr: new TokContext(\"function\", true),\n  f_expr_gen: new TokContext(\"function\", true, false, null, true),\n  f_gen: new TokContext(\"function\", false, false, null, true)\n};\n\nvar pp$7 = Parser.prototype;\n\npp$7.initialContext = function() {\n  return [types$1.b_stat]\n};\n\npp$7.braceIsBlock = function(prevType) {\n  var parent = this.curContext();\n  if (parent === types$1.f_expr || parent === types$1.f_stat)\n    { return true }\n  if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))\n    { return !parent.isExpr }\n\n  // The check for `tt.name && exprAllowed` detects whether we are\n  // after a `yield` or `of` construct. See the `updateContext` for\n  // `tt.name`.\n  if (prevType === types._return || prevType === types.name && this.exprAllowed)\n    { return lineBreak.test(this.input.slice(this.lastTokEnd, this.start)) }\n  if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType === types.arrow)\n    { return true }\n  if (prevType === types.braceL)\n    { return parent === types$1.b_stat }\n  if (prevType === types._var || prevType === types._const || prevType === types.name)\n    { return false }\n  return !this.exprAllowed\n};\n\npp$7.inGeneratorContext = function() {\n  for (var i = this.context.length - 1; i >= 1; i--) {\n    var context = this.context[i];\n    if (context.token === \"function\")\n      { return context.generator }\n  }\n  return false\n};\n\npp$7.updateContext = function(prevType) {\n  var update, type = this.type;\n  if (type.keyword && prevType === types.dot)\n    { this.exprAllowed = false; }\n  else if (update = type.updateContext)\n    { update.call(this, prevType); }\n  else\n    { this.exprAllowed = type.beforeExpr; }\n};\n\n// Token-specific context update code\n\ntypes.parenR.updateContext = types.braceR.updateContext = function() {\n  if (this.context.length === 1) {\n    this.exprAllowed = true;\n    return\n  }\n  var out = this.context.pop();\n  if (out === types$1.b_stat && this.curContext().token === \"function\") {\n    out = this.context.pop();\n  }\n  this.exprAllowed = !out.isExpr;\n};\n\ntypes.braceL.updateContext = function(prevType) {\n  this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);\n  this.exprAllowed = true;\n};\n\ntypes.dollarBraceL.updateContext = function() {\n  this.context.push(types$1.b_tmpl);\n  this.exprAllowed = true;\n};\n\ntypes.parenL.updateContext = function(prevType) {\n  var statementParens = prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;\n  this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);\n  this.exprAllowed = true;\n};\n\ntypes.incDec.updateContext = function() {\n  // tokExprAllowed stays unchanged\n};\n\ntypes._function.updateContext = types._class.updateContext = function(prevType) {\n  if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else &&\n      !(prevType === types._return && lineBreak.test(this.input.slice(this.lastTokEnd, this.start))) &&\n      !((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))\n    { this.context.push(types$1.f_expr); }\n  else\n    { this.context.push(types$1.f_stat); }\n  this.exprAllowed = false;\n};\n\ntypes.backQuote.updateContext = function() {\n  if (this.curContext() === types$1.q_tmpl)\n    { this.context.pop(); }\n  else\n    { this.context.push(types$1.q_tmpl); }\n  this.exprAllowed = false;\n};\n\ntypes.star.updateContext = function(prevType) {\n  if (prevType === types._function) {\n    var index = this.context.length - 1;\n    if (this.context[index] === types$1.f_expr)\n      { this.context[index] = types$1.f_expr_gen; }\n    else\n      { this.context[index] = types$1.f_gen; }\n  }\n  this.exprAllowed = true;\n};\n\ntypes.name.updateContext = function(prevType) {\n  var allowed = false;\n  if (this.options.ecmaVersion >= 6 && prevType !== types.dot) {\n    if (this.value === \"of\" && !this.exprAllowed ||\n        this.value === \"yield\" && this.inGeneratorContext())\n      { allowed = true; }\n  }\n  this.exprAllowed = allowed;\n};\n\n// This file contains Unicode properties extracted from the ECMAScript\n// specification. The lists are extracted like so:\n// $$('#table-binary-unicode-properties > figure > table > tbody > tr > td:nth-child(1) code').map(el => el.innerText)\n\n// #table-binary-unicode-properties\nvar ecma9BinaryProperties = \"ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS\";\nvar ecma10BinaryProperties = ecma9BinaryProperties + \" Extended_Pictographic\";\nvar ecma11BinaryProperties = ecma10BinaryProperties;\nvar unicodeBinaryProperties = {\n  9: ecma9BinaryProperties,\n  10: ecma10BinaryProperties,\n  11: ecma11BinaryProperties\n};\n\n// #table-unicode-general-category-values\nvar unicodeGeneralCategoryValues = \"Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu\";\n\n// #table-unicode-script-values\nvar ecma9ScriptValues = \"Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb\";\nvar ecma10ScriptValues = ecma9ScriptValues + \" Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd\";\nvar ecma11ScriptValues = ecma10ScriptValues + \" Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho\";\nvar unicodeScriptValues = {\n  9: ecma9ScriptValues,\n  10: ecma10ScriptValues,\n  11: ecma11ScriptValues\n};\n\nvar data = {};\nfunction buildUnicodeData(ecmaVersion) {\n  var d = data[ecmaVersion] = {\n    binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + \" \" + unicodeGeneralCategoryValues),\n    nonBinary: {\n      General_Category: wordsRegexp(unicodeGeneralCategoryValues),\n      Script: wordsRegexp(unicodeScriptValues[ecmaVersion])\n    }\n  };\n  d.nonBinary.Script_Extensions = d.nonBinary.Script;\n\n  d.nonBinary.gc = d.nonBinary.General_Category;\n  d.nonBinary.sc = d.nonBinary.Script;\n  d.nonBinary.scx = d.nonBinary.Script_Extensions;\n}\nbuildUnicodeData(9);\nbuildUnicodeData(10);\nbuildUnicodeData(11);\n\nvar pp$8 = Parser.prototype;\n\nvar RegExpValidationState = function RegExpValidationState(parser) {\n  this.parser = parser;\n  this.validFlags = \"gim\" + (parser.options.ecmaVersion >= 6 ? \"uy\" : \"\") + (parser.options.ecmaVersion >= 9 ? \"s\" : \"\");\n  this.unicodeProperties = data[parser.options.ecmaVersion >= 11 ? 11 : parser.options.ecmaVersion];\n  this.source = \"\";\n  this.flags = \"\";\n  this.start = 0;\n  this.switchU = false;\n  this.switchN = false;\n  this.pos = 0;\n  this.lastIntValue = 0;\n  this.lastStringValue = \"\";\n  this.lastAssertionIsQuantifiable = false;\n  this.numCapturingParens = 0;\n  this.maxBackReference = 0;\n  this.groupNames = [];\n  this.backReferenceNames = [];\n};\n\nRegExpValidationState.prototype.reset = function reset (start, pattern, flags) {\n  var unicode = flags.indexOf(\"u\") !== -1;\n  this.start = start | 0;\n  this.source = pattern + \"\";\n  this.flags = flags;\n  this.switchU = unicode && this.parser.options.ecmaVersion >= 6;\n  this.switchN = unicode && this.parser.options.ecmaVersion >= 9;\n};\n\nRegExpValidationState.prototype.raise = function raise (message) {\n  this.parser.raiseRecoverable(this.start, (\"Invalid regular expression: /\" + (this.source) + \"/: \" + message));\n};\n\n// If u flag is given, this returns the code point at the index (it combines a surrogate pair).\n// Otherwise, this returns the code unit of the index (can be a part of a surrogate pair).\nRegExpValidationState.prototype.at = function at (i) {\n  var s = this.source;\n  var l = s.length;\n  if (i >= l) {\n    return -1\n  }\n  var c = s.charCodeAt(i);\n  if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {\n    return c\n  }\n  return (c << 10) + s.charCodeAt(i + 1) - 0x35FDC00\n};\n\nRegExpValidationState.prototype.nextIndex = function nextIndex (i) {\n  var s = this.source;\n  var l = s.length;\n  if (i >= l) {\n    return l\n  }\n  var c = s.charCodeAt(i);\n  if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {\n    return i + 1\n  }\n  return i + 2\n};\n\nRegExpValidationState.prototype.current = function current () {\n  return this.at(this.pos)\n};\n\nRegExpValidationState.prototype.lookahead = function lookahead () {\n  return this.at(this.nextIndex(this.pos))\n};\n\nRegExpValidationState.prototype.advance = function advance () {\n  this.pos = this.nextIndex(this.pos);\n};\n\nRegExpValidationState.prototype.eat = function eat (ch) {\n  if (this.current() === ch) {\n    this.advance();\n    return true\n  }\n  return false\n};\n\nfunction codePointToString(ch) {\n  if (ch <= 0xFFFF) { return String.fromCharCode(ch) }\n  ch -= 0x10000;\n  return String.fromCharCode((ch >> 10) + 0xD800, (ch & 0x03FF) + 0xDC00)\n}\n\n/**\n * Validate the flags part of a given RegExpLiteral.\n *\n * @param {RegExpValidationState} state The state to validate RegExp.\n * @returns {void}\n */\npp$8.validateRegExpFlags = function(state) {\n  var validFlags = state.validFlags;\n  var flags = state.flags;\n\n  for (var i = 0; i < flags.length; i++) {\n    var flag = flags.charAt(i);\n    if (validFlags.indexOf(flag) === -1) {\n      this.raise(state.start, \"Invalid regular expression flag\");\n    }\n    if (flags.indexOf(flag, i + 1) > -1) {\n      this.raise(state.start, \"Duplicate regular expression flag\");\n    }\n  }\n};\n\n/**\n * Validate the pattern part of a given RegExpLiteral.\n *\n * @param {RegExpValidationState} state The state to validate RegExp.\n * @returns {void}\n */\npp$8.validateRegExpPattern = function(state) {\n  this.regexp_pattern(state);\n\n  // The goal symbol for the parse is |Pattern[~U, ~N]|. If the result of\n  // parsing contains a |GroupName|, reparse with the goal symbol\n  // |Pattern[~U, +N]| and use this result instead. Throw a *SyntaxError*\n  // exception if _P_ did not conform to the grammar, if any elements of _P_\n  // were not matched by the parse, or if any Early Error conditions exist.\n  if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {\n    state.switchN = true;\n    this.regexp_pattern(state);\n  }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Pattern\npp$8.regexp_pattern = function(state) {\n  state.pos = 0;\n  state.lastIntValue = 0;\n  state.lastStringValue = \"\";\n  state.lastAssertionIsQuantifiable = false;\n  state.numCapturingParens = 0;\n  state.maxBackReference = 0;\n  state.groupNames.length = 0;\n  state.backReferenceNames.length = 0;\n\n  this.regexp_disjunction(state);\n\n  if (state.pos !== state.source.length) {\n    // Make the same messages as V8.\n    if (state.eat(0x29 /* ) */)) {\n      state.raise(\"Unmatched ')'\");\n    }\n    if (state.eat(0x5D /* [ */) || state.eat(0x7D /* } */)) {\n      state.raise(\"Lone quantifier brackets\");\n    }\n  }\n  if (state.maxBackReference > state.numCapturingParens) {\n    state.raise(\"Invalid escape\");\n  }\n  for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {\n    var name = list[i];\n\n    if (state.groupNames.indexOf(name) === -1) {\n      state.raise(\"Invalid named capture referenced\");\n    }\n  }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Disjunction\npp$8.regexp_disjunction = function(state) {\n  this.regexp_alternative(state);\n  while (state.eat(0x7C /* | */)) {\n    this.regexp_alternative(state);\n  }\n\n  // Make the same message as V8.\n  if (this.regexp_eatQuantifier(state, true)) {\n    state.raise(\"Nothing to repeat\");\n  }\n  if (state.eat(0x7B /* { */)) {\n    state.raise(\"Lone quantifier brackets\");\n  }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Alternative\npp$8.regexp_alternative = function(state) {\n  while (state.pos < state.source.length && this.regexp_eatTerm(state))\n    { }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Term\npp$8.regexp_eatTerm = function(state) {\n  if (this.regexp_eatAssertion(state)) {\n    // Handle `QuantifiableAssertion Quantifier` alternative.\n    // `state.lastAssertionIsQuantifiable` is true if the last eaten Assertion\n    // is a QuantifiableAssertion.\n    if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {\n      // Make the same message as V8.\n      if (state.switchU) {\n        state.raise(\"Invalid quantifier\");\n      }\n    }\n    return true\n  }\n\n  if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {\n    this.regexp_eatQuantifier(state);\n    return true\n  }\n\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-Assertion\npp$8.regexp_eatAssertion = function(state) {\n  var start = state.pos;\n  state.lastAssertionIsQuantifiable = false;\n\n  // ^, $\n  if (state.eat(0x5E /* ^ */) || state.eat(0x24 /* $ */)) {\n    return true\n  }\n\n  // \\b \\B\n  if (state.eat(0x5C /* \\ */)) {\n    if (state.eat(0x42 /* B */) || state.eat(0x62 /* b */)) {\n      return true\n    }\n    state.pos = start;\n  }\n\n  // Lookahead / Lookbehind\n  if (state.eat(0x28 /* ( */) && state.eat(0x3F /* ? */)) {\n    var lookbehind = false;\n    if (this.options.ecmaVersion >= 9) {\n      lookbehind = state.eat(0x3C /* < */);\n    }\n    if (state.eat(0x3D /* = */) || state.eat(0x21 /* ! */)) {\n      this.regexp_disjunction(state);\n      if (!state.eat(0x29 /* ) */)) {\n        state.raise(\"Unterminated group\");\n      }\n      state.lastAssertionIsQuantifiable = !lookbehind;\n      return true\n    }\n  }\n\n  state.pos = start;\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Quantifier\npp$8.regexp_eatQuantifier = function(state, noError) {\n  if ( noError === void 0 ) noError = false;\n\n  if (this.regexp_eatQuantifierPrefix(state, noError)) {\n    state.eat(0x3F /* ? */);\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-QuantifierPrefix\npp$8.regexp_eatQuantifierPrefix = function(state, noError) {\n  return (\n    state.eat(0x2A /* * */) ||\n    state.eat(0x2B /* + */) ||\n    state.eat(0x3F /* ? */) ||\n    this.regexp_eatBracedQuantifier(state, noError)\n  )\n};\npp$8.regexp_eatBracedQuantifier = function(state, noError) {\n  var start = state.pos;\n  if (state.eat(0x7B /* { */)) {\n    var min = 0, max = -1;\n    if (this.regexp_eatDecimalDigits(state)) {\n      min = state.lastIntValue;\n      if (state.eat(0x2C /* , */) && this.regexp_eatDecimalDigits(state)) {\n        max = state.lastIntValue;\n      }\n      if (state.eat(0x7D /* } */)) {\n        // SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-term\n        if (max !== -1 && max < min && !noError) {\n          state.raise(\"numbers out of order in {} quantifier\");\n        }\n        return true\n      }\n    }\n    if (state.switchU && !noError) {\n      state.raise(\"Incomplete quantifier\");\n    }\n    state.pos = start;\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Atom\npp$8.regexp_eatAtom = function(state) {\n  return (\n    this.regexp_eatPatternCharacters(state) ||\n    state.eat(0x2E /* . */) ||\n    this.regexp_eatReverseSolidusAtomEscape(state) ||\n    this.regexp_eatCharacterClass(state) ||\n    this.regexp_eatUncapturingGroup(state) ||\n    this.regexp_eatCapturingGroup(state)\n  )\n};\npp$8.regexp_eatReverseSolidusAtomEscape = function(state) {\n  var start = state.pos;\n  if (state.eat(0x5C /* \\ */)) {\n    if (this.regexp_eatAtomEscape(state)) {\n      return true\n    }\n    state.pos = start;\n  }\n  return false\n};\npp$8.regexp_eatUncapturingGroup = function(state) {\n  var start = state.pos;\n  if (state.eat(0x28 /* ( */)) {\n    if (state.eat(0x3F /* ? */) && state.eat(0x3A /* : */)) {\n      this.regexp_disjunction(state);\n      if (state.eat(0x29 /* ) */)) {\n        return true\n      }\n      state.raise(\"Unterminated group\");\n    }\n    state.pos = start;\n  }\n  return false\n};\npp$8.regexp_eatCapturingGroup = function(state) {\n  if (state.eat(0x28 /* ( */)) {\n    if (this.options.ecmaVersion >= 9) {\n      this.regexp_groupSpecifier(state);\n    } else if (state.current() === 0x3F /* ? */) {\n      state.raise(\"Invalid group\");\n    }\n    this.regexp_disjunction(state);\n    if (state.eat(0x29 /* ) */)) {\n      state.numCapturingParens += 1;\n      return true\n    }\n    state.raise(\"Unterminated group\");\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedAtom\npp$8.regexp_eatExtendedAtom = function(state) {\n  return (\n    state.eat(0x2E /* . */) ||\n    this.regexp_eatReverseSolidusAtomEscape(state) ||\n    this.regexp_eatCharacterClass(state) ||\n    this.regexp_eatUncapturingGroup(state) ||\n    this.regexp_eatCapturingGroup(state) ||\n    this.regexp_eatInvalidBracedQuantifier(state) ||\n    this.regexp_eatExtendedPatternCharacter(state)\n  )\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-InvalidBracedQuantifier\npp$8.regexp_eatInvalidBracedQuantifier = function(state) {\n  if (this.regexp_eatBracedQuantifier(state, true)) {\n    state.raise(\"Nothing to repeat\");\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-SyntaxCharacter\npp$8.regexp_eatSyntaxCharacter = function(state) {\n  var ch = state.current();\n  if (isSyntaxCharacter(ch)) {\n    state.lastIntValue = ch;\n    state.advance();\n    return true\n  }\n  return false\n};\nfunction isSyntaxCharacter(ch) {\n  return (\n    ch === 0x24 /* $ */ ||\n    ch >= 0x28 /* ( */ && ch <= 0x2B /* + */ ||\n    ch === 0x2E /* . */ ||\n    ch === 0x3F /* ? */ ||\n    ch >= 0x5B /* [ */ && ch <= 0x5E /* ^ */ ||\n    ch >= 0x7B /* { */ && ch <= 0x7D /* } */\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-PatternCharacter\n// But eat eager.\npp$8.regexp_eatPatternCharacters = function(state) {\n  var start = state.pos;\n  var ch = 0;\n  while ((ch = state.current()) !== -1 && !isSyntaxCharacter(ch)) {\n    state.advance();\n  }\n  return state.pos !== start\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ExtendedPatternCharacter\npp$8.regexp_eatExtendedPatternCharacter = function(state) {\n  var ch = state.current();\n  if (\n    ch !== -1 &&\n    ch !== 0x24 /* $ */ &&\n    !(ch >= 0x28 /* ( */ && ch <= 0x2B /* + */) &&\n    ch !== 0x2E /* . */ &&\n    ch !== 0x3F /* ? */ &&\n    ch !== 0x5B /* [ */ &&\n    ch !== 0x5E /* ^ */ &&\n    ch !== 0x7C /* | */\n  ) {\n    state.advance();\n    return true\n  }\n  return false\n};\n\n// GroupSpecifier[U] ::\n//   [empty]\n//   `?` GroupName[?U]\npp$8.regexp_groupSpecifier = function(state) {\n  if (state.eat(0x3F /* ? */)) {\n    if (this.regexp_eatGroupName(state)) {\n      if (state.groupNames.indexOf(state.lastStringValue) !== -1) {\n        state.raise(\"Duplicate capture group name\");\n      }\n      state.groupNames.push(state.lastStringValue);\n      return\n    }\n    state.raise(\"Invalid group\");\n  }\n};\n\n// GroupName[U] ::\n//   `<` RegExpIdentifierName[?U] `>`\n// Note: this updates `state.lastStringValue` property with the eaten name.\npp$8.regexp_eatGroupName = function(state) {\n  state.lastStringValue = \"\";\n  if (state.eat(0x3C /* < */)) {\n    if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E /* > */)) {\n      return true\n    }\n    state.raise(\"Invalid capture group name\");\n  }\n  return false\n};\n\n// RegExpIdentifierName[U] ::\n//   RegExpIdentifierStart[?U]\n//   RegExpIdentifierName[?U] RegExpIdentifierPart[?U]\n// Note: this updates `state.lastStringValue` property with the eaten name.\npp$8.regexp_eatRegExpIdentifierName = function(state) {\n  state.lastStringValue = \"\";\n  if (this.regexp_eatRegExpIdentifierStart(state)) {\n    state.lastStringValue += codePointToString(state.lastIntValue);\n    while (this.regexp_eatRegExpIdentifierPart(state)) {\n      state.lastStringValue += codePointToString(state.lastIntValue);\n    }\n    return true\n  }\n  return false\n};\n\n// RegExpIdentifierStart[U] ::\n//   UnicodeIDStart\n//   `$`\n//   `_`\n//   `\\` RegExpUnicodeEscapeSequence[?U]\npp$8.regexp_eatRegExpIdentifierStart = function(state) {\n  var start = state.pos;\n  var ch = state.current();\n  state.advance();\n\n  if (ch === 0x5C /* \\ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {\n    ch = state.lastIntValue;\n  }\n  if (isRegExpIdentifierStart(ch)) {\n    state.lastIntValue = ch;\n    return true\n  }\n\n  state.pos = start;\n  return false\n};\nfunction isRegExpIdentifierStart(ch) {\n  return isIdentifierStart(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */\n}\n\n// RegExpIdentifierPart[U] ::\n//   UnicodeIDContinue\n//   `$`\n//   `_`\n//   `\\` RegExpUnicodeEscapeSequence[?U]\n//   <ZWNJ>\n//   <ZWJ>\npp$8.regexp_eatRegExpIdentifierPart = function(state) {\n  var start = state.pos;\n  var ch = state.current();\n  state.advance();\n\n  if (ch === 0x5C /* \\ */ && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {\n    ch = state.lastIntValue;\n  }\n  if (isRegExpIdentifierPart(ch)) {\n    state.lastIntValue = ch;\n    return true\n  }\n\n  state.pos = start;\n  return false\n};\nfunction isRegExpIdentifierPart(ch) {\n  return isIdentifierChar(ch, true) || ch === 0x24 /* $ */ || ch === 0x5F /* _ */ || ch === 0x200C /* <ZWNJ> */ || ch === 0x200D /* <ZWJ> */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-AtomEscape\npp$8.regexp_eatAtomEscape = function(state) {\n  if (\n    this.regexp_eatBackReference(state) ||\n    this.regexp_eatCharacterClassEscape(state) ||\n    this.regexp_eatCharacterEscape(state) ||\n    (state.switchN && this.regexp_eatKGroupName(state))\n  ) {\n    return true\n  }\n  if (state.switchU) {\n    // Make the same message as V8.\n    if (state.current() === 0x63 /* c */) {\n      state.raise(\"Invalid unicode escape\");\n    }\n    state.raise(\"Invalid escape\");\n  }\n  return false\n};\npp$8.regexp_eatBackReference = function(state) {\n  var start = state.pos;\n  if (this.regexp_eatDecimalEscape(state)) {\n    var n = state.lastIntValue;\n    if (state.switchU) {\n      // For SyntaxError in https://www.ecma-international.org/ecma-262/8.0/#sec-atomescape\n      if (n > state.maxBackReference) {\n        state.maxBackReference = n;\n      }\n      return true\n    }\n    if (n <= state.numCapturingParens) {\n      return true\n    }\n    state.pos = start;\n  }\n  return false\n};\npp$8.regexp_eatKGroupName = function(state) {\n  if (state.eat(0x6B /* k */)) {\n    if (this.regexp_eatGroupName(state)) {\n      state.backReferenceNames.push(state.lastStringValue);\n      return true\n    }\n    state.raise(\"Invalid named reference\");\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-CharacterEscape\npp$8.regexp_eatCharacterEscape = function(state) {\n  return (\n    this.regexp_eatControlEscape(state) ||\n    this.regexp_eatCControlLetter(state) ||\n    this.regexp_eatZero(state) ||\n    this.regexp_eatHexEscapeSequence(state) ||\n    this.regexp_eatRegExpUnicodeEscapeSequence(state) ||\n    (!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||\n    this.regexp_eatIdentityEscape(state)\n  )\n};\npp$8.regexp_eatCControlLetter = function(state) {\n  var start = state.pos;\n  if (state.eat(0x63 /* c */)) {\n    if (this.regexp_eatControlLetter(state)) {\n      return true\n    }\n    state.pos = start;\n  }\n  return false\n};\npp$8.regexp_eatZero = function(state) {\n  if (state.current() === 0x30 /* 0 */ && !isDecimalDigit(state.lookahead())) {\n    state.lastIntValue = 0;\n    state.advance();\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlEscape\npp$8.regexp_eatControlEscape = function(state) {\n  var ch = state.current();\n  if (ch === 0x74 /* t */) {\n    state.lastIntValue = 0x09; /* \\t */\n    state.advance();\n    return true\n  }\n  if (ch === 0x6E /* n */) {\n    state.lastIntValue = 0x0A; /* \\n */\n    state.advance();\n    return true\n  }\n  if (ch === 0x76 /* v */) {\n    state.lastIntValue = 0x0B; /* \\v */\n    state.advance();\n    return true\n  }\n  if (ch === 0x66 /* f */) {\n    state.lastIntValue = 0x0C; /* \\f */\n    state.advance();\n    return true\n  }\n  if (ch === 0x72 /* r */) {\n    state.lastIntValue = 0x0D; /* \\r */\n    state.advance();\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ControlLetter\npp$8.regexp_eatControlLetter = function(state) {\n  var ch = state.current();\n  if (isControlLetter(ch)) {\n    state.lastIntValue = ch % 0x20;\n    state.advance();\n    return true\n  }\n  return false\n};\nfunction isControlLetter(ch) {\n  return (\n    (ch >= 0x41 /* A */ && ch <= 0x5A /* Z */) ||\n    (ch >= 0x61 /* a */ && ch <= 0x7A /* z */)\n  )\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-RegExpUnicodeEscapeSequence\npp$8.regexp_eatRegExpUnicodeEscapeSequence = function(state) {\n  var start = state.pos;\n\n  if (state.eat(0x75 /* u */)) {\n    if (this.regexp_eatFixedHexDigits(state, 4)) {\n      var lead = state.lastIntValue;\n      if (state.switchU && lead >= 0xD800 && lead <= 0xDBFF) {\n        var leadSurrogateEnd = state.pos;\n        if (state.eat(0x5C /* \\ */) && state.eat(0x75 /* u */) && this.regexp_eatFixedHexDigits(state, 4)) {\n          var trail = state.lastIntValue;\n          if (trail >= 0xDC00 && trail <= 0xDFFF) {\n            state.lastIntValue = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;\n            return true\n          }\n        }\n        state.pos = leadSurrogateEnd;\n        state.lastIntValue = lead;\n      }\n      return true\n    }\n    if (\n      state.switchU &&\n      state.eat(0x7B /* { */) &&\n      this.regexp_eatHexDigits(state) &&\n      state.eat(0x7D /* } */) &&\n      isValidUnicode(state.lastIntValue)\n    ) {\n      return true\n    }\n    if (state.switchU) {\n      state.raise(\"Invalid unicode escape\");\n    }\n    state.pos = start;\n  }\n\n  return false\n};\nfunction isValidUnicode(ch) {\n  return ch >= 0 && ch <= 0x10FFFF\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-IdentityEscape\npp$8.regexp_eatIdentityEscape = function(state) {\n  if (state.switchU) {\n    if (this.regexp_eatSyntaxCharacter(state)) {\n      return true\n    }\n    if (state.eat(0x2F /* / */)) {\n      state.lastIntValue = 0x2F; /* / */\n      return true\n    }\n    return false\n  }\n\n  var ch = state.current();\n  if (ch !== 0x63 /* c */ && (!state.switchN || ch !== 0x6B /* k */)) {\n    state.lastIntValue = ch;\n    state.advance();\n    return true\n  }\n\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalEscape\npp$8.regexp_eatDecimalEscape = function(state) {\n  state.lastIntValue = 0;\n  var ch = state.current();\n  if (ch >= 0x31 /* 1 */ && ch <= 0x39 /* 9 */) {\n    do {\n      state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);\n      state.advance();\n    } while ((ch = state.current()) >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */)\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClassEscape\npp$8.regexp_eatCharacterClassEscape = function(state) {\n  var ch = state.current();\n\n  if (isCharacterClassEscape(ch)) {\n    state.lastIntValue = -1;\n    state.advance();\n    return true\n  }\n\n  if (\n    state.switchU &&\n    this.options.ecmaVersion >= 9 &&\n    (ch === 0x50 /* P */ || ch === 0x70 /* p */)\n  ) {\n    state.lastIntValue = -1;\n    state.advance();\n    if (\n      state.eat(0x7B /* { */) &&\n      this.regexp_eatUnicodePropertyValueExpression(state) &&\n      state.eat(0x7D /* } */)\n    ) {\n      return true\n    }\n    state.raise(\"Invalid property name\");\n  }\n\n  return false\n};\nfunction isCharacterClassEscape(ch) {\n  return (\n    ch === 0x64 /* d */ ||\n    ch === 0x44 /* D */ ||\n    ch === 0x73 /* s */ ||\n    ch === 0x53 /* S */ ||\n    ch === 0x77 /* w */ ||\n    ch === 0x57 /* W */\n  )\n}\n\n// UnicodePropertyValueExpression ::\n//   UnicodePropertyName `=` UnicodePropertyValue\n//   LoneUnicodePropertyNameOrValue\npp$8.regexp_eatUnicodePropertyValueExpression = function(state) {\n  var start = state.pos;\n\n  // UnicodePropertyName `=` UnicodePropertyValue\n  if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D /* = */)) {\n    var name = state.lastStringValue;\n    if (this.regexp_eatUnicodePropertyValue(state)) {\n      var value = state.lastStringValue;\n      this.regexp_validateUnicodePropertyNameAndValue(state, name, value);\n      return true\n    }\n  }\n  state.pos = start;\n\n  // LoneUnicodePropertyNameOrValue\n  if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {\n    var nameOrValue = state.lastStringValue;\n    this.regexp_validateUnicodePropertyNameOrValue(state, nameOrValue);\n    return true\n  }\n  return false\n};\npp$8.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {\n  if (!has(state.unicodeProperties.nonBinary, name))\n    { state.raise(\"Invalid property name\"); }\n  if (!state.unicodeProperties.nonBinary[name].test(value))\n    { state.raise(\"Invalid property value\"); }\n};\npp$8.regexp_validateUnicodePropertyNameOrValue = function(state, nameOrValue) {\n  if (!state.unicodeProperties.binary.test(nameOrValue))\n    { state.raise(\"Invalid property name\"); }\n};\n\n// UnicodePropertyName ::\n//   UnicodePropertyNameCharacters\npp$8.regexp_eatUnicodePropertyName = function(state) {\n  var ch = 0;\n  state.lastStringValue = \"\";\n  while (isUnicodePropertyNameCharacter(ch = state.current())) {\n    state.lastStringValue += codePointToString(ch);\n    state.advance();\n  }\n  return state.lastStringValue !== \"\"\n};\nfunction isUnicodePropertyNameCharacter(ch) {\n  return isControlLetter(ch) || ch === 0x5F /* _ */\n}\n\n// UnicodePropertyValue ::\n//   UnicodePropertyValueCharacters\npp$8.regexp_eatUnicodePropertyValue = function(state) {\n  var ch = 0;\n  state.lastStringValue = \"\";\n  while (isUnicodePropertyValueCharacter(ch = state.current())) {\n    state.lastStringValue += codePointToString(ch);\n    state.advance();\n  }\n  return state.lastStringValue !== \"\"\n};\nfunction isUnicodePropertyValueCharacter(ch) {\n  return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)\n}\n\n// LoneUnicodePropertyNameOrValue ::\n//   UnicodePropertyValueCharacters\npp$8.regexp_eatLoneUnicodePropertyNameOrValue = function(state) {\n  return this.regexp_eatUnicodePropertyValue(state)\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-CharacterClass\npp$8.regexp_eatCharacterClass = function(state) {\n  if (state.eat(0x5B /* [ */)) {\n    state.eat(0x5E /* ^ */);\n    this.regexp_classRanges(state);\n    if (state.eat(0x5D /* [ */)) {\n      return true\n    }\n    // Unreachable since it threw \"unterminated regular expression\" error before.\n    state.raise(\"Unterminated character class\");\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassRanges\n// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRanges\n// https://www.ecma-international.org/ecma-262/8.0/#prod-NonemptyClassRangesNoDash\npp$8.regexp_classRanges = function(state) {\n  while (this.regexp_eatClassAtom(state)) {\n    var left = state.lastIntValue;\n    if (state.eat(0x2D /* - */) && this.regexp_eatClassAtom(state)) {\n      var right = state.lastIntValue;\n      if (state.switchU && (left === -1 || right === -1)) {\n        state.raise(\"Invalid character class\");\n      }\n      if (left !== -1 && right !== -1 && left > right) {\n        state.raise(\"Range out of order in character class\");\n      }\n    }\n  }\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtom\n// https://www.ecma-international.org/ecma-262/8.0/#prod-ClassAtomNoDash\npp$8.regexp_eatClassAtom = function(state) {\n  var start = state.pos;\n\n  if (state.eat(0x5C /* \\ */)) {\n    if (this.regexp_eatClassEscape(state)) {\n      return true\n    }\n    if (state.switchU) {\n      // Make the same message as V8.\n      var ch$1 = state.current();\n      if (ch$1 === 0x63 /* c */ || isOctalDigit(ch$1)) {\n        state.raise(\"Invalid class escape\");\n      }\n      state.raise(\"Invalid escape\");\n    }\n    state.pos = start;\n  }\n\n  var ch = state.current();\n  if (ch !== 0x5D /* [ */) {\n    state.lastIntValue = ch;\n    state.advance();\n    return true\n  }\n\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassEscape\npp$8.regexp_eatClassEscape = function(state) {\n  var start = state.pos;\n\n  if (state.eat(0x62 /* b */)) {\n    state.lastIntValue = 0x08; /* <BS> */\n    return true\n  }\n\n  if (state.switchU && state.eat(0x2D /* - */)) {\n    state.lastIntValue = 0x2D; /* - */\n    return true\n  }\n\n  if (!state.switchU && state.eat(0x63 /* c */)) {\n    if (this.regexp_eatClassControlLetter(state)) {\n      return true\n    }\n    state.pos = start;\n  }\n\n  return (\n    this.regexp_eatCharacterClassEscape(state) ||\n    this.regexp_eatCharacterEscape(state)\n  )\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-ClassControlLetter\npp$8.regexp_eatClassControlLetter = function(state) {\n  var ch = state.current();\n  if (isDecimalDigit(ch) || ch === 0x5F /* _ */) {\n    state.lastIntValue = ch % 0x20;\n    state.advance();\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence\npp$8.regexp_eatHexEscapeSequence = function(state) {\n  var start = state.pos;\n  if (state.eat(0x78 /* x */)) {\n    if (this.regexp_eatFixedHexDigits(state, 2)) {\n      return true\n    }\n    if (state.switchU) {\n      state.raise(\"Invalid escape\");\n    }\n    state.pos = start;\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-DecimalDigits\npp$8.regexp_eatDecimalDigits = function(state) {\n  var start = state.pos;\n  var ch = 0;\n  state.lastIntValue = 0;\n  while (isDecimalDigit(ch = state.current())) {\n    state.lastIntValue = 10 * state.lastIntValue + (ch - 0x30 /* 0 */);\n    state.advance();\n  }\n  return state.pos !== start\n};\nfunction isDecimalDigit(ch) {\n  return ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigits\npp$8.regexp_eatHexDigits = function(state) {\n  var start = state.pos;\n  var ch = 0;\n  state.lastIntValue = 0;\n  while (isHexDigit(ch = state.current())) {\n    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);\n    state.advance();\n  }\n  return state.pos !== start\n};\nfunction isHexDigit(ch) {\n  return (\n    (ch >= 0x30 /* 0 */ && ch <= 0x39 /* 9 */) ||\n    (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) ||\n    (ch >= 0x61 /* a */ && ch <= 0x66 /* f */)\n  )\n}\nfunction hexToInt(ch) {\n  if (ch >= 0x41 /* A */ && ch <= 0x46 /* F */) {\n    return 10 + (ch - 0x41 /* A */)\n  }\n  if (ch >= 0x61 /* a */ && ch <= 0x66 /* f */) {\n    return 10 + (ch - 0x61 /* a */)\n  }\n  return ch - 0x30 /* 0 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-annexB-LegacyOctalEscapeSequence\n// Allows only 0-377(octal) i.e. 0-255(decimal).\npp$8.regexp_eatLegacyOctalEscapeSequence = function(state) {\n  if (this.regexp_eatOctalDigit(state)) {\n    var n1 = state.lastIntValue;\n    if (this.regexp_eatOctalDigit(state)) {\n      var n2 = state.lastIntValue;\n      if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {\n        state.lastIntValue = n1 * 64 + n2 * 8 + state.lastIntValue;\n      } else {\n        state.lastIntValue = n1 * 8 + n2;\n      }\n    } else {\n      state.lastIntValue = n1;\n    }\n    return true\n  }\n  return false\n};\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-OctalDigit\npp$8.regexp_eatOctalDigit = function(state) {\n  var ch = state.current();\n  if (isOctalDigit(ch)) {\n    state.lastIntValue = ch - 0x30; /* 0 */\n    state.advance();\n    return true\n  }\n  state.lastIntValue = 0;\n  return false\n};\nfunction isOctalDigit(ch) {\n  return ch >= 0x30 /* 0 */ && ch <= 0x37 /* 7 */\n}\n\n// https://www.ecma-international.org/ecma-262/8.0/#prod-Hex4Digits\n// https://www.ecma-international.org/ecma-262/8.0/#prod-HexDigit\n// And HexDigit HexDigit in https://www.ecma-international.org/ecma-262/8.0/#prod-HexEscapeSequence\npp$8.regexp_eatFixedHexDigits = function(state, length) {\n  var start = state.pos;\n  state.lastIntValue = 0;\n  for (var i = 0; i < length; ++i) {\n    var ch = state.current();\n    if (!isHexDigit(ch)) {\n      state.pos = start;\n      return false\n    }\n    state.lastIntValue = 16 * state.lastIntValue + hexToInt(ch);\n    state.advance();\n  }\n  return true\n};\n\n// Object type used to represent tokens. Note that normally, tokens\n// simply exist as properties on the parser object. This is only\n// used for the onToken callback and the external tokenizer.\n\nvar Token = function Token(p) {\n  this.type = p.type;\n  this.value = p.value;\n  this.start = p.start;\n  this.end = p.end;\n  if (p.options.locations)\n    { this.loc = new SourceLocation(p, p.startLoc, p.endLoc); }\n  if (p.options.ranges)\n    { this.range = [p.start, p.end]; }\n};\n\n// ## Tokenizer\n\nvar pp$9 = Parser.prototype;\n\n// Move to the next token\n\npp$9.next = function() {\n  if (this.options.onToken)\n    { this.options.onToken(new Token(this)); }\n\n  this.lastTokEnd = this.end;\n  this.lastTokStart = this.start;\n  this.lastTokEndLoc = this.endLoc;\n  this.lastTokStartLoc = this.startLoc;\n  this.nextToken();\n};\n\npp$9.getToken = function() {\n  this.next();\n  return new Token(this)\n};\n\n// If we're in an ES6 environment, make parsers iterable\nif (typeof Symbol !== \"undefined\")\n  { pp$9[Symbol.iterator] = function() {\n    var this$1 = this;\n\n    return {\n      next: function () {\n        var token = this$1.getToken();\n        return {\n          done: token.type === types.eof,\n          value: token\n        }\n      }\n    }\n  }; }\n\n// Toggle strict mode. Re-reads the next number or string to please\n// pedantic tests (`\"use strict\"; 010;` should fail).\n\npp$9.curContext = function() {\n  return this.context[this.context.length - 1]\n};\n\n// Read a single token, updating the parser object's token-related\n// properties.\n\npp$9.nextToken = function() {\n  var curContext = this.curContext();\n  if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }\n\n  this.start = this.pos;\n  if (this.options.locations) { this.startLoc = this.curPosition(); }\n  if (this.pos >= this.input.length) { return this.finishToken(types.eof) }\n\n  if (curContext.override) { return curContext.override(this) }\n  else { this.readToken(this.fullCharCodeAtPos()); }\n};\n\npp$9.readToken = function(code) {\n  // Identifier or keyword. '\\uXXXX' sequences are allowed in\n  // identifiers, so '\\' also dispatches to that.\n  if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\\' */)\n    { return this.readWord() }\n\n  return this.getTokenFromCode(code)\n};\n\npp$9.fullCharCodeAtPos = function() {\n  var code = this.input.charCodeAt(this.pos);\n  if (code <= 0xd7ff || code >= 0xe000) { return code }\n  var next = this.input.charCodeAt(this.pos + 1);\n  return (code << 10) + next - 0x35fdc00\n};\n\npp$9.skipBlockComment = function() {\n  var startLoc = this.options.onComment && this.curPosition();\n  var start = this.pos, end = this.input.indexOf(\"*/\", this.pos += 2);\n  if (end === -1) { this.raise(this.pos - 2, \"Unterminated comment\"); }\n  this.pos = end + 2;\n  if (this.options.locations) {\n    lineBreakG.lastIndex = start;\n    var match;\n    while ((match = lineBreakG.exec(this.input)) && match.index < this.pos) {\n      ++this.curLine;\n      this.lineStart = match.index + match[0].length;\n    }\n  }\n  if (this.options.onComment)\n    { this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,\n                           startLoc, this.curPosition()); }\n};\n\npp$9.skipLineComment = function(startSkip) {\n  var start = this.pos;\n  var startLoc = this.options.onComment && this.curPosition();\n  var ch = this.input.charCodeAt(this.pos += startSkip);\n  while (this.pos < this.input.length && !isNewLine(ch)) {\n    ch = this.input.charCodeAt(++this.pos);\n  }\n  if (this.options.onComment)\n    { this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,\n                           startLoc, this.curPosition()); }\n};\n\n// Called at the start of the parse and after every token. Skips\n// whitespace and comments, and.\n\npp$9.skipSpace = function() {\n  loop: while (this.pos < this.input.length) {\n    var ch = this.input.charCodeAt(this.pos);\n    switch (ch) {\n    case 32: case 160: // ' '\n      ++this.pos;\n      break\n    case 13:\n      if (this.input.charCodeAt(this.pos + 1) === 10) {\n        ++this.pos;\n      }\n    case 10: case 8232: case 8233:\n      ++this.pos;\n      if (this.options.locations) {\n        ++this.curLine;\n        this.lineStart = this.pos;\n      }\n      break\n    case 47: // '/'\n      switch (this.input.charCodeAt(this.pos + 1)) {\n      case 42: // '*'\n        this.skipBlockComment();\n        break\n      case 47:\n        this.skipLineComment(2);\n        break\n      default:\n        break loop\n      }\n      break\n    default:\n      if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {\n        ++this.pos;\n      } else {\n        break loop\n      }\n    }\n  }\n};\n\n// Called at the end of every token. Sets `end`, `val`, and\n// maintains `context` and `exprAllowed`, and skips the space after\n// the token, so that the next one's `start` will point at the\n// right position.\n\npp$9.finishToken = function(type, val) {\n  this.end = this.pos;\n  if (this.options.locations) { this.endLoc = this.curPosition(); }\n  var prevType = this.type;\n  this.type = type;\n  this.value = val;\n\n  this.updateContext(prevType);\n};\n\n// ### Token reading\n\n// This is the function that is called to fetch the next token. It\n// is somewhat obscure, because it works in character codes rather\n// than characters, and because operator parsing has been inlined\n// into it.\n//\n// All in the name of speed.\n//\npp$9.readToken_dot = function() {\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next >= 48 && next <= 57) { return this.readNumber(true) }\n  var next2 = this.input.charCodeAt(this.pos + 2);\n  if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'\n    this.pos += 3;\n    return this.finishToken(types.ellipsis)\n  } else {\n    ++this.pos;\n    return this.finishToken(types.dot)\n  }\n};\n\npp$9.readToken_slash = function() { // '/'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (this.exprAllowed) { ++this.pos; return this.readRegexp() }\n  if (next === 61) { return this.finishOp(types.assign, 2) }\n  return this.finishOp(types.slash, 1)\n};\n\npp$9.readToken_mult_modulo_exp = function(code) { // '%*'\n  var next = this.input.charCodeAt(this.pos + 1);\n  var size = 1;\n  var tokentype = code === 42 ? types.star : types.modulo;\n\n  // exponentiation operator ** and **=\n  if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {\n    ++size;\n    tokentype = types.starstar;\n    next = this.input.charCodeAt(this.pos + 2);\n  }\n\n  if (next === 61) { return this.finishOp(types.assign, size + 1) }\n  return this.finishOp(tokentype, size)\n};\n\npp$9.readToken_pipe_amp = function(code) { // '|&'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next === code) { return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND, 2) }\n  if (next === 61) { return this.finishOp(types.assign, 2) }\n  return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND, 1)\n};\n\npp$9.readToken_caret = function() { // '^'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next === 61) { return this.finishOp(types.assign, 2) }\n  return this.finishOp(types.bitwiseXOR, 1)\n};\n\npp$9.readToken_plus_min = function(code) { // '+-'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next === code) {\n    if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&\n        (this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd, this.pos)))) {\n      // A `-->` line comment\n      this.skipLineComment(3);\n      this.skipSpace();\n      return this.nextToken()\n    }\n    return this.finishOp(types.incDec, 2)\n  }\n  if (next === 61) { return this.finishOp(types.assign, 2) }\n  return this.finishOp(types.plusMin, 1)\n};\n\npp$9.readToken_lt_gt = function(code) { // '<>'\n  var next = this.input.charCodeAt(this.pos + 1);\n  var size = 1;\n  if (next === code) {\n    size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;\n    if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign, size + 1) }\n    return this.finishOp(types.bitShift, size)\n  }\n  if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&\n      this.input.charCodeAt(this.pos + 3) === 45) {\n    // `<!--`, an XML-style comment that should be interpreted as a line comment\n    this.skipLineComment(4);\n    this.skipSpace();\n    return this.nextToken()\n  }\n  if (next === 61) { size = 2; }\n  return this.finishOp(types.relational, size)\n};\n\npp$9.readToken_eq_excl = function(code) { // '=!'\n  var next = this.input.charCodeAt(this.pos + 1);\n  if (next === 61) { return this.finishOp(types.equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }\n  if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'\n    this.pos += 2;\n    return this.finishToken(types.arrow)\n  }\n  return this.finishOp(code === 61 ? types.eq : types.prefix, 1)\n};\n\npp$9.getTokenFromCode = function(code) {\n  switch (code) {\n  // The interpretation of a dot depends on whether it is followed\n  // by a digit or another two dots.\n  case 46: // '.'\n    return this.readToken_dot()\n\n  // Punctuation tokens.\n  case 40: ++this.pos; return this.finishToken(types.parenL)\n  case 41: ++this.pos; return this.finishToken(types.parenR)\n  case 59: ++this.pos; return this.finishToken(types.semi)\n  case 44: ++this.pos; return this.finishToken(types.comma)\n  case 91: ++this.pos; return this.finishToken(types.bracketL)\n  case 93: ++this.pos; return this.finishToken(types.bracketR)\n  case 123: ++this.pos; return this.finishToken(types.braceL)\n  case 125: ++this.pos; return this.finishToken(types.braceR)\n  case 58: ++this.pos; return this.finishToken(types.colon)\n  case 63: ++this.pos; return this.finishToken(types.question)\n\n  case 96: // '`'\n    if (this.options.ecmaVersion < 6) { break }\n    ++this.pos;\n    return this.finishToken(types.backQuote)\n\n  case 48: // '0'\n    var next = this.input.charCodeAt(this.pos + 1);\n    if (next === 120 || next === 88) { return this.readRadixNumber(16) } // '0x', '0X' - hex number\n    if (this.options.ecmaVersion >= 6) {\n      if (next === 111 || next === 79) { return this.readRadixNumber(8) } // '0o', '0O' - octal number\n      if (next === 98 || next === 66) { return this.readRadixNumber(2) } // '0b', '0B' - binary number\n    }\n\n  // Anything else beginning with a digit is an integer, octal\n  // number, or float.\n  case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9\n    return this.readNumber(false)\n\n  // Quotes produce strings.\n  case 34: case 39: // '\"', \"'\"\n    return this.readString(code)\n\n  // Operators are parsed inline in tiny state machines. '=' (61) is\n  // often referred to. `finishOp` simply skips the amount of\n  // characters it is given as second argument, and returns a token\n  // of the type given by its first argument.\n\n  case 47: // '/'\n    return this.readToken_slash()\n\n  case 37: case 42: // '%*'\n    return this.readToken_mult_modulo_exp(code)\n\n  case 124: case 38: // '|&'\n    return this.readToken_pipe_amp(code)\n\n  case 94: // '^'\n    return this.readToken_caret()\n\n  case 43: case 45: // '+-'\n    return this.readToken_plus_min(code)\n\n  case 60: case 62: // '<>'\n    return this.readToken_lt_gt(code)\n\n  case 61: case 33: // '=!'\n    return this.readToken_eq_excl(code)\n\n  case 126: // '~'\n    return this.finishOp(types.prefix, 1)\n  }\n\n  this.raise(this.pos, \"Unexpected character '\" + codePointToString$1(code) + \"'\");\n};\n\npp$9.finishOp = function(type, size) {\n  var str = this.input.slice(this.pos, this.pos + size);\n  this.pos += size;\n  return this.finishToken(type, str)\n};\n\npp$9.readRegexp = function() {\n  var escaped, inClass, start = this.pos;\n  for (;;) {\n    if (this.pos >= this.input.length) { this.raise(start, \"Unterminated regular expression\"); }\n    var ch = this.input.charAt(this.pos);\n    if (lineBreak.test(ch)) { this.raise(start, \"Unterminated regular expression\"); }\n    if (!escaped) {\n      if (ch === \"[\") { inClass = true; }\n      else if (ch === \"]\" && inClass) { inClass = false; }\n      else if (ch === \"/\" && !inClass) { break }\n      escaped = ch === \"\\\\\";\n    } else { escaped = false; }\n    ++this.pos;\n  }\n  var pattern = this.input.slice(start, this.pos);\n  ++this.pos;\n  var flagsStart = this.pos;\n  var flags = this.readWord1();\n  if (this.containsEsc) { this.unexpected(flagsStart); }\n\n  // Validate pattern\n  var state = this.regexpState || (this.regexpState = new RegExpValidationState(this));\n  state.reset(start, pattern, flags);\n  this.validateRegExpFlags(state);\n  this.validateRegExpPattern(state);\n\n  // Create Literal#value property value.\n  var value = null;\n  try {\n    value = new RegExp(pattern, flags);\n  } catch (e) {\n    // ESTree requires null if it failed to instantiate RegExp object.\n    // https://github.com/estree/estree/blob/a27003adf4fd7bfad44de9cef372a2eacd527b1c/es5.md#regexpliteral\n  }\n\n  return this.finishToken(types.regexp, {pattern: pattern, flags: flags, value: value})\n};\n\n// Read an integer in the given radix. Return null if zero digits\n// were read, the integer value otherwise. When `len` is given, this\n// will return `null` unless the integer has exactly `len` digits.\n\npp$9.readInt = function(radix, len) {\n  var start = this.pos, total = 0;\n  for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {\n    var code = this.input.charCodeAt(this.pos), val = (void 0);\n    if (code >= 97) { val = code - 97 + 10; } // a\n    else if (code >= 65) { val = code - 65 + 10; } // A\n    else if (code >= 48 && code <= 57) { val = code - 48; } // 0-9\n    else { val = Infinity; }\n    if (val >= radix) { break }\n    ++this.pos;\n    total = total * radix + val;\n  }\n  if (this.pos === start || len != null && this.pos - start !== len) { return null }\n\n  return total\n};\n\npp$9.readRadixNumber = function(radix) {\n  var start = this.pos;\n  this.pos += 2; // 0x\n  var val = this.readInt(radix);\n  if (val == null) { this.raise(this.start + 2, \"Expected number in radix \" + radix); }\n  if (this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {\n    val = typeof BigInt !== \"undefined\" ? BigInt(this.input.slice(start, this.pos)) : null;\n    ++this.pos;\n  } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, \"Identifier directly after number\"); }\n  return this.finishToken(types.num, val)\n};\n\n// Read an integer, octal integer, or floating-point number.\n\npp$9.readNumber = function(startsWithDot) {\n  var start = this.pos;\n  if (!startsWithDot && this.readInt(10) === null) { this.raise(start, \"Invalid number\"); }\n  var octal = this.pos - start >= 2 && this.input.charCodeAt(start) === 48;\n  if (octal && this.strict) { this.raise(start, \"Invalid number\"); }\n  if (octal && /[89]/.test(this.input.slice(start, this.pos))) { octal = false; }\n  var next = this.input.charCodeAt(this.pos);\n  if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {\n    var str$1 = this.input.slice(start, this.pos);\n    var val$1 = typeof BigInt !== \"undefined\" ? BigInt(str$1) : null;\n    ++this.pos;\n    if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, \"Identifier directly after number\"); }\n    return this.finishToken(types.num, val$1)\n  }\n  if (next === 46 && !octal) { // '.'\n    ++this.pos;\n    this.readInt(10);\n    next = this.input.charCodeAt(this.pos);\n  }\n  if ((next === 69 || next === 101) && !octal) { // 'eE'\n    next = this.input.charCodeAt(++this.pos);\n    if (next === 43 || next === 45) { ++this.pos; } // '+-'\n    if (this.readInt(10) === null) { this.raise(start, \"Invalid number\"); }\n  }\n  if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos, \"Identifier directly after number\"); }\n\n  var str = this.input.slice(start, this.pos);\n  var val = octal ? parseInt(str, 8) : parseFloat(str);\n  return this.finishToken(types.num, val)\n};\n\n// Read a string value, interpreting backslash-escapes.\n\npp$9.readCodePoint = function() {\n  var ch = this.input.charCodeAt(this.pos), code;\n\n  if (ch === 123) { // '{'\n    if (this.options.ecmaVersion < 6) { this.unexpected(); }\n    var codePos = ++this.pos;\n    code = this.readHexChar(this.input.indexOf(\"}\", this.pos) - this.pos);\n    ++this.pos;\n    if (code > 0x10FFFF) { this.invalidStringToken(codePos, \"Code point out of bounds\"); }\n  } else {\n    code = this.readHexChar(4);\n  }\n  return code\n};\n\nfunction codePointToString$1(code) {\n  // UTF-16 Decoding\n  if (code <= 0xFFFF) { return String.fromCharCode(code) }\n  code -= 0x10000;\n  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00)\n}\n\npp$9.readString = function(quote) {\n  var out = \"\", chunkStart = ++this.pos;\n  for (;;) {\n    if (this.pos >= this.input.length) { this.raise(this.start, \"Unterminated string constant\"); }\n    var ch = this.input.charCodeAt(this.pos);\n    if (ch === quote) { break }\n    if (ch === 92) { // '\\'\n      out += this.input.slice(chunkStart, this.pos);\n      out += this.readEscapedChar(false);\n      chunkStart = this.pos;\n    } else {\n      if (isNewLine(ch, this.options.ecmaVersion >= 10)) { this.raise(this.start, \"Unterminated string constant\"); }\n      ++this.pos;\n    }\n  }\n  out += this.input.slice(chunkStart, this.pos++);\n  return this.finishToken(types.string, out)\n};\n\n// Reads template string tokens.\n\nvar INVALID_TEMPLATE_ESCAPE_ERROR = {};\n\npp$9.tryReadTemplateToken = function() {\n  this.inTemplateElement = true;\n  try {\n    this.readTmplToken();\n  } catch (err) {\n    if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {\n      this.readInvalidTemplateToken();\n    } else {\n      throw err\n    }\n  }\n\n  this.inTemplateElement = false;\n};\n\npp$9.invalidStringToken = function(position, message) {\n  if (this.inTemplateElement && this.options.ecmaVersion >= 9) {\n    throw INVALID_TEMPLATE_ESCAPE_ERROR\n  } else {\n    this.raise(position, message);\n  }\n};\n\npp$9.readTmplToken = function() {\n  var out = \"\", chunkStart = this.pos;\n  for (;;) {\n    if (this.pos >= this.input.length) { this.raise(this.start, \"Unterminated template\"); }\n    var ch = this.input.charCodeAt(this.pos);\n    if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'\n      if (this.pos === this.start && (this.type === types.template || this.type === types.invalidTemplate)) {\n        if (ch === 36) {\n          this.pos += 2;\n          return this.finishToken(types.dollarBraceL)\n        } else {\n          ++this.pos;\n          return this.finishToken(types.backQuote)\n        }\n      }\n      out += this.input.slice(chunkStart, this.pos);\n      return this.finishToken(types.template, out)\n    }\n    if (ch === 92) { // '\\'\n      out += this.input.slice(chunkStart, this.pos);\n      out += this.readEscapedChar(true);\n      chunkStart = this.pos;\n    } else if (isNewLine(ch)) {\n      out += this.input.slice(chunkStart, this.pos);\n      ++this.pos;\n      switch (ch) {\n      case 13:\n        if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; }\n      case 10:\n        out += \"\\n\";\n        break\n      default:\n        out += String.fromCharCode(ch);\n        break\n      }\n      if (this.options.locations) {\n        ++this.curLine;\n        this.lineStart = this.pos;\n      }\n      chunkStart = this.pos;\n    } else {\n      ++this.pos;\n    }\n  }\n};\n\n// Reads a template token to search for the end, without validating any escape sequences\npp$9.readInvalidTemplateToken = function() {\n  for (; this.pos < this.input.length; this.pos++) {\n    switch (this.input[this.pos]) {\n    case \"\\\\\":\n      ++this.pos;\n      break\n\n    case \"$\":\n      if (this.input[this.pos + 1] !== \"{\") {\n        break\n      }\n    // falls through\n\n    case \"`\":\n      return this.finishToken(types.invalidTemplate, this.input.slice(this.start, this.pos))\n\n    // no default\n    }\n  }\n  this.raise(this.start, \"Unterminated template\");\n};\n\n// Used to read escaped characters\n\npp$9.readEscapedChar = function(inTemplate) {\n  var ch = this.input.charCodeAt(++this.pos);\n  ++this.pos;\n  switch (ch) {\n  case 110: return \"\\n\" // 'n' -> '\\n'\n  case 114: return \"\\r\" // 'r' -> '\\r'\n  case 120: return String.fromCharCode(this.readHexChar(2)) // 'x'\n  case 117: return codePointToString$1(this.readCodePoint()) // 'u'\n  case 116: return \"\\t\" // 't' -> '\\t'\n  case 98: return \"\\b\" // 'b' -> '\\b'\n  case 118: return \"\\u000b\" // 'v' -> '\\u000b'\n  case 102: return \"\\f\" // 'f' -> '\\f'\n  case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; } // '\\r\\n'\n  case 10: // ' \\n'\n    if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }\n    return \"\"\n  default:\n    if (ch >= 48 && ch <= 55) {\n      var octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0];\n      var octal = parseInt(octalStr, 8);\n      if (octal > 255) {\n        octalStr = octalStr.slice(0, -1);\n        octal = parseInt(octalStr, 8);\n      }\n      this.pos += octalStr.length - 1;\n      ch = this.input.charCodeAt(this.pos);\n      if ((octalStr !== \"0\" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {\n        this.invalidStringToken(\n          this.pos - 1 - octalStr.length,\n          inTemplate\n            ? \"Octal literal in template string\"\n            : \"Octal literal in strict mode\"\n        );\n      }\n      return String.fromCharCode(octal)\n    }\n    if (isNewLine(ch)) {\n      // Unicode new line characters after \\ get removed from output in both\n      // template literals and strings\n      return \"\"\n    }\n    return String.fromCharCode(ch)\n  }\n};\n\n// Used to read character escape sequences ('\\x', '\\u', '\\U').\n\npp$9.readHexChar = function(len) {\n  var codePos = this.pos;\n  var n = this.readInt(16, len);\n  if (n === null) { this.invalidStringToken(codePos, \"Bad character escape sequence\"); }\n  return n\n};\n\n// Read an identifier, and return it as a string. Sets `this.containsEsc`\n// to whether the word contained a '\\u' escape.\n//\n// Incrementally adds only escaped chars, adding other chunks as-is\n// as a micro-optimization.\n\npp$9.readWord1 = function() {\n  this.containsEsc = false;\n  var word = \"\", first = true, chunkStart = this.pos;\n  var astral = this.options.ecmaVersion >= 6;\n  while (this.pos < this.input.length) {\n    var ch = this.fullCharCodeAtPos();\n    if (isIdentifierChar(ch, astral)) {\n      this.pos += ch <= 0xffff ? 1 : 2;\n    } else if (ch === 92) { // \"\\\"\n      this.containsEsc = true;\n      word += this.input.slice(chunkStart, this.pos);\n      var escStart = this.pos;\n      if (this.input.charCodeAt(++this.pos) !== 117) // \"u\"\n        { this.invalidStringToken(this.pos, \"Expecting Unicode escape sequence \\\\uXXXX\"); }\n      ++this.pos;\n      var esc = this.readCodePoint();\n      if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))\n        { this.invalidStringToken(escStart, \"Invalid Unicode escape\"); }\n      word += codePointToString$1(esc);\n      chunkStart = this.pos;\n    } else {\n      break\n    }\n    first = false;\n  }\n  return word + this.input.slice(chunkStart, this.pos)\n};\n\n// Read an identifier or keyword token. Will check for reserved\n// words when necessary.\n\npp$9.readWord = function() {\n  var word = this.readWord1();\n  var type = types.name;\n  if (this.keywords.test(word)) {\n    if (this.containsEsc) { this.raiseRecoverable(this.start, \"Escape sequence in keyword \" + word); }\n    type = keywords$1[word];\n  }\n  return this.finishToken(type, word)\n};\n\n// Acorn is a tiny, fast JavaScript parser written in JavaScript.\n\nvar version = \"7.1.0\";\n\nParser.acorn = {\n  Parser: Parser,\n  version: version,\n  defaultOptions: defaultOptions,\n  Position: Position,\n  SourceLocation: SourceLocation,\n  getLineInfo: getLineInfo,\n  Node: Node,\n  TokenType: TokenType,\n  tokTypes: types,\n  keywordTypes: keywords$1,\n  TokContext: TokContext,\n  tokContexts: types$1,\n  isIdentifierChar: isIdentifierChar,\n  isIdentifierStart: isIdentifierStart,\n  Token: Token,\n  isNewLine: isNewLine,\n  lineBreak: lineBreak,\n  lineBreakG: lineBreakG,\n  nonASCIIwhitespace: nonASCIIwhitespace\n};\n\n// The main exported interface (under `self.acorn` when in the\n// browser) is a `parse` function that takes a code string and\n// returns an abstract syntax tree as specified by [Mozilla parser\n// API][api].\n//\n// [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API\n\nfunction parse(input, options) {\n  return Parser.parse(input, options)\n}\n\n// This function tries to parse a single expression at a given\n// offset in a string. Useful for parsing mixed-language formats\n// that embed JavaScript expressions.\n\nfunction parseExpressionAt(input, pos, options) {\n  return Parser.parseExpressionAt(input, pos, options)\n}\n\n// Acorn is organized as a tokenizer and a recursive-descent parser.\n// The `tokenizer` export provides an interface to the tokenizer.\n\nfunction tokenizer(input, options) {\n  return Parser.tokenizer(input, options)\n}\n\nexport { Node, Parser, Position, SourceLocation, TokContext, Token, TokenType, defaultOptions, getLineInfo, isIdentifierChar, isIdentifierStart, isNewLine, keywords$1 as keywordTypes, lineBreak, lineBreakG, nonASCIIwhitespace, parse, parseExpressionAt, types$1 as tokContexts, types as tokTypes, tokenizer, version };\n","'use strict';\n\nconst XHTMLEntities = require('./xhtml');\n\nconst hexNumber = /^[\\da-fA-F]+$/;\nconst decimalNumber = /^\\d+$/;\n\n// The map to `acorn-jsx` tokens from `acorn` namespace objects.\nconst acornJsxMap = new WeakMap();\n\n// Get the original tokens for the given `acorn` namespace object.\nfunction getJsxTokens(acorn) {\n  acorn = acorn.Parser.acorn || acorn;\n  let acornJsx = acornJsxMap.get(acorn);\n  if (!acornJsx) {\n    const tt = acorn.tokTypes;\n    const TokContext = acorn.TokContext;\n    const TokenType = acorn.TokenType;\n    const tc_oTag = new TokContext('<tag', false);\n    const tc_cTag = new TokContext('</tag', false);\n    const tc_expr = new TokContext('<tag>...</tag>', true, true);\n    const tokContexts = {\n      tc_oTag: tc_oTag,\n      tc_cTag: tc_cTag,\n      tc_expr: tc_expr\n    };\n    const tokTypes = {\n      jsxName: new TokenType('jsxName'),\n      jsxText: new TokenType('jsxText', {beforeExpr: true}),\n      jsxTagStart: new TokenType('jsxTagStart'),\n      jsxTagEnd: new TokenType('jsxTagEnd')\n    };\n\n    tokTypes.jsxTagStart.updateContext = function() {\n      this.context.push(tc_expr); // treat as beginning of JSX expression\n      this.context.push(tc_oTag); // start opening tag context\n      this.exprAllowed = false;\n    };\n    tokTypes.jsxTagEnd.updateContext = function(prevType) {\n      let out = this.context.pop();\n      if (out === tc_oTag && prevType === tt.slash || out === tc_cTag) {\n        this.context.pop();\n        this.exprAllowed = this.curContext() === tc_expr;\n      } else {\n        this.exprAllowed = true;\n      }\n    };\n\n    acornJsx = { tokContexts: tokContexts, tokTypes: tokTypes };\n    acornJsxMap.set(acorn, acornJsx);\n  }\n\n  return acornJsx;\n}\n\n// Transforms JSX element name to string.\n\nfunction getQualifiedJSXName(object) {\n  if (!object)\n    return object;\n\n  if (object.type === 'JSXIdentifier')\n    return object.name;\n\n  if (object.type === 'JSXNamespacedName')\n    return object.namespace.name + ':' + object.name.name;\n\n  if (object.type === 'JSXMemberExpression')\n    return getQualifiedJSXName(object.object) + '.' +\n    getQualifiedJSXName(object.property);\n}\n\nmodule.exports = function(options) {\n  options = options || {};\n  return function(Parser) {\n    return plugin({\n      allowNamespaces: options.allowNamespaces !== false,\n      allowNamespacedObjects: !!options.allowNamespacedObjects\n    }, Parser);\n  };\n};\n\n// This is `tokTypes` of the peer dep.\n// This can be different instances from the actual `tokTypes` this plugin uses.\nObject.defineProperty(module.exports, \"tokTypes\", {\n  get: function get_tokTypes() {\n    return getJsxTokens(require(\"acorn\")).tokTypes;\n  },\n  configurable: true,\n  enumerable: true\n});\n\nfunction plugin(options, Parser) {\n  const acorn = Parser.acorn || require(\"acorn\");\n  const acornJsx = getJsxTokens(acorn);\n  const tt = acorn.tokTypes;\n  const tok = acornJsx.tokTypes;\n  const tokContexts = acorn.tokContexts;\n  const tc_oTag = acornJsx.tokContexts.tc_oTag;\n  const tc_cTag = acornJsx.tokContexts.tc_cTag;\n  const tc_expr = acornJsx.tokContexts.tc_expr;\n  const isNewLine = acorn.isNewLine;\n  const isIdentifierStart = acorn.isIdentifierStart;\n  const isIdentifierChar = acorn.isIdentifierChar;\n\n  return class extends Parser {\n    // Expose actual `tokTypes` and `tokContexts` to other plugins.\n    static get acornJsx() {\n      return acornJsx;\n    }\n\n    // Reads inline JSX contents token.\n    jsx_readToken() {\n      let out = '', chunkStart = this.pos;\n      for (;;) {\n        if (this.pos >= this.input.length)\n          this.raise(this.start, 'Unterminated JSX contents');\n        let ch = this.input.charCodeAt(this.pos);\n\n        switch (ch) {\n        case 60: // '<'\n        case 123: // '{'\n          if (this.pos === this.start) {\n            if (ch === 60 && this.exprAllowed) {\n              ++this.pos;\n              return this.finishToken(tok.jsxTagStart);\n            }\n            return this.getTokenFromCode(ch);\n          }\n          out += this.input.slice(chunkStart, this.pos);\n          return this.finishToken(tok.jsxText, out);\n\n        case 38: // '&'\n          out += this.input.slice(chunkStart, this.pos);\n          out += this.jsx_readEntity();\n          chunkStart = this.pos;\n          break;\n\n        default:\n          if (isNewLine(ch)) {\n            out += this.input.slice(chunkStart, this.pos);\n            out += this.jsx_readNewLine(true);\n            chunkStart = this.pos;\n          } else {\n            ++this.pos;\n          }\n        }\n      }\n    }\n\n    jsx_readNewLine(normalizeCRLF) {\n      let ch = this.input.charCodeAt(this.pos);\n      let out;\n      ++this.pos;\n      if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {\n        ++this.pos;\n        out = normalizeCRLF ? '\\n' : '\\r\\n';\n      } else {\n        out = String.fromCharCode(ch);\n      }\n      if (this.options.locations) {\n        ++this.curLine;\n        this.lineStart = this.pos;\n      }\n\n      return out;\n    }\n\n    jsx_readString(quote) {\n      let out = '', chunkStart = ++this.pos;\n      for (;;) {\n        if (this.pos >= this.input.length)\n          this.raise(this.start, 'Unterminated string constant');\n        let ch = this.input.charCodeAt(this.pos);\n        if (ch === quote) break;\n        if (ch === 38) { // '&'\n          out += this.input.slice(chunkStart, this.pos);\n          out += this.jsx_readEntity();\n          chunkStart = this.pos;\n        } else if (isNewLine(ch)) {\n          out += this.input.slice(chunkStart, this.pos);\n          out += this.jsx_readNewLine(false);\n          chunkStart = this.pos;\n        } else {\n          ++this.pos;\n        }\n      }\n      out += this.input.slice(chunkStart, this.pos++);\n      return this.finishToken(tt.string, out);\n    }\n\n    jsx_readEntity() {\n      let str = '', count = 0, entity;\n      let ch = this.input[this.pos];\n      if (ch !== '&')\n        this.raise(this.pos, 'Entity must start with an ampersand');\n      let startPos = ++this.pos;\n      while (this.pos < this.input.length && count++ < 10) {\n        ch = this.input[this.pos++];\n        if (ch === ';') {\n          if (str[0] === '#') {\n            if (str[1] === 'x') {\n              str = str.substr(2);\n              if (hexNumber.test(str))\n                entity = String.fromCharCode(parseInt(str, 16));\n            } else {\n              str = str.substr(1);\n              if (decimalNumber.test(str))\n                entity = String.fromCharCode(parseInt(str, 10));\n            }\n          } else {\n            entity = XHTMLEntities[str];\n          }\n          break;\n        }\n        str += ch;\n      }\n      if (!entity) {\n        this.pos = startPos;\n        return '&';\n      }\n      return entity;\n    }\n\n    // Read a JSX identifier (valid tag or attribute name).\n    //\n    // Optimized version since JSX identifiers can't contain\n    // escape characters and so can be read as single slice.\n    // Also assumes that first character was already checked\n    // by isIdentifierStart in readToken.\n\n    jsx_readWord() {\n      let ch, start = this.pos;\n      do {\n        ch = this.input.charCodeAt(++this.pos);\n      } while (isIdentifierChar(ch) || ch === 45); // '-'\n      return this.finishToken(tok.jsxName, this.input.slice(start, this.pos));\n    }\n\n    // Parse next token as JSX identifier\n\n    jsx_parseIdentifier() {\n      let node = this.startNode();\n      if (this.type === tok.jsxName)\n        node.name = this.value;\n      else if (this.type.keyword)\n        node.name = this.type.keyword;\n      else\n        this.unexpected();\n      this.next();\n      return this.finishNode(node, 'JSXIdentifier');\n    }\n\n    // Parse namespaced identifier.\n\n    jsx_parseNamespacedName() {\n      let startPos = this.start, startLoc = this.startLoc;\n      let name = this.jsx_parseIdentifier();\n      if (!options.allowNamespaces || !this.eat(tt.colon)) return name;\n      var node = this.startNodeAt(startPos, startLoc);\n      node.namespace = name;\n      node.name = this.jsx_parseIdentifier();\n      return this.finishNode(node, 'JSXNamespacedName');\n    }\n\n    // Parses element name in any form - namespaced, member\n    // or single identifier.\n\n    jsx_parseElementName() {\n      if (this.type === tok.jsxTagEnd) return '';\n      let startPos = this.start, startLoc = this.startLoc;\n      let node = this.jsx_parseNamespacedName();\n      if (this.type === tt.dot && node.type === 'JSXNamespacedName' && !options.allowNamespacedObjects) {\n        this.unexpected();\n      }\n      while (this.eat(tt.dot)) {\n        let newNode = this.startNodeAt(startPos, startLoc);\n        newNode.object = node;\n        newNode.property = this.jsx_parseIdentifier();\n        node = this.finishNode(newNode, 'JSXMemberExpression');\n      }\n      return node;\n    }\n\n    // Parses any type of JSX attribute value.\n\n    jsx_parseAttributeValue() {\n      switch (this.type) {\n      case tt.braceL:\n        let node = this.jsx_parseExpressionContainer();\n        if (node.expression.type === 'JSXEmptyExpression')\n          this.raise(node.start, 'JSX attributes must only be assigned a non-empty expression');\n        return node;\n\n      case tok.jsxTagStart:\n      case tt.string:\n        return this.parseExprAtom();\n\n      default:\n        this.raise(this.start, 'JSX value should be either an expression or a quoted JSX text');\n      }\n    }\n\n    // JSXEmptyExpression is unique type since it doesn't actually parse anything,\n    // and so it should start at the end of last read token (left brace) and finish\n    // at the beginning of the next one (right brace).\n\n    jsx_parseEmptyExpression() {\n      let node = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);\n      return this.finishNodeAt(node, 'JSXEmptyExpression', this.start, this.startLoc);\n    }\n\n    // Parses JSX expression enclosed into curly brackets.\n\n    jsx_parseExpressionContainer() {\n      let node = this.startNode();\n      this.next();\n      node.expression = this.type === tt.braceR\n        ? this.jsx_parseEmptyExpression()\n        : this.parseExpression();\n      this.expect(tt.braceR);\n      return this.finishNode(node, 'JSXExpressionContainer');\n    }\n\n    // Parses following JSX attribute name-value pair.\n\n    jsx_parseAttribute() {\n      let node = this.startNode();\n      if (this.eat(tt.braceL)) {\n        this.expect(tt.ellipsis);\n        node.argument = this.parseMaybeAssign();\n        this.expect(tt.braceR);\n        return this.finishNode(node, 'JSXSpreadAttribute');\n      }\n      node.name = this.jsx_parseNamespacedName();\n      node.value = this.eat(tt.eq) ? this.jsx_parseAttributeValue() : null;\n      return this.finishNode(node, 'JSXAttribute');\n    }\n\n    // Parses JSX opening tag starting after '<'.\n\n    jsx_parseOpeningElementAt(startPos, startLoc) {\n      let node = this.startNodeAt(startPos, startLoc);\n      node.attributes = [];\n      let nodeName = this.jsx_parseElementName();\n      if (nodeName) node.name = nodeName;\n      while (this.type !== tt.slash && this.type !== tok.jsxTagEnd)\n        node.attributes.push(this.jsx_parseAttribute());\n      node.selfClosing = this.eat(tt.slash);\n      this.expect(tok.jsxTagEnd);\n      return this.finishNode(node, nodeName ? 'JSXOpeningElement' : 'JSXOpeningFragment');\n    }\n\n    // Parses JSX closing tag starting after '</'.\n\n    jsx_parseClosingElementAt(startPos, startLoc) {\n      let node = this.startNodeAt(startPos, startLoc);\n      let nodeName = this.jsx_parseElementName();\n      if (nodeName) node.name = nodeName;\n      this.expect(tok.jsxTagEnd);\n      return this.finishNode(node, nodeName ? 'JSXClosingElement' : 'JSXClosingFragment');\n    }\n\n    // Parses entire JSX element, including it's opening tag\n    // (starting after '<'), attributes, contents and closing tag.\n\n    jsx_parseElementAt(startPos, startLoc) {\n      let node = this.startNodeAt(startPos, startLoc);\n      let children = [];\n      let openingElement = this.jsx_parseOpeningElementAt(startPos, startLoc);\n      let closingElement = null;\n\n      if (!openingElement.selfClosing) {\n        contents: for (;;) {\n          switch (this.type) {\n          case tok.jsxTagStart:\n            startPos = this.start; startLoc = this.startLoc;\n            this.next();\n            if (this.eat(tt.slash)) {\n              closingElement = this.jsx_parseClosingElementAt(startPos, startLoc);\n              break contents;\n            }\n            children.push(this.jsx_parseElementAt(startPos, startLoc));\n            break;\n\n          case tok.jsxText:\n            children.push(this.parseExprAtom());\n            break;\n\n          case tt.braceL:\n            children.push(this.jsx_parseExpressionContainer());\n            break;\n\n          default:\n            this.unexpected();\n          }\n        }\n        if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {\n          this.raise(\n            closingElement.start,\n            'Expected corresponding JSX closing tag for <' + getQualifiedJSXName(openingElement.name) + '>');\n        }\n      }\n      let fragmentOrElement = openingElement.name ? 'Element' : 'Fragment';\n\n      node['opening' + fragmentOrElement] = openingElement;\n      node['closing' + fragmentOrElement] = closingElement;\n      node.children = children;\n      if (this.type === tt.relational && this.value === \"<\") {\n        this.raise(this.start, \"Adjacent JSX elements must be wrapped in an enclosing tag\");\n      }\n      return this.finishNode(node, 'JSX' + fragmentOrElement);\n    }\n\n    // Parse JSX text\n\n    jsx_parseText(value) {\n      let node = this.parseLiteral(value);\n      node.type = \"JSXText\";\n      return node;\n    }\n\n    // Parses entire JSX element from current position.\n\n    jsx_parseElement() {\n      let startPos = this.start, startLoc = this.startLoc;\n      this.next();\n      return this.jsx_parseElementAt(startPos, startLoc);\n    }\n\n    parseExprAtom(refShortHandDefaultPos) {\n      if (this.type === tok.jsxText)\n        return this.jsx_parseText(this.value);\n      else if (this.type === tok.jsxTagStart)\n        return this.jsx_parseElement();\n      else\n        return super.parseExprAtom(refShortHandDefaultPos);\n    }\n\n    readToken(code) {\n      let context = this.curContext();\n\n      if (context === tc_expr) return this.jsx_readToken();\n\n      if (context === tc_oTag || context === tc_cTag) {\n        if (isIdentifierStart(code)) return this.jsx_readWord();\n\n        if (code == 62) {\n          ++this.pos;\n          return this.finishToken(tok.jsxTagEnd);\n        }\n\n        if ((code === 34 || code === 39) && context == tc_oTag)\n          return this.jsx_readString(code);\n      }\n\n      if (code === 60 && this.exprAllowed && this.input.charCodeAt(this.pos + 1) !== 33) {\n        ++this.pos;\n        return this.finishToken(tok.jsxTagStart);\n      }\n      return super.readToken(code);\n    }\n\n    updateContext(prevType) {\n      if (this.type == tt.braceL) {\n        var curContext = this.curContext();\n        if (curContext == tc_oTag) this.context.push(tokContexts.b_expr);\n        else if (curContext == tc_expr) this.context.push(tokContexts.b_tmpl);\n        else super.updateContext(prevType);\n        this.exprAllowed = true;\n      } else if (this.type === tt.slash && prevType === tok.jsxTagStart) {\n        this.context.length -= 2; // do not consider JSX expr -> JSX open tag -> ... anymore\n        this.context.push(tc_cTag); // reconsider as closing tag context\n        this.exprAllowed = false;\n      } else {\n        return super.updateContext(prevType);\n      }\n    }\n  };\n}\n","module.exports = {\n  quot: '\\u0022',\n  amp: '&',\n  apos: '\\u0027',\n  lt: '<',\n  gt: '>',\n  nbsp: '\\u00A0',\n  iexcl: '\\u00A1',\n  cent: '\\u00A2',\n  pound: '\\u00A3',\n  curren: '\\u00A4',\n  yen: '\\u00A5',\n  brvbar: '\\u00A6',\n  sect: '\\u00A7',\n  uml: '\\u00A8',\n  copy: '\\u00A9',\n  ordf: '\\u00AA',\n  laquo: '\\u00AB',\n  not: '\\u00AC',\n  shy: '\\u00AD',\n  reg: '\\u00AE',\n  macr: '\\u00AF',\n  deg: '\\u00B0',\n  plusmn: '\\u00B1',\n  sup2: '\\u00B2',\n  sup3: '\\u00B3',\n  acute: '\\u00B4',\n  micro: '\\u00B5',\n  para: '\\u00B6',\n  middot: '\\u00B7',\n  cedil: '\\u00B8',\n  sup1: '\\u00B9',\n  ordm: '\\u00BA',\n  raquo: '\\u00BB',\n  frac14: '\\u00BC',\n  frac12: '\\u00BD',\n  frac34: '\\u00BE',\n  iquest: '\\u00BF',\n  Agrave: '\\u00C0',\n  Aacute: '\\u00C1',\n  Acirc: '\\u00C2',\n  Atilde: '\\u00C3',\n  Auml: '\\u00C4',\n  Aring: '\\u00C5',\n  AElig: '\\u00C6',\n  Ccedil: '\\u00C7',\n  Egrave: '\\u00C8',\n  Eacute: '\\u00C9',\n  Ecirc: '\\u00CA',\n  Euml: '\\u00CB',\n  Igrave: '\\u00CC',\n  Iacute: '\\u00CD',\n  Icirc: '\\u00CE',\n  Iuml: '\\u00CF',\n  ETH: '\\u00D0',\n  Ntilde: '\\u00D1',\n  Ograve: '\\u00D2',\n  Oacute: '\\u00D3',\n  Ocirc: '\\u00D4',\n  Otilde: '\\u00D5',\n  Ouml: '\\u00D6',\n  times: '\\u00D7',\n  Oslash: '\\u00D8',\n  Ugrave: '\\u00D9',\n  Uacute: '\\u00DA',\n  Ucirc: '\\u00DB',\n  Uuml: '\\u00DC',\n  Yacute: '\\u00DD',\n  THORN: '\\u00DE',\n  szlig: '\\u00DF',\n  agrave: '\\u00E0',\n  aacute: '\\u00E1',\n  acirc: '\\u00E2',\n  atilde: '\\u00E3',\n  auml: '\\u00E4',\n  aring: '\\u00E5',\n  aelig: '\\u00E6',\n  ccedil: '\\u00E7',\n  egrave: '\\u00E8',\n  eacute: '\\u00E9',\n  ecirc: '\\u00EA',\n  euml: '\\u00EB',\n  igrave: '\\u00EC',\n  iacute: '\\u00ED',\n  icirc: '\\u00EE',\n  iuml: '\\u00EF',\n  eth: '\\u00F0',\n  ntilde: '\\u00F1',\n  ograve: '\\u00F2',\n  oacute: '\\u00F3',\n  ocirc: '\\u00F4',\n  otilde: '\\u00F5',\n  ouml: '\\u00F6',\n  divide: '\\u00F7',\n  oslash: '\\u00F8',\n  ugrave: '\\u00F9',\n  uacute: '\\u00FA',\n  ucirc: '\\u00FB',\n  uuml: '\\u00FC',\n  yacute: '\\u00FD',\n  thorn: '\\u00FE',\n  yuml: '\\u00FF',\n  OElig: '\\u0152',\n  oelig: '\\u0153',\n  Scaron: '\\u0160',\n  scaron: '\\u0161',\n  Yuml: '\\u0178',\n  fnof: '\\u0192',\n  circ: '\\u02C6',\n  tilde: '\\u02DC',\n  Alpha: '\\u0391',\n  Beta: '\\u0392',\n  Gamma: '\\u0393',\n  Delta: '\\u0394',\n  Epsilon: '\\u0395',\n  Zeta: '\\u0396',\n  Eta: '\\u0397',\n  Theta: '\\u0398',\n  Iota: '\\u0399',\n  Kappa: '\\u039A',\n  Lambda: '\\u039B',\n  Mu: '\\u039C',\n  Nu: '\\u039D',\n  Xi: '\\u039E',\n  Omicron: '\\u039F',\n  Pi: '\\u03A0',\n  Rho: '\\u03A1',\n  Sigma: '\\u03A3',\n  Tau: '\\u03A4',\n  Upsilon: '\\u03A5',\n  Phi: '\\u03A6',\n  Chi: '\\u03A7',\n  Psi: '\\u03A8',\n  Omega: '\\u03A9',\n  alpha: '\\u03B1',\n  beta: '\\u03B2',\n  gamma: '\\u03B3',\n  delta: '\\u03B4',\n  epsilon: '\\u03B5',\n  zeta: '\\u03B6',\n  eta: '\\u03B7',\n  theta: '\\u03B8',\n  iota: '\\u03B9',\n  kappa: '\\u03BA',\n  lambda: '\\u03BB',\n  mu: '\\u03BC',\n  nu: '\\u03BD',\n  xi: '\\u03BE',\n  omicron: '\\u03BF',\n  pi: '\\u03C0',\n  rho: '\\u03C1',\n  sigmaf: '\\u03C2',\n  sigma: '\\u03C3',\n  tau: '\\u03C4',\n  upsilon: '\\u03C5',\n  phi: '\\u03C6',\n  chi: '\\u03C7',\n  psi: '\\u03C8',\n  omega: '\\u03C9',\n  thetasym: '\\u03D1',\n  upsih: '\\u03D2',\n  piv: '\\u03D6',\n  ensp: '\\u2002',\n  emsp: '\\u2003',\n  thinsp: '\\u2009',\n  zwnj: '\\u200C',\n  zwj: '\\u200D',\n  lrm: '\\u200E',\n  rlm: '\\u200F',\n  ndash: '\\u2013',\n  mdash: '\\u2014',\n  lsquo: '\\u2018',\n  rsquo: '\\u2019',\n  sbquo: '\\u201A',\n  ldquo: '\\u201C',\n  rdquo: '\\u201D',\n  bdquo: '\\u201E',\n  dagger: '\\u2020',\n  Dagger: '\\u2021',\n  bull: '\\u2022',\n  hellip: '\\u2026',\n  permil: '\\u2030',\n  prime: '\\u2032',\n  Prime: '\\u2033',\n  lsaquo: '\\u2039',\n  rsaquo: '\\u203A',\n  oline: '\\u203E',\n  frasl: '\\u2044',\n  euro: '\\u20AC',\n  image: '\\u2111',\n  weierp: '\\u2118',\n  real: '\\u211C',\n  trade: '\\u2122',\n  alefsym: '\\u2135',\n  larr: '\\u2190',\n  uarr: '\\u2191',\n  rarr: '\\u2192',\n  darr: '\\u2193',\n  harr: '\\u2194',\n  crarr: '\\u21B5',\n  lArr: '\\u21D0',\n  uArr: '\\u21D1',\n  rArr: '\\u21D2',\n  dArr: '\\u21D3',\n  hArr: '\\u21D4',\n  forall: '\\u2200',\n  part: '\\u2202',\n  exist: '\\u2203',\n  empty: '\\u2205',\n  nabla: '\\u2207',\n  isin: '\\u2208',\n  notin: '\\u2209',\n  ni: '\\u220B',\n  prod: '\\u220F',\n  sum: '\\u2211',\n  minus: '\\u2212',\n  lowast: '\\u2217',\n  radic: '\\u221A',\n  prop: '\\u221D',\n  infin: '\\u221E',\n  ang: '\\u2220',\n  and: '\\u2227',\n  or: '\\u2228',\n  cap: '\\u2229',\n  cup: '\\u222A',\n  'int': '\\u222B',\n  there4: '\\u2234',\n  sim: '\\u223C',\n  cong: '\\u2245',\n  asymp: '\\u2248',\n  ne: '\\u2260',\n  equiv: '\\u2261',\n  le: '\\u2264',\n  ge: '\\u2265',\n  sub: '\\u2282',\n  sup: '\\u2283',\n  nsub: '\\u2284',\n  sube: '\\u2286',\n  supe: '\\u2287',\n  oplus: '\\u2295',\n  otimes: '\\u2297',\n  perp: '\\u22A5',\n  sdot: '\\u22C5',\n  lceil: '\\u2308',\n  rceil: '\\u2309',\n  lfloor: '\\u230A',\n  rfloor: '\\u230B',\n  lang: '\\u2329',\n  rang: '\\u232A',\n  loz: '\\u25CA',\n  spades: '\\u2660',\n  clubs: '\\u2663',\n  hearts: '\\u2665',\n  diams: '\\u2666'\n};\n","export default {\n  class:     'className',\n  for:       'htmlFor',\n  maxlength: 'maxLength',\n\n  colspan: 'colSpan',\n  rowspan: 'rowSpan',\n}\n","const VOID_ELEMENTS = [\n  'area',\n  'base',\n  'br',\n  'col',\n  'embed',\n  'hr',\n  'img',\n  'input',\n  'keygen',\n  'link',\n  'menuitem',\n  'meta',\n  'param',\n  'source',\n  'track',\n  'wbr',\n]\n\nconst NO_WHITESPACE = [\n  'table',\n  'tbody',\n  'tfoot',\n  'thead',\n  'tr',\n]\n\nexport default VOID_ELEMENTS\n\nexport function canHaveChildren(tagName) {\n  return VOID_ELEMENTS.indexOf(tagName.toLowerCase()) === -1\n}\nexport function canHaveWhitespace(tagName) {\n  return NO_WHITESPACE.indexOf(tagName.toLowerCase()) !== -1\n}\n","export default function hash(value = '', radix = 16) {\n  const string = String(value)\n  let h = 0\n  string.split('').forEach((char) => {\n    /* eslint-disable no-bitwise */\n    h = ((h << 5) - h) + char.charCodeAt(0)\n    h &= h // Convert to 32-bit integer\n    /* eslint-enable no-bitwise */\n  })\n  return Math.abs(h).toString(radix)\n}\n\nexport const randomHash = () => hash(Math.random().toString())","import camelCase from './camelCase'\n\nexport default function parseStyle(style) {\n  switch (typeof style) {\n    case 'string':\n      return style.split(';').filter(r => r)\n        .reduce((map, rule) => {\n          const name = rule.slice(0, rule.indexOf(':')).trim()\n          const value = rule.slice(rule.indexOf(':') + 1).trim()\n\n          return {\n            ...map,\n            [camelCase(name)]: value,\n          }\n        }, {})\n    case 'object':\n      return style\n\n    default:\n      return undefined\n  }\n}\n","export default function camelCase(string) {\n  return string\n    .replace(/([A-Z])([A-Z])/g, '$1 $2')\n    .replace(/([a-z])([A-Z])/g, '$1 $2')\n    .replace(/[^a-zA-Z\\u00C0-\\u00ff]/g, ' ')\n    .toLowerCase()\n    .split(' ')\n    .filter(value => value)\n    .map((s, i) => (i > 0 ? s[0].toUpperCase() + s.slice(1) : s))\n    .join('')\n}\n","const pathToArrayPath = (path) => {\n  if (path == null || path === '') return []\n  return path.split('.')\n}\n\nconst resolveArrayPath = (object, path) => {\n  const [property, ...subPath] = path\n  if (object == null || property == null) {\n    return undefined\n  }\n  return subPath.length === 0\n    ? object[property]\n    : resolveArrayPath(object[property], subPath)\n}\n\nexport default (object, path) => resolveArrayPath(object, pathToArrayPath(path))\n","import * as acorn from 'acorn'\nimport acornJsx from 'acorn-jsx'\nimport React, { Component, Fragment } from 'react'\nimport ATTRIBUTES from '../constants/attributeNames'\nimport { canHaveChildren, canHaveWhitespace } from '../constants/specialTags'\nimport { randomHash } from '../helpers/hash'\nimport parseStyle from '../helpers/parseStyle'\nimport resolvePath from '../helpers/resolvePath'\n\nconst parser = acorn.Parser.extend(acornJsx())\n\n/* eslint-disable consistent-return */\nexport default class JsxParser extends Component {\n  static displayName = 'JsxParser'\n\n  static defaultProps = {\n    allowUnknownElements: true,\n    bindings: {},\n    blacklistedAttrs: [/^on.+/i],\n    blacklistedTags: ['script'],\n    components: [],\n    componentsOnly: false,\n    disableFragments: false,\n    disableKeyGeneration: false,\n    jsx: '',\n    onError: () => { },\n    showWarnings: false,\n    renderError: undefined,\n    renderInWrapper: true,\n  }\n\n  parseJSX = rawJSX => {\n    const wrappedJsx = `<root>${rawJSX}</root>`\n    let parsed = []\n    try {\n      parsed = parser.parse(wrappedJsx)\n      parsed = parsed.body[0].expression.children || []\n    } catch (error) {\n      // eslint-disable-next-line no-console\n      if (this.props.showWarnings) console.warn(error)\n      if (this.props.onError) this.props.onError(error)\n      if (this.props.renderError) {\n        return this.props.renderError({ error: String(error) })\n      }\n      return []\n    }\n\n    return parsed.map(this.parseExpression).filter(Boolean)\n  }\n\n  parseExpression = expression => {\n    switch (expression.type) {\n      case 'JSXAttribute':\n        if (expression.value === null) return true\n        return this.parseExpression(expression.value)\n      case 'JSXElement':\n        return this.parseElement(expression)\n      case 'JSXExpressionContainer':\n        return this.parseExpression(expression.expression)\n      case 'JSXText':\n        const key = this.props.disableKeyGeneration ? undefined : randomHash()\n        return this.props.disableFragments\n          ? expression.value\n          : <Fragment key={key}>{expression.value}</Fragment>\n      case 'ArrayExpression':\n        return expression.elements.map(this.parseExpression)\n      case 'BinaryExpression':\n        /* eslint-disable eqeqeq,max-len */\n        switch (expression.operator) {\n          case '-': return this.parseExpression(expression.left) - this.parseExpression(expression.right)\n          case '!=': return this.parseExpression(expression.left) != this.parseExpression(expression.right)\n          case '!==': return this.parseExpression(expression.left) !== this.parseExpression(expression.right)\n          case '*': return this.parseExpression(expression.left) * this.parseExpression(expression.right)\n          case '**': return this.parseExpression(expression.left) ** this.parseExpression(expression.right)\n          case '/': return this.parseExpression(expression.left) / this.parseExpression(expression.right)\n          case '%': return this.parseExpression(expression.left) % this.parseExpression(expression.right)\n          case '+': return this.parseExpression(expression.left) + this.parseExpression(expression.right)\n          case '==': return this.parseExpression(expression.left) == this.parseExpression(expression.right)\n          case '===': return this.parseExpression(expression.left) === this.parseExpression(expression.right)\n        /* eslint-enable eqeqeq,max-len */\n        }\n        return undefined\n      case 'CallExpression':\n        const parsedCallee = this.parseExpression(expression.callee)\n        if (parsedCallee === undefined) {\n          this.props.onError(new Error(`The expression '${expression.callee}' could not be resolved, resulting in an undefined return value.`))\n          return undefined\n        }\n        return parsedCallee(...expression.arguments.map(this.parseExpression))\n      case 'ConditionalExpression':\n        return this.parseExpression(expression.test)\n          ? this.parseExpression(expression.consequent)\n          : this.parseExpression(expression.alternate)\n      case 'Identifier':\n        return (this.props.bindings || {})[expression.name]\n      case 'Literal':\n        return expression.value\n      case 'LogicalExpression':\n        const left = this.parseExpression(expression.left)\n        if (expression.operator === '||' && left) return left\n        if ((expression.operator === '&&' && left) || (expression.operator === '||' && !left)) {\n          return this.parseExpression(expression.right)\n        }\n        return false\n      case 'MemberExpression':\n        const thisObj = this.parseExpression(expression.object) || {}\n        const member = (thisObj)[expression.property.name]\n        if (typeof member === 'function') return member.bind(thisObj)\n        return member\n      case 'ObjectExpression':\n        const object = {}\n        expression.properties.forEach(prop => {\n          object[prop.key.name || prop.key.value] = this.parseExpression(prop.value)\n        })\n        return object\n      case 'UnaryExpression':\n        switch (expression.operator) {\n          case '+': return expression.argument.value\n          case '-': return -1 * expression.argument.value\n          case '!': return !expression.argument.value\n        }\n        return undefined\n    }\n  }\n\n  parseName = element => {\n    switch (element.type) {\n      case 'JSXIdentifier':\n        return element.name\n      case 'JSXMemberExpression':\n        return `${this.parseName(element.object)}.${this.parseName(element.property)}`\n    }\n  }\n\n  parseElement = element => {\n    const { allowUnknownElements, components = {}, componentsOnly, onError } = this.props\n    const { children: childNodes = [], openingElement } = element\n    const { attributes = [] } = openingElement\n    const name = this.parseName(openingElement.name)\n    if (!name) {\n      onError(new Error(`The <${openingElement.name}> tag could not be parsed, and will not be rendered.`))\n      return undefined\n    }\n\n    const blacklistedAttrs = (this.props.blacklistedAttrs || [])\n      .map(attr => (attr instanceof RegExp ? attr : new RegExp(attr, 'i')))\n    const blacklistedTags = (this.props.blacklistedTags || [])\n      .map(tag => tag.trim().toLowerCase()).filter(Boolean)\n\n    if (/^(html|head|body)$/i.test(name)) return childNodes.map(c => this.parseElement(c))\n    const tagName = name.trim().toLowerCase()\n    if (blacklistedTags.indexOf(tagName) !== -1) {\n      onError(new Error(`The tag <${name}> is blacklisted, and will not be rendered.`))\n      return undefined\n    }\n\n    if (!resolvePath(components, name)) {\n      if (componentsOnly) {\n        onError(new Error(`The componenet <${name}> is unrecognized, and will not be rendered.`))\n        return undefined\n      }\n\n      if (!allowUnknownElements && document.createElement(name) instanceof HTMLUnknownElement) {\n        onError(new Error(`The tag <${name}> is unrecognized in this browser, and will not be rendered.`))\n        return undefined\n      }\n    }\n\n    let children\n    const component = resolvePath(components, name)\n    if (component || canHaveChildren(name)) {\n      children = childNodes.map(this.parseExpression)\n      if (!component && !canHaveWhitespace(name)) {\n        children = children.filter(child => (\n          typeof child !== 'string' || !/^\\s*$/.test(child)\n        ))\n      }\n\n      if (children.length === 0) {\n        children = undefined\n      } else if (children.length === 1) {\n        [children] = children\n      }\n    }\n\n    const props = {\n      key: this.props.disableKeyGeneration ? undefined : randomHash(),\n    }\n    attributes.forEach(expr => {\n      if (expr.type === 'JSXAttribute') {\n        const rawName = expr.name.name\n        const attributeName = ATTRIBUTES[rawName] || rawName\n        // if the value is null, this is an implicitly \"true\" prop, such as readOnly\n        const value = this.parseExpression(expr)\n\n        const matches = blacklistedAttrs.filter(re => re.test(attributeName))\n        if (matches.length === 0) {\n          if (value === 'true' || value === 'false') {\n            props[attributeName] = (value === 'true')\n          } else {\n            props[attributeName] = value\n          }\n        }\n      } else if (\n        (expr.type === 'JSXSpreadAttribute' && expr.argument.type === 'Identifier')\n        || expr.argument.type === 'MemberExpression'\n      ) {\n        const value = this.parseExpression(expr.argument)\n        if (typeof value === 'object') {\n          Object.keys(value).forEach(rawName => {\n            const attributeName = ATTRIBUTES[rawName] || rawName\n            const matches = blacklistedAttrs.filter(re => re.test(attributeName))\n            if (matches.length === 0) {\n              props[attributeName] = value[rawName]\n            }\n          })\n        }\n      }\n    })\n\n    if (typeof props.style === 'string') {\n      props.style = parseStyle(props.style)\n    }\n\n    if (children) props.children = children\n\n    return React.createElement(component || name.toLowerCase(), props)\n  }\n\n  render = () => {\n    const jsx = (this.props.jsx || '').trim().replace(/<!DOCTYPE([^>]*)>/g, '')\n    this.ParsedChildren = this.parseJSX(jsx)\n\n    return (\n      this.props.renderInWrapper\n        ? <div className=\"jsx-parser\">{this.ParsedChildren}</div>\n        : <>{this.ParsedChildren}</>\n    )\n  }\n}\n/* eslint-enable consistent-return */\n\nif (process.env.NODE_ENV !== 'production') {\n  /* eslint-disable react/no-unused-prop-types */\n  // eslint-disable-next-line global-require,import/no-extraneous-dependencies\n  const PropTypes = require('prop-types')\n  JsxParser.propTypes = {\n    allowUnknownElements: PropTypes.bool,\n    bindings: PropTypes.shape({}),\n    blacklistedAttrs: PropTypes.arrayOf(PropTypes.oneOfType([\n      PropTypes.string,\n      PropTypes.instanceOf(RegExp),\n    ])),\n    blacklistedTags: PropTypes.arrayOf(PropTypes.string),\n    components: PropTypes.shape({}),\n    componentsOnly: PropTypes.bool,\n    disableFragments: PropTypes.bool,\n    disableKeyGeneration: PropTypes.bool,\n    jsx: PropTypes.string,\n    onError: PropTypes.func,\n    showWarnings: PropTypes.bool,\n    renderError: PropTypes.func,\n    renderInWrapper: PropTypes.bool,\n  }\n}\n","'use strict';\n\nvar React = require('react');\n\nvar xtend = require('xtend');\n\nvar ReactIs = require('react-is');\n\nvar defaultNodePosition = {\n  start: {\n    line: 1,\n    column: 1,\n    offset: 0\n  },\n  end: {\n    line: 1,\n    column: 1,\n    offset: 0\n  }\n};\n\nfunction astToReact(node, options) {\n  var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;\n  var renderer = options.renderers[node.type]; // nodes generated by plugins may not have position data\n  // much of the code after this point will attempt to access properties of the node.position\n  // this will set the node position to the parent node's position to prevent errors\n\n  if (node.position === undefined) {\n    node.position = parent.node && parent.node.position || defaultNodePosition;\n  }\n\n  var pos = node.position.start;\n  var key = [node.type, pos.line, pos.column, index].join('-');\n\n  if (!ReactIs.isValidElementType(renderer)) {\n    throw new Error(\"Renderer for type `\".concat(node.type, \"` not defined or is not renderable\"));\n  }\n\n  var nodeProps = getNodeProps(node, key, options, renderer, parent, index);\n  return React.createElement(renderer, nodeProps, nodeProps.children || resolveChildren() || undefined);\n\n  function resolveChildren() {\n    return node.children && node.children.map(function (childNode, i) {\n      return astToReact(childNode, options, {\n        node: node,\n        props: nodeProps\n      }, i);\n    });\n  }\n} // eslint-disable-next-line max-params, complexity\n\n\nfunction getNodeProps(node, key, opts, renderer, parent, index) {\n  var props = {\n    key: key\n  };\n  var isTagRenderer = typeof renderer === 'string'; // `sourcePos` is true if the user wants source information (line/column info from markdown source)\n\n  if (opts.sourcePos && node.position) {\n    props['data-sourcepos'] = flattenPosition(node.position);\n  }\n\n  if (opts.rawSourcePos && !isTagRenderer) {\n    props.sourcePosition = node.position;\n  } // If `includeNodeIndex` is true, pass node index info to all non-tag renderers\n\n\n  if (opts.includeNodeIndex && parent.node && parent.node.children && !isTagRenderer) {\n    props.index = parent.node.children.indexOf(node);\n    props.parentChildCount = parent.node.children.length;\n  }\n\n  var ref = node.identifier !== null && node.identifier !== undefined ? opts.definitions[node.identifier] || {} : null;\n\n  switch (node.type) {\n    case 'root':\n      assignDefined(props, {\n        className: opts.className\n      });\n      break;\n\n    case 'text':\n      props.nodeKey = key;\n      props.children = node.value;\n      break;\n\n    case 'heading':\n      props.level = node.depth;\n      break;\n\n    case 'list':\n      props.start = node.start;\n      props.ordered = node.ordered;\n      props.tight = !node.loose;\n      props.depth = node.depth;\n      break;\n\n    case 'listItem':\n      props.checked = node.checked;\n      props.tight = !node.loose;\n      props.ordered = node.ordered;\n      props.index = node.index;\n      props.children = getListItemChildren(node, parent).map(function (childNode, i) {\n        return astToReact(childNode, opts, {\n          node: node,\n          props: props\n        }, i);\n      });\n      break;\n\n    case 'definition':\n      assignDefined(props, {\n        identifier: node.identifier,\n        title: node.title,\n        url: node.url\n      });\n      break;\n\n    case 'code':\n      assignDefined(props, {\n        language: node.lang && node.lang.split(/\\s/, 1)[0]\n      });\n      break;\n\n    case 'inlineCode':\n      props.children = node.value;\n      props.inline = true;\n      break;\n\n    case 'link':\n      assignDefined(props, {\n        title: node.title || undefined,\n        target: typeof opts.linkTarget === 'function' ? opts.linkTarget(node.url, node.children, node.title) : opts.linkTarget,\n        href: opts.transformLinkUri ? opts.transformLinkUri(node.url, node.children, node.title) : node.url\n      });\n      break;\n\n    case 'image':\n      assignDefined(props, {\n        alt: node.alt || undefined,\n        title: node.title || undefined,\n        src: opts.transformImageUri ? opts.transformImageUri(node.url, node.children, node.title, node.alt) : node.url\n      });\n      break;\n\n    case 'linkReference':\n      assignDefined(props, xtend(ref, {\n        href: opts.transformLinkUri ? opts.transformLinkUri(ref.href) : ref.href\n      }));\n      break;\n\n    case 'imageReference':\n      assignDefined(props, {\n        src: opts.transformImageUri && ref.href ? opts.transformImageUri(ref.href, node.children, ref.title, node.alt) : ref.href,\n        title: ref.title || undefined,\n        alt: node.alt || undefined\n      });\n      break;\n\n    case 'table':\n    case 'tableHead':\n    case 'tableBody':\n      props.columnAlignment = node.align;\n      break;\n\n    case 'tableRow':\n      props.isHeader = parent.node.type === 'tableHead';\n      props.columnAlignment = parent.props.columnAlignment;\n      break;\n\n    case 'tableCell':\n      assignDefined(props, {\n        isHeader: parent.props.isHeader,\n        align: parent.props.columnAlignment[index]\n      });\n      break;\n\n    case 'virtualHtml':\n      props.tag = node.tag;\n      break;\n\n    case 'html':\n      // @todo find a better way than this\n      props.isBlock = node.position.start.line !== node.position.end.line;\n      props.escapeHtml = opts.escapeHtml;\n      props.skipHtml = opts.skipHtml;\n      break;\n\n    case 'parsedHtml':\n      {\n        var parsedChildren;\n\n        if (node.children) {\n          parsedChildren = node.children.map(function (child, i) {\n            return astToReact(child, opts, {\n              node: node,\n              props: props\n            }, i);\n          });\n        }\n\n        props.escapeHtml = opts.escapeHtml;\n        props.skipHtml = opts.skipHtml;\n        props.element = mergeNodeChildren(node, parsedChildren);\n        break;\n      }\n\n    default:\n      assignDefined(props, xtend(node, {\n        type: undefined,\n        position: undefined,\n        children: undefined\n      }));\n  }\n\n  if (!isTagRenderer && node.value) {\n    props.value = node.value;\n  }\n\n  return props;\n}\n\nfunction assignDefined(target, attrs) {\n  for (var key in attrs) {\n    if (typeof attrs[key] !== 'undefined') {\n      target[key] = attrs[key];\n    }\n  }\n}\n\nfunction mergeNodeChildren(node, parsedChildren) {\n  var el = node.element;\n\n  if (Array.isArray(el)) {\n    var Fragment = React.Fragment || 'div';\n    return React.createElement(Fragment, null, el);\n  }\n\n  if (el.props.children || parsedChildren) {\n    var children = React.Children.toArray(el.props.children).concat(parsedChildren);\n    return React.cloneElement(el, null, children);\n  }\n\n  return React.cloneElement(el, null);\n}\n\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(String).join('');\n}\n\nfunction getListItemChildren(node, parent) {\n  if (node.loose) {\n    return node.children;\n  }\n\n  if (parent.node && node.index > 0 && parent.node.children[node.index - 1].loose) {\n    return node.children;\n  }\n\n  return unwrapParagraphs(node);\n}\n\nfunction unwrapParagraphs(node) {\n  return node.children.reduce(function (array, child) {\n    return array.concat(child.type === 'paragraph' ? child.children || [] : [child]);\n  }, []);\n}\n\nmodule.exports = astToReact;","'use strict';\n\nmodule.exports = function getDefinitions(node) {\n  var defs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return (node.children || []).reduce(function (definitions, child) {\n    if (child.type === 'definition') {\n      definitions[child.identifier] = {\n        href: child.url,\n        title: child.title\n      };\n    }\n\n    return getDefinitions(child, definitions);\n  }, defs);\n};","\"use strict\";\n\nvar visit = require('unist-util-visit');\n\nexports.ofType = function (types, mode) {\n  return function (node) {\n    types.forEach(function (type) {\n      return visit(node, type, disallow, true);\n    });\n    return node;\n  };\n\n  function disallow(node, index, parent) {\n    if (parent) {\n      untangle(node, index, parent, mode);\n    }\n  }\n};\n\nexports.ifNotMatch = function (allowNode, mode) {\n  return function (node) {\n    visit(node, disallow, true);\n    return node;\n  };\n\n  function disallow(node, index, parent) {\n    if (parent && !allowNode(node, index, parent)) {\n      untangle(node, index, parent, mode);\n    }\n  }\n};\n\nfunction untangle(node, index, parent, mode) {\n  if (mode === 'remove') {\n    parent.children.splice(index, 1);\n  } else if (mode === 'unwrap') {\n    var args = [index, 1];\n\n    if (node.children) {\n      args = args.concat(node.children);\n    }\n\n    Array.prototype.splice.apply(parent.children, args);\n  }\n}","\"use strict\";\n\n/**\n * Naive, simple plugin to match inline nodes without attributes\n * This allows say <strong>foo</strong>, but not <strong class=\"very\">foo</strong>\n * For proper HTML support, you'll want a different plugin\n **/\nvar visit = require('unist-util-visit');\n\nvar type = 'virtualHtml';\nvar selfClosingRe = /^<(area|base|br|col|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)\\s*\\/?>$/i;\nvar simpleTagRe = /^<(\\/?)([a-z]+)\\s*>$/;\n\nmodule.exports = function (tree) {\n  var open;\n  var currentParent;\n  visit(tree, 'html', function (node, index, parent) {\n    if (currentParent !== parent) {\n      open = [];\n      currentParent = parent;\n    }\n\n    var selfClosing = getSelfClosing(node);\n\n    if (selfClosing) {\n      parent.children.splice(index, 1, {\n        type: type,\n        tag: selfClosing,\n        position: node.position\n      });\n      return true;\n    }\n\n    var current = getSimpleTag(node, parent);\n\n    if (!current) {\n      return true;\n    }\n\n    var matching = findAndPull(open, current.tag);\n\n    if (matching) {\n      parent.children.splice(index, 0, virtual(current, matching, parent));\n    } else if (!current.opening) {\n      open.push(current);\n    }\n\n    return true;\n  }, true // Iterate in reverse\n  );\n  return tree;\n};\n\nfunction findAndPull(open, matchingTag) {\n  var i = open.length;\n\n  while (i--) {\n    if (open[i].tag === matchingTag) {\n      return open.splice(i, 1)[0];\n    }\n  }\n\n  return false;\n}\n\nfunction getSimpleTag(node, parent) {\n  var match = node.value.match(simpleTagRe);\n  return match ? {\n    tag: match[2],\n    opening: !match[1],\n    node: node\n  } : false;\n}\n\nfunction getSelfClosing(node) {\n  var match = node.value.match(selfClosingRe);\n  return match ? match[1] : false;\n}\n\nfunction virtual(fromNode, toNode, parent) {\n  var fromIndex = parent.children.indexOf(fromNode.node);\n  var toIndex = parent.children.indexOf(toNode.node);\n  var extracted = parent.children.splice(fromIndex, toIndex - fromIndex + 1);\n  var children = extracted.slice(1, -1);\n  return {\n    type: type,\n    children: children,\n    tag: fromNode.tag,\n    position: {\n      start: fromNode.node.position.start,\n      end: toNode.node.position.end,\n      indent: []\n    }\n  };\n}","'use strict';\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance\"); }\n\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }\n\nvar xtend = require('xtend');\n\nvar unified = require('unified');\n\nvar parse = require('remark-parse');\n\nvar PropTypes = require('prop-types');\n\nvar addListMetadata = require('mdast-add-list-metadata');\n\nvar naiveHtml = require('./plugins/naive-html');\n\nvar disallowNode = require('./plugins/disallow-node');\n\nvar astToReact = require('./ast-to-react');\n\nvar wrapTableRows = require('./wrap-table-rows');\n\nvar getDefinitions = require('./get-definitions');\n\nvar uriTransformer = require('./uri-transformer');\n\nvar defaultRenderers = require('./renderers');\n\nvar symbols = require('./symbols');\n\nvar allTypes = Object.keys(defaultRenderers);\n\nvar ReactMarkdown = function ReactMarkdown(props) {\n  var src = props.source || props.children || '';\n  var parserOptions = props.parserOptions;\n\n  if (props.allowedTypes && props.disallowedTypes) {\n    throw new Error('Only one of `allowedTypes` and `disallowedTypes` should be defined');\n  }\n\n  var renderers = xtend(defaultRenderers, props.renderers);\n  var plugins = [[parse, parserOptions]].concat(props.plugins || []);\n  var parser = plugins.reduce(applyParserPlugin, unified());\n  var rawAst = parser.parse(src);\n  var renderProps = xtend(props, {\n    renderers: renderers,\n    definitions: getDefinitions(rawAst)\n  });\n  var astPlugins = determineAstPlugins(props); // eslint-disable-next-line no-sync\n\n  var transformedAst = parser.runSync(rawAst);\n  var ast = astPlugins.reduce(function (node, plugin) {\n    return plugin(node, renderProps);\n  }, transformedAst);\n  return astToReact(ast, renderProps);\n};\n\nfunction applyParserPlugin(parser, plugin) {\n  return Array.isArray(plugin) ? parser.use.apply(parser, _toConsumableArray(plugin)) : parser.use(plugin);\n}\n\nfunction determineAstPlugins(props) {\n  var plugins = [wrapTableRows, addListMetadata()];\n  var disallowedTypes = props.disallowedTypes;\n\n  if (props.allowedTypes) {\n    disallowedTypes = allTypes.filter(function (type) {\n      return type !== 'root' && props.allowedTypes.indexOf(type) === -1;\n    });\n  }\n\n  var removalMethod = props.unwrapDisallowed ? 'unwrap' : 'remove';\n\n  if (disallowedTypes && disallowedTypes.length > 0) {\n    plugins.push(disallowNode.ofType(disallowedTypes, removalMethod));\n  }\n\n  if (props.allowNode) {\n    plugins.push(disallowNode.ifNotMatch(props.allowNode, removalMethod));\n  }\n\n  var renderHtml = !props.escapeHtml && !props.skipHtml;\n  var hasHtmlParser = (props.astPlugins || []).some(function (item) {\n    var plugin = Array.isArray(item) ? item[0] : item;\n    return plugin.identity === symbols.HtmlParser;\n  });\n\n  if (renderHtml && !hasHtmlParser) {\n    plugins.push(naiveHtml);\n  }\n\n  return props.astPlugins ? plugins.concat(props.astPlugins) : plugins;\n}\n\nReactMarkdown.defaultProps = {\n  renderers: {},\n  escapeHtml: true,\n  skipHtml: false,\n  sourcePos: false,\n  rawSourcePos: false,\n  transformLinkUri: uriTransformer,\n  astPlugins: [],\n  plugins: [],\n  parserOptions: {}\n};\nReactMarkdown.propTypes = {\n  className: PropTypes.string,\n  source: PropTypes.string,\n  children: PropTypes.string,\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  escapeHtml: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  allowNode: PropTypes.func,\n  allowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  disallowedTypes: PropTypes.arrayOf(PropTypes.oneOf(allTypes)),\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  astPlugins: PropTypes.arrayOf(PropTypes.func),\n  unwrapDisallowed: PropTypes.bool,\n  renderers: PropTypes.object,\n  plugins: PropTypes.array,\n  parserOptions: PropTypes.object\n};\nReactMarkdown.types = allTypes;\nReactMarkdown.renderers = defaultRenderers;\nReactMarkdown.uriTransformer = uriTransformer;\nmodule.exports = ReactMarkdown;","/* eslint-disable react/prop-types, react/no-multi-comp */\n'use strict';\n\nvar xtend = require('xtend');\n\nvar React = require('react');\n\nvar supportsStringRender = parseInt((React.version || '16').slice(0, 2), 10) >= 16;\nvar createElement = React.createElement;\nmodule.exports = {\n  break: 'br',\n  paragraph: 'p',\n  emphasis: 'em',\n  strong: 'strong',\n  thematicBreak: 'hr',\n  blockquote: 'blockquote',\n  delete: 'del',\n  link: 'a',\n  image: 'img',\n  linkReference: 'a',\n  imageReference: 'img',\n  table: SimpleRenderer.bind(null, 'table'),\n  tableHead: SimpleRenderer.bind(null, 'thead'),\n  tableBody: SimpleRenderer.bind(null, 'tbody'),\n  tableRow: SimpleRenderer.bind(null, 'tr'),\n  tableCell: TableCell,\n  root: Root,\n  text: TextRenderer,\n  list: List,\n  listItem: ListItem,\n  definition: NullRenderer,\n  heading: Heading,\n  inlineCode: InlineCode,\n  code: CodeBlock,\n  html: Html,\n  virtualHtml: VirtualHtml,\n  parsedHtml: ParsedHtml\n};\n\nfunction TextRenderer(props) {\n  return supportsStringRender ? props.children : createElement('span', null, props.children);\n}\n\nfunction Root(props) {\n  var useFragment = !props.className;\n  var root = useFragment ? React.Fragment || 'div' : 'div';\n  return createElement(root, useFragment ? null : props, props.children);\n}\n\nfunction SimpleRenderer(tag, props) {\n  return createElement(tag, getCoreProps(props), props.children);\n}\n\nfunction TableCell(props) {\n  var style = props.align ? {\n    textAlign: props.align\n  } : undefined;\n  var coreProps = getCoreProps(props);\n  return createElement(props.isHeader ? 'th' : 'td', style ? xtend({\n    style: style\n  }, coreProps) : coreProps, props.children);\n}\n\nfunction Heading(props) {\n  return createElement(\"h\".concat(props.level), getCoreProps(props), props.children);\n}\n\nfunction List(props) {\n  var attrs = getCoreProps(props);\n\n  if (props.start !== null && props.start !== 1 && props.start !== undefined) {\n    attrs.start = props.start.toString();\n  }\n\n  return createElement(props.ordered ? 'ol' : 'ul', attrs, props.children);\n}\n\nfunction ListItem(props) {\n  var checkbox = null;\n\n  if (props.checked !== null && props.checked !== undefined) {\n    var checked = props.checked;\n    checkbox = createElement('input', {\n      type: 'checkbox',\n      checked: checked,\n      readOnly: true\n    });\n  }\n\n  return createElement('li', getCoreProps(props), checkbox, props.children);\n}\n\nfunction CodeBlock(props) {\n  var className = props.language && \"language-\".concat(props.language);\n  var code = createElement('code', className ? {\n    className: className\n  } : null, props.value);\n  return createElement('pre', getCoreProps(props), code);\n}\n\nfunction InlineCode(props) {\n  return createElement('code', getCoreProps(props), props.children);\n}\n\nfunction Html(props) {\n  if (props.skipHtml) {\n    return null;\n  }\n\n  var tag = props.isBlock ? 'div' : 'span';\n\n  if (props.escapeHtml) {\n    var comp = React.Fragment || tag;\n    return createElement(comp, null, props.value);\n  }\n\n  var nodeProps = {\n    dangerouslySetInnerHTML: {\n      __html: props.value\n    }\n  };\n  return createElement(tag, nodeProps);\n}\n\nfunction ParsedHtml(props) {\n  return props['data-sourcepos'] ? React.cloneElement(props.element, {\n    'data-sourcepos': props['data-sourcepos']\n  }) : props.element;\n}\n\nfunction VirtualHtml(props) {\n  return createElement(props.tag, getCoreProps(props), props.children);\n}\n\nfunction NullRenderer() {\n  return null;\n}\n\nfunction getCoreProps(props) {\n  return props['data-sourcepos'] ? {\n    'data-sourcepos': props['data-sourcepos']\n  } : {};\n}","\"use strict\";\n\nvar HtmlParser = '__RMD_HTML_PARSER__';\nexports.HtmlParser = typeof Symbol === 'undefined' ? HtmlParser : Symbol(HtmlParser);","\"use strict\";\n\nvar protocols = ['http', 'https', 'mailto', 'tel'];\n\nmodule.exports = function uriTransformer(uri) {\n  var url = (uri || '').trim();\n  var first = url.charAt(0);\n\n  if (first === '#' || first === '/') {\n    return url;\n  }\n\n  var colon = url.indexOf(':');\n\n  if (colon === -1) {\n    return url;\n  }\n\n  var length = protocols.length;\n  var index = -1;\n\n  while (++index < length) {\n    var protocol = protocols[index];\n\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n\n  index = url.indexOf('?');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n\n  index = url.indexOf('#');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n\n  return 'javascript:void(0)';\n};","'use strict';\n\nvar visit = require('unist-util-visit');\n\nmodule.exports = function (node) {\n  visit(node, 'table', wrap);\n  return node;\n};\n\nfunction wrap(table) {\n  var children = table.children;\n  table.children = [{\n    type: 'tableHead',\n    align: table.align,\n    children: [children[0]],\n    position: children[0].position\n  }];\n\n  if (children.length > 1) {\n    table.children.push({\n      type: 'tableBody',\n      align: table.align,\n      children: children.slice(1),\n      position: {\n        start: children[1].position.start,\n        end: children[children.length - 1].position.end\n      }\n    });\n  }\n}","const util = require('./util')\n\nmodule.exports = mathBlock\n\nconst lineFeed = 10 //  '\\n'\nconst space = 32 // ' '\nconst dollarSign = 36 // '$'\n\nconst lineFeedChar = '\\n'\nconst dollarSignChar = '$'\n\nconst minFenceCount = 2\n\nconst classList = ['math', 'math-display']\n\nfunction mathBlock() {\n  const parser = this.Parser\n  const compiler = this.Compiler\n\n  if (util.isRemarkParser(parser)) {\n    attachParser(parser)\n  }\n\n  if (util.isRemarkCompiler(compiler)) {\n    attachCompiler(compiler)\n  }\n}\n\nfunction attachParser(parser) {\n  const proto = parser.prototype\n  const blockMethods = proto.blockMethods\n  const interruptParagraph = proto.interruptParagraph\n  const interruptList = proto.interruptList\n  const interruptBlockquote = proto.interruptBlockquote\n\n  proto.blockTokenizers.math = mathBlockTokenizer\n\n  blockMethods.splice(blockMethods.indexOf('fencedCode') + 1, 0, 'math')\n\n  // Inject math to interrupt rules\n  interruptParagraph.splice(interruptParagraph.indexOf('fencedCode') + 1, 0, [\n    'math'\n  ])\n  interruptList.splice(interruptList.indexOf('fencedCode') + 1, 0, ['math'])\n  interruptBlockquote.splice(interruptBlockquote.indexOf('fencedCode') + 1, 0, [\n    'math'\n  ])\n\n  function mathBlockTokenizer(eat, value, silent) {\n    var length = value.length\n    var index = 0\n    let code\n    let content\n    let lineEnd\n    let lineIndex\n    let openingFenceIndentSize\n    let openingFenceSize\n    let openingFenceContentStart\n    let closingFence\n    let closingFenceSize\n    let lineContentStart\n    let lineContentEnd\n\n    // Skip initial spacing.\n    while (index < length && value.charCodeAt(index) === space) {\n      index++\n    }\n\n    openingFenceIndentSize = index\n\n    // Skip the fence.\n    while (index < length && value.charCodeAt(index) === dollarSign) {\n      index++\n    }\n\n    openingFenceSize = index - openingFenceIndentSize\n\n    // Exit if there is not enough of a fence.\n    if (openingFenceSize < minFenceCount) {\n      return\n    }\n\n    // Skip spacing after the fence.\n    while (index < length && value.charCodeAt(index) === space) {\n      index++\n    }\n\n    openingFenceContentStart = index\n\n    // Eat everything after the fence.\n    while (index < length) {\n      code = value.charCodeAt(index)\n\n      // We don’t allow dollar signs here, as that could interfere with inline\n      // math.\n      if (code === dollarSign) {\n        return\n      }\n\n      if (code === lineFeed) {\n        break\n      }\n\n      index++\n    }\n\n    if (value.charCodeAt(index) !== lineFeed) {\n      return\n    }\n\n    if (silent) {\n      return true\n    }\n\n    content = []\n\n    if (openingFenceContentStart !== index) {\n      content.push(value.slice(openingFenceContentStart, index))\n    }\n\n    index++\n    lineEnd = value.indexOf(lineFeedChar, index + 1)\n    lineEnd = lineEnd === -1 ? length : lineEnd\n\n    while (index < length) {\n      closingFence = false\n      lineContentStart = index\n      lineContentEnd = lineEnd\n      lineIndex = lineEnd\n      closingFenceSize = 0\n\n      // First, let’s see if this is a valid closing fence.\n      // Skip trailing white space\n      while (\n        lineIndex > lineContentStart &&\n        value.charCodeAt(lineIndex - 1) === space\n      ) {\n        lineIndex--\n      }\n\n      // Skip the fence.\n      while (\n        lineIndex > lineContentStart &&\n        value.charCodeAt(lineIndex - 1) === dollarSign\n      ) {\n        closingFenceSize++\n        lineIndex--\n      }\n\n      // Check if this is a valid closing fence line.\n      if (\n        openingFenceSize <= closingFenceSize &&\n        value.indexOf(dollarSignChar, lineContentStart) === lineIndex\n      ) {\n        closingFence = true\n        lineContentEnd = lineIndex\n      }\n\n      // Sweet, next, we need to trim the line.\n      // Skip initial spacing.\n      while (\n        lineContentStart <= lineContentEnd &&\n        lineContentStart - index < openingFenceIndentSize &&\n        value.charCodeAt(lineContentStart) === space\n      ) {\n        lineContentStart++\n      }\n\n      // If this is a closing fence, skip final spacing.\n      if (closingFence) {\n        while (\n          lineContentEnd > lineContentStart &&\n          value.charCodeAt(lineContentEnd - 1) === space\n        ) {\n          lineContentEnd--\n        }\n      }\n\n      // If this is a content line, or if there is content before the fence:\n      if (!closingFence || lineContentStart !== lineContentEnd) {\n        content.push(value.slice(lineContentStart, lineContentEnd))\n      }\n\n      if (closingFence) {\n        break\n      }\n\n      index = lineEnd + 1\n      lineEnd = value.indexOf(lineFeedChar, index + 1)\n      lineEnd = lineEnd === -1 ? length : lineEnd\n    }\n\n    content = content.join('\\n')\n\n    return eat(value.slice(0, lineEnd))({\n      type: 'math',\n      value: content,\n      data: {\n        hName: 'div',\n        hProperties: {className: classList.concat()},\n        hChildren: [{type: 'text', value: content}]\n      }\n    })\n  }\n}\n\nfunction attachCompiler(compiler) {\n  const proto = compiler.prototype\n\n  proto.visitors.math = compileBlockMath\n\n  function compileBlockMath(node) {\n    return '$$\\n' + node.value + '\\n$$'\n  }\n}\n","const inlinePlugin = require('./inline')\nconst blockPlugin = require('./block')\n\nmodule.exports = math\n\nfunction math(options) {\n  var settings = options || {}\n  blockPlugin.call(this, settings)\n  inlinePlugin.call(this, settings)\n}\n","var util = require('./util')\n\nmodule.exports = mathInline\n\nconst tab = 9 // '\\t'\nconst space = 32 // ' '\nconst dollarSign = 36 // '$'\nconst digit0 = 48 // '0'\nconst digit9 = 57 // '9'\nconst backslash = 92 // '\\\\'\n\nconst classList = ['math', 'math-inline']\nconst mathDisplay = 'math-display'\n\nfunction mathInline(options) {\n  const parser = this.Parser\n  const compiler = this.Compiler\n\n  if (util.isRemarkParser(parser)) {\n    attachParser(parser, options)\n  }\n\n  if (util.isRemarkCompiler(compiler)) {\n    attachCompiler(compiler, options)\n  }\n}\n\nfunction attachParser(parser, options) {\n  const proto = parser.prototype\n  const inlineMethods = proto.inlineMethods\n\n  mathInlineTokenizer.locator = locator\n\n  proto.inlineTokenizers.math = mathInlineTokenizer\n\n  inlineMethods.splice(inlineMethods.indexOf('text'), 0, 'math')\n\n  function locator(value, fromIndex) {\n    return value.indexOf('$', fromIndex)\n  }\n\n  function mathInlineTokenizer(eat, value, silent) {\n    const length = value.length\n    let double = false\n    let escaped = false\n    let index = 0\n    let previous\n    let code\n    let next\n    let contentStart\n    let contentEnd\n    let valueEnd\n    let content\n\n    if (value.charCodeAt(index) === backslash) {\n      escaped = true\n      index++\n    }\n\n    if (value.charCodeAt(index) !== dollarSign) {\n      return\n    }\n\n    index++\n\n    // Support escaped dollars.\n    if (escaped) {\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true\n      }\n\n      return eat(value.slice(0, index))({type: 'text', value: '$'})\n    }\n\n    if (value.charCodeAt(index) === dollarSign) {\n      double = true\n      index++\n    }\n\n    next = value.charCodeAt(index)\n\n    // Opening fence cannot be followed by a space or a tab.\n    if (next === space || next === tab) {\n      return\n    }\n\n    contentStart = index\n\n    while (index < length) {\n      code = next\n      next = value.charCodeAt(index + 1)\n\n      if (code === dollarSign) {\n        previous = value.charCodeAt(index - 1)\n\n        // Closing fence cannot be preceded by a space or a tab, or followed by\n        // a digit.\n        // If a double marker was used to open, the closing fence must consist\n        // of two dollars as well.\n        if (\n          previous !== space &&\n          previous !== tab &&\n          // eslint-disable-next-line no-self-compare\n          (next !== next || next < digit0 || next > digit9) &&\n          (!double || next === dollarSign)\n        ) {\n          contentEnd = index - 1\n\n          index++\n\n          if (double) {\n            index++\n          }\n\n          valueEnd = index\n          break\n        }\n      } else if (code === backslash) {\n        index++\n        next = value.charCodeAt(index + 1)\n      }\n\n      index++\n    }\n\n    if (valueEnd === undefined) {\n      return\n    }\n\n    /* istanbul ignore if - never used (yet) */\n    if (silent) {\n      return true\n    }\n\n    content = value.slice(contentStart, contentEnd + 1)\n\n    return eat(value.slice(0, valueEnd))({\n      type: 'inlineMath',\n      value: content,\n      data: {\n        hName: 'span',\n        hProperties: {\n          className: classList.concat(\n            double && options.inlineMathDouble ? [mathDisplay] : []\n          )\n        },\n        hChildren: [{type: 'text', value: content}]\n      }\n    })\n  }\n}\n\nfunction attachCompiler(compiler) {\n  const proto = compiler.prototype\n\n  proto.visitors.inlineMath = compileInlineMath\n\n  function compileInlineMath(node) {\n    let fence = '$'\n    const classes =\n      (node.data && node.data.hProperties && node.data.hProperties.className) ||\n      []\n\n    if (classes.includes(mathDisplay)) {\n      fence = '$$'\n    }\n\n    return fence + node.value + fence\n  }\n}\n","exports.isRemarkParser = isRemarkParser\nexports.isRemarkCompiler = isRemarkCompiler\n\nfunction isRemarkParser(parser) {\n  return Boolean(parser && parser.prototype && parser.prototype.blockTokenizers)\n}\n\nfunction isRemarkCompiler(compiler) {\n  return Boolean(compiler && compiler.prototype && compiler.prototype.visitors)\n}\n","'use strict'\n\nmodule.exports = bail\n\nfunction bail(err) {\n  if (err) {\n    throw err\n  }\n}\n","'use strict'\n\nmodule.exports = collapse\n\n// `collapse(' \\t\\nbar \\nbaz\\t') // ' bar baz '`\nfunction collapse(value) {\n  return String(value).replace(/\\s+/g, ' ')\n}\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","'use strict'\n\nmodule.exports = alphabetical\n\n// Check if the given character code, or the character code at the first\n// character, is alphabetical.\nfunction alphabetical(character) {\n  var code = typeof character === 'string' ? character.charCodeAt(0) : character\n\n  return (\n    (code >= 97 && code <= 122) /* a-z */ ||\n    (code >= 65 && code <= 90) /* A-Z */\n  )\n}\n","'use strict'\n\nvar alphabetical = require('is-alphabetical')\nvar decimal = require('is-decimal')\n\nmodule.exports = alphanumerical\n\n// Check if the given character code, or the character code at the first\n// character, is alphanumerical.\nfunction alphanumerical(character) {\n  return alphabetical(character) || decimal(character)\n}\n","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\n// The _isBuffer check is for Safari 5-7 support, because it's missing\n// Object.prototype.constructor. Remove this eventually\nmodule.exports = function (obj) {\n  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)\n}\n\nfunction isBuffer (obj) {\n  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n\n// For Node v0.10 support. Remove this eventually.\nfunction isSlowBuffer (obj) {\n  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))\n}\n","'use strict'\n\nmodule.exports = decimal\n\n// Check if the given character code, or the character code at the first\n// character, is decimal.\nfunction decimal(character) {\n  var code = typeof character === 'string' ? character.charCodeAt(0) : character\n\n  return code >= 48 && code <= 57 /* 0-9 */\n}\n","'use strict'\n\nmodule.exports = hexadecimal\n\n// Check if the given character code, or the character code at the first\n// character, is hexadecimal.\nfunction hexadecimal(character) {\n  var code = typeof character === 'string' ? character.charCodeAt(0) : character\n\n  return (\n    (code >= 97 /* a */ && code <= 102) /* z */ ||\n    (code >= 65 /* A */ && code <= 70) /* Z */ ||\n    (code >= 48 /* A */ && code <= 57) /* Z */\n  )\n}\n","'use strict'\n\nmodule.exports = whitespace\n\nvar fromCode = String.fromCharCode\nvar re = /\\s/\n\n// Check if the given character code, or the character code at the first\n// character, is a whitespace character.\nfunction whitespace(character) {\n  return re.test(\n    typeof character === 'number' ? fromCode(character) : character.charAt(0)\n  )\n}\n","'use strict'\n\nmodule.exports = wordCharacter\n\nvar fromCode = String.fromCharCode\nvar re = /\\w/\n\n// Check if the given character code, or the character code at the first\n// character, is a word character.\nfunction wordCharacter(character) {\n  return re.test(\n    typeof character === 'number' ? fromCode(character) : character.charAt(0)\n  )\n}\n","'use strict'\n\nmodule.exports = escapes\n\nvar defaults = [\n  '\\\\',\n  '`',\n  '*',\n  '{',\n  '}',\n  '[',\n  ']',\n  '(',\n  ')',\n  '#',\n  '+',\n  '-',\n  '.',\n  '!',\n  '_',\n  '>'\n]\n\nvar gfm = defaults.concat(['~', '|'])\n\nvar commonmark = gfm.concat([\n  '\\n',\n  '\"',\n  '$',\n  '%',\n  '&',\n  \"'\",\n  ',',\n  '/',\n  ':',\n  ';',\n  '<',\n  '=',\n  '?',\n  '@',\n  '^'\n])\n\nescapes.default = defaults\nescapes.gfm = gfm\nescapes.commonmark = commonmark\n\n// Get markdown escapes.\nfunction escapes(options) {\n  var settings = options || {}\n\n  if (settings.commonmark) {\n    return commonmark\n  }\n\n  return settings.gfm ? gfm : defaults\n}\n","var visitWithParents = require('unist-util-visit-parents');\n\nfunction addListMetadata() {\n  return function (ast) {\n    visitWithParents(ast, 'list', function (listNode, parents) {\n      var depth = 0, i, n;\n      for (i = 0, n = parents.length; i < n; i++) {\n        if (parents[i].type === 'list') depth += 1;\n      }\n      for (i = 0, n = listNode.children.length; i < n; i++) {\n        var child = listNode.children[i];\n        child.index = i;\n        child.ordered = listNode.ordered;\n      }\n      listNode.depth = depth;\n    });\n    return ast;\n  };\n}\n\nmodule.exports = addListMetadata;\n","'use strict'\n\n/* eslint-env browser */\n\nvar el\n\nvar semicolon = 59 //  ';'\n\nmodule.exports = decodeEntity\n\nfunction decodeEntity(characters) {\n  var entity = '&' + characters + ';'\n  var char\n\n  el = el || document.createElement('i')\n  el.innerHTML = entity\n  char = el.textContent\n\n  // Some entities do not require the closing semicolon (`&not` - for instance),\n  // which leads to situations where parsing the assumed entity of &notit; will\n  // result in the string `¬it;`.  When we encounter a trailing semicolon after\n  // parsing and the entity to decode was not a semicolon (`&semi;`), we can\n  // assume that the matching was incomplete\n  if (char.charCodeAt(char.length - 1) === semicolon && characters !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the entity was not valid\n  return char === entity ? false : char\n}\n","'use strict'\n\nvar legacy = require('character-entities-legacy')\nvar invalid = require('character-reference-invalid')\nvar decimal = require('is-decimal')\nvar hexadecimal = require('is-hexadecimal')\nvar alphanumerical = require('is-alphanumerical')\nvar decodeEntity = require('./decode-entity')\n\nmodule.exports = parseEntities\n\nvar own = {}.hasOwnProperty\nvar fromCharCode = String.fromCharCode\nvar noop = Function.prototype\n\n// Default settings.\nvar defaults = {\n  warning: null,\n  reference: null,\n  text: null,\n  warningContext: null,\n  referenceContext: null,\n  textContext: null,\n  position: {},\n  additional: null,\n  attribute: false,\n  nonTerminated: true\n}\n\n// Characters.\nvar tab = 9 // '\\t'\nvar lineFeed = 10 // '\\n'\nvar formFeed = 12 //  '\\f'\nvar space = 32 // ' '\nvar ampersand = 38 //  '&'\nvar semicolon = 59 //  ';'\nvar lessThan = 60 //  '<'\nvar equalsTo = 61 //  '='\nvar numberSign = 35 //  '#'\nvar uppercaseX = 88 //  'X'\nvar lowercaseX = 120 //  'x'\nvar replacementCharacter = 65533 // '�'\n\n// Reference types.\nvar name = 'named'\nvar hexa = 'hexadecimal'\nvar deci = 'decimal'\n\n// Map of bases.\nvar bases = {}\n\nbases[hexa] = 16\nbases[deci] = 10\n\n// Map of types to tests.\n// Each type of character reference accepts different characters.\n// This test is used to detect whether a reference has ended (as the semicolon\n// is not strictly needed).\nvar tests = {}\n\ntests[name] = alphanumerical\ntests[deci] = decimal\ntests[hexa] = hexadecimal\n\n// Warning types.\nvar namedNotTerminated = 1\nvar numericNotTerminated = 2\nvar namedEmpty = 3\nvar numericEmpty = 4\nvar namedUnknown = 5\nvar numericDisallowed = 6\nvar numericProhibited = 7\n\n// Warning messages.\nvar messages = {}\n\nmessages[namedNotTerminated] =\n  'Named character references must be terminated by a semicolon'\nmessages[numericNotTerminated] =\n  'Numeric character references must be terminated by a semicolon'\nmessages[namedEmpty] = 'Named character references cannot be empty'\nmessages[numericEmpty] = 'Numeric character references cannot be empty'\nmessages[namedUnknown] = 'Named character references must be known'\nmessages[numericDisallowed] =\n  'Numeric character references cannot be disallowed'\nmessages[numericProhibited] =\n  'Numeric character references cannot be outside the permissible Unicode range'\n\n// Wrap to ensure clean parameters are given to `parse`.\nfunction parseEntities(value, options) {\n  var settings = {}\n  var option\n  var key\n\n  if (!options) {\n    options = {}\n  }\n\n  for (key in defaults) {\n    option = options[key]\n    settings[key] =\n      option === null || option === undefined ? defaults[key] : option\n  }\n\n  if (settings.position.indent || settings.position.start) {\n    settings.indent = settings.position.indent || []\n    settings.position = settings.position.start\n  }\n\n  return parse(value, settings)\n}\n\n// Parse entities.\n// eslint-disable-next-line complexity\nfunction parse(value, settings) {\n  var additional = settings.additional\n  var nonTerminated = settings.nonTerminated\n  var handleText = settings.text\n  var handleReference = settings.reference\n  var handleWarning = settings.warning\n  var textContext = settings.textContext\n  var referenceContext = settings.referenceContext\n  var warningContext = settings.warningContext\n  var pos = settings.position\n  var indent = settings.indent || []\n  var length = value.length\n  var index = 0\n  var lines = -1\n  var column = pos.column || 1\n  var line = pos.line || 1\n  var queue = ''\n  var result = []\n  var entityCharacters\n  var namedEntity\n  var terminated\n  var characters\n  var character\n  var reference\n  var following\n  var warning\n  var reason\n  var output\n  var entity\n  var begin\n  var start\n  var type\n  var test\n  var prev\n  var next\n  var diff\n  var end\n\n  if (typeof additional === 'string') {\n    additional = additional.charCodeAt(0)\n  }\n\n  // Cache the current point.\n  prev = now()\n\n  // Wrap `handleWarning`.\n  warning = handleWarning ? parseError : noop\n\n  // Ensure the algorithm walks over the first character and the end (inclusive).\n  index--\n  length++\n\n  while (++index < length) {\n    // If the previous character was a newline.\n    if (character === lineFeed) {\n      column = indent[lines] || 1\n    }\n\n    character = value.charCodeAt(index)\n\n    if (character === ampersand) {\n      following = value.charCodeAt(index + 1)\n\n      // The behaviour depends on the identity of the next character.\n      if (\n        following === tab ||\n        following === lineFeed ||\n        following === formFeed ||\n        following === space ||\n        following === ampersand ||\n        following === lessThan ||\n        following !== following ||\n        (additional && following === additional)\n      ) {\n        // Not a character reference.\n        // No characters are consumed, and nothing is returned.\n        // This is not an error, either.\n        queue += fromCharCode(character)\n        column++\n\n        continue\n      }\n\n      start = index + 1\n      begin = start\n      end = start\n\n      if (following === numberSign) {\n        // Numerical entity.\n        end = ++begin\n\n        // The behaviour further depends on the next character.\n        following = value.charCodeAt(end)\n\n        if (following === uppercaseX || following === lowercaseX) {\n          // ASCII hex digits.\n          type = hexa\n          end = ++begin\n        } else {\n          // ASCII digits.\n          type = deci\n        }\n      } else {\n        // Named entity.\n        type = name\n      }\n\n      entityCharacters = ''\n      entity = ''\n      characters = ''\n      test = tests[type]\n      end--\n\n      while (++end < length) {\n        following = value.charCodeAt(end)\n\n        if (!test(following)) {\n          break\n        }\n\n        characters += fromCharCode(following)\n\n        // Check if we can match a legacy named reference.\n        // If so, we cache that as the last viable named reference.\n        // This ensures we do not need to walk backwards later.\n        if (type === name && own.call(legacy, characters)) {\n          entityCharacters = characters\n          entity = legacy[characters]\n        }\n      }\n\n      terminated = value.charCodeAt(end) === semicolon\n\n      if (terminated) {\n        end++\n\n        namedEntity = type === name ? decodeEntity(characters) : false\n\n        if (namedEntity) {\n          entityCharacters = characters\n          entity = namedEntity\n        }\n      }\n\n      diff = 1 + end - start\n\n      if (!terminated && !nonTerminated) {\n        // Empty.\n      } else if (!characters) {\n        // An empty (possible) entity is valid, unless it’s numeric (thus an\n        // ampersand followed by an octothorp).\n        if (type !== name) {\n          warning(numericEmpty, diff)\n        }\n      } else if (type === name) {\n        // An ampersand followed by anything unknown, and not terminated, is\n        // invalid.\n        if (terminated && !entity) {\n          warning(namedUnknown, 1)\n        } else {\n          // If theres something after an entity name which is not known, cap\n          // the reference.\n          if (entityCharacters !== characters) {\n            end = begin + entityCharacters.length\n            diff = 1 + end - begin\n            terminated = false\n          }\n\n          // If the reference is not terminated, warn.\n          if (!terminated) {\n            reason = entityCharacters ? namedNotTerminated : namedEmpty\n\n            if (settings.attribute) {\n              following = value.charCodeAt(end)\n\n              if (following === equalsTo) {\n                warning(reason, diff)\n                entity = null\n              } else if (alphanumerical(following)) {\n                entity = null\n              } else {\n                warning(reason, diff)\n              }\n            } else {\n              warning(reason, diff)\n            }\n          }\n        }\n\n        reference = entity\n      } else {\n        if (!terminated) {\n          // All non-terminated numeric entities are not rendered, and trigger a\n          // warning.\n          warning(numericNotTerminated, diff)\n        }\n\n        // When terminated and number, parse as either hexadecimal or decimal.\n        reference = parseInt(characters, bases[type])\n\n        // Trigger a warning when the parsed number is prohibited, and replace\n        // with replacement character.\n        if (prohibited(reference)) {\n          warning(numericProhibited, diff)\n          reference = fromCharCode(replacementCharacter)\n        } else if (reference in invalid) {\n          // Trigger a warning when the parsed number is disallowed, and replace\n          // by an alternative.\n          warning(numericDisallowed, diff)\n          reference = invalid[reference]\n        } else {\n          // Parse the number.\n          output = ''\n\n          // Trigger a warning when the parsed number should not be used.\n          if (disallowed(reference)) {\n            warning(numericDisallowed, diff)\n          }\n\n          // Stringify the number.\n          if (reference > 0xffff) {\n            reference -= 0x10000\n            output += fromCharCode((reference >>> (10 & 0x3ff)) | 0xd800)\n            reference = 0xdc00 | (reference & 0x3ff)\n          }\n\n          reference = output + fromCharCode(reference)\n        }\n      }\n\n      // Found it!\n      // First eat the queued characters as normal text, then eat an entity.\n      if (reference) {\n        flush()\n\n        prev = now()\n        index = end - 1\n        column += end - start + 1\n        result.push(reference)\n        next = now()\n        next.offset++\n\n        if (handleReference) {\n          handleReference.call(\n            referenceContext,\n            reference,\n            {start: prev, end: next},\n            value.slice(start - 1, end)\n          )\n        }\n\n        prev = next\n      } else {\n        // If we could not find a reference, queue the checked characters (as\n        // normal characters), and move the pointer to their end.\n        // This is possible because we can be certain neither newlines nor\n        // ampersands are included.\n        characters = value.slice(start - 1, end)\n        queue += characters\n        column += characters.length\n        index = end - 1\n      }\n    } else {\n      // Handle anything other than an ampersand, including newlines and EOF.\n      if (\n        character === 10 // Line feed\n      ) {\n        line++\n        lines++\n        column = 0\n      }\n\n      if (character === character) {\n        queue += fromCharCode(character)\n        column++\n      } else {\n        flush()\n      }\n    }\n  }\n\n  // Return the reduced nodes, and any possible warnings.\n  return result.join('')\n\n  // Get current position.\n  function now() {\n    return {\n      line: line,\n      column: column,\n      offset: index + (pos.offset || 0)\n    }\n  }\n\n  // “Throw” a parse-error: a warning.\n  function parseError(code, offset) {\n    var position = now()\n\n    position.column += offset\n    position.offset += offset\n\n    handleWarning.call(warningContext, messages[code], position, code)\n  }\n\n  // Flush `queue` (normal text).\n  // Macro invoked before each entity and at the end of `value`.\n  // Does nothing when `queue` is empty.\n  function flush() {\n    if (queue) {\n      result.push(queue)\n\n      if (handleText) {\n        handleText.call(textContext, queue, {start: prev, end: now()})\n      }\n\n      queue = ''\n    }\n  }\n}\n\n// Check if `character` is outside the permissible unicode range.\nfunction prohibited(code) {\n  return (code >= 0xd800 && code <= 0xdfff) || code > 0x10ffff\n}\n\n// Check if `character` is disallowed.\nfunction disallowed(code) {\n  return (\n    (code >= 0x0001 && code <= 0x0008) ||\n    code === 0x000b ||\n    (code >= 0x000d && code <= 0x001f) ||\n    (code >= 0x007f && code <= 0x009f) ||\n    (code >= 0xfdd0 && code <= 0xfdef) ||\n    (code & 0xffff) === 0xffff ||\n    (code & 0xffff) === 0xfffe\n  )\n}\n","// 'path' module extracted from Node.js v8.11.1 (only the posix part)\n// transplited with Babel\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n\n// Resolves . and .. elements in a path with directory names\nfunction normalizeStringPosix(path, allowAboveRoot) {\n  var res = '';\n  var lastSegmentLength = 0;\n  var lastSlash = -1;\n  var dots = 0;\n  var code;\n  for (var i = 0; i <= path.length; ++i) {\n    if (i < path.length)\n      code = path.charCodeAt(i);\n    else if (code === 47 /*/*/)\n      break;\n    else\n      code = 47 /*/*/;\n    if (code === 47 /*/*/) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {\n          if (res.length > 2) {\n            var lastSlashIndex = res.lastIndexOf('/');\n            if (lastSlashIndex !== res.length - 1) {\n              if (lastSlashIndex === -1) {\n                res = '';\n                lastSegmentLength = 0;\n              } else {\n                res = res.slice(0, lastSlashIndex);\n                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');\n              }\n              lastSlash = i;\n              dots = 0;\n              continue;\n            }\n          } else if (res.length === 2 || res.length === 1) {\n            res = '';\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0)\n            res += '/..';\n          else\n            res = '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0)\n          res += '/' + path.slice(lastSlash + 1, i);\n        else\n          res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === 46 /*.*/ && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nfunction _format(sep, pathObject) {\n  var dir = pathObject.dir || pathObject.root;\n  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');\n  if (!dir) {\n    return base;\n  }\n  if (dir === pathObject.root) {\n    return dir + base;\n  }\n  return dir + sep + base;\n}\n\nvar posix = {\n  // path.resolve([from ...], to)\n  resolve: function resolve() {\n    var resolvedPath = '';\n    var resolvedAbsolute = false;\n    var cwd;\n\n    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n      var path;\n      if (i >= 0)\n        path = arguments[i];\n      else {\n        if (cwd === undefined)\n          cwd = process.cwd();\n        path = cwd;\n      }\n\n      assertPath(path);\n\n      // Skip empty entries\n      if (path.length === 0) {\n        continue;\n      }\n\n      resolvedPath = path + '/' + resolvedPath;\n      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    }\n\n    // At this point the path should be resolved to a full absolute path, but\n    // handle relative paths to be safe (might happen when process.cwd() fails)\n\n    // Normalize the path\n    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);\n\n    if (resolvedAbsolute) {\n      if (resolvedPath.length > 0)\n        return '/' + resolvedPath;\n      else\n        return '/';\n    } else if (resolvedPath.length > 0) {\n      return resolvedPath;\n    } else {\n      return '.';\n    }\n  },\n\n  normalize: function normalize(path) {\n    assertPath(path);\n\n    if (path.length === 0) return '.';\n\n    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;\n    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;\n\n    // Normalize the path\n    path = normalizeStringPosix(path, !isAbsolute);\n\n    if (path.length === 0 && !isAbsolute) path = '.';\n    if (path.length > 0 && trailingSeparator) path += '/';\n\n    if (isAbsolute) return '/' + path;\n    return path;\n  },\n\n  isAbsolute: function isAbsolute(path) {\n    assertPath(path);\n    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;\n  },\n\n  join: function join() {\n    if (arguments.length === 0)\n      return '.';\n    var joined;\n    for (var i = 0; i < arguments.length; ++i) {\n      var arg = arguments[i];\n      assertPath(arg);\n      if (arg.length > 0) {\n        if (joined === undefined)\n          joined = arg;\n        else\n          joined += '/' + arg;\n      }\n    }\n    if (joined === undefined)\n      return '.';\n    return posix.normalize(joined);\n  },\n\n  relative: function relative(from, to) {\n    assertPath(from);\n    assertPath(to);\n\n    if (from === to) return '';\n\n    from = posix.resolve(from);\n    to = posix.resolve(to);\n\n    if (from === to) return '';\n\n    // Trim any leading backslashes\n    var fromStart = 1;\n    for (; fromStart < from.length; ++fromStart) {\n      if (from.charCodeAt(fromStart) !== 47 /*/*/)\n        break;\n    }\n    var fromEnd = from.length;\n    var fromLen = fromEnd - fromStart;\n\n    // Trim any leading backslashes\n    var toStart = 1;\n    for (; toStart < to.length; ++toStart) {\n      if (to.charCodeAt(toStart) !== 47 /*/*/)\n        break;\n    }\n    var toEnd = to.length;\n    var toLen = toEnd - toStart;\n\n    // Compare paths to find the longest common path from root\n    var length = fromLen < toLen ? fromLen : toLen;\n    var lastCommonSep = -1;\n    var i = 0;\n    for (; i <= length; ++i) {\n      if (i === length) {\n        if (toLen > length) {\n          if (to.charCodeAt(toStart + i) === 47 /*/*/) {\n            // We get here if `from` is the exact base path for `to`.\n            // For example: from='/foo/bar'; to='/foo/bar/baz'\n            return to.slice(toStart + i + 1);\n          } else if (i === 0) {\n            // We get here if `from` is the root\n            // For example: from='/'; to='/foo'\n            return to.slice(toStart + i);\n          }\n        } else if (fromLen > length) {\n          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {\n            // We get here if `to` is the exact base path for `from`.\n            // For example: from='/foo/bar/baz'; to='/foo/bar'\n            lastCommonSep = i;\n          } else if (i === 0) {\n            // We get here if `to` is the root.\n            // For example: from='/foo'; to='/'\n            lastCommonSep = 0;\n          }\n        }\n        break;\n      }\n      var fromCode = from.charCodeAt(fromStart + i);\n      var toCode = to.charCodeAt(toStart + i);\n      if (fromCode !== toCode)\n        break;\n      else if (fromCode === 47 /*/*/)\n        lastCommonSep = i;\n    }\n\n    var out = '';\n    // Generate the relative path based on the path difference between `to`\n    // and `from`\n    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {\n        if (out.length === 0)\n          out += '..';\n        else\n          out += '/..';\n      }\n    }\n\n    // Lastly, append the rest of the destination (`to`) path that comes after\n    // the common path parts\n    if (out.length > 0)\n      return out + to.slice(toStart + lastCommonSep);\n    else {\n      toStart += lastCommonSep;\n      if (to.charCodeAt(toStart) === 47 /*/*/)\n        ++toStart;\n      return to.slice(toStart);\n    }\n  },\n\n  _makeLong: function _makeLong(path) {\n    return path;\n  },\n\n  dirname: function dirname(path) {\n    assertPath(path);\n    if (path.length === 0) return '.';\n    var code = path.charCodeAt(0);\n    var hasRoot = code === 47 /*/*/;\n    var end = -1;\n    var matchedSlash = true;\n    for (var i = path.length - 1; i >= 1; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          if (!matchedSlash) {\n            end = i;\n            break;\n          }\n        } else {\n        // We saw the first non-path separator\n        matchedSlash = false;\n      }\n    }\n\n    if (end === -1) return hasRoot ? '/' : '.';\n    if (hasRoot && end === 1) return '//';\n    return path.slice(0, end);\n  },\n\n  basename: function basename(path, ext) {\n    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('\"ext\" argument must be a string');\n    assertPath(path);\n\n    var start = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i;\n\n    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n      if (ext.length === path.length && ext === path) return '';\n      var extIdx = ext.length - 1;\n      var firstNonSlashEnd = -1;\n      for (i = path.length - 1; i >= 0; --i) {\n        var code = path.charCodeAt(i);\n        if (code === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else {\n          if (firstNonSlashEnd === -1) {\n            // We saw the first non-path separator, remember this index in case\n            // we need it if the extension ends up not matching\n            matchedSlash = false;\n            firstNonSlashEnd = i + 1;\n          }\n          if (extIdx >= 0) {\n            // Try to match the explicit extension\n            if (code === ext.charCodeAt(extIdx)) {\n              if (--extIdx === -1) {\n                // We matched the extension, so mark this as the end of our path\n                // component\n                end = i;\n              }\n            } else {\n              // Extension does not match, so our result is the entire path\n              // component\n              extIdx = -1;\n              end = firstNonSlashEnd;\n            }\n          }\n        }\n      }\n\n      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;\n      return path.slice(start, end);\n    } else {\n      for (i = path.length - 1; i >= 0; --i) {\n        if (path.charCodeAt(i) === 47 /*/*/) {\n            // If we reached a path separator that was not part of a set of path\n            // separators at the end of the string, stop now\n            if (!matchedSlash) {\n              start = i + 1;\n              break;\n            }\n          } else if (end === -1) {\n          // We saw the first non-path separator, mark this as the end of our\n          // path component\n          matchedSlash = false;\n          end = i + 1;\n        }\n      }\n\n      if (end === -1) return '';\n      return path.slice(start, end);\n    }\n  },\n\n  extname: function extname(path) {\n    assertPath(path);\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n    for (var i = path.length - 1; i >= 0; --i) {\n      var code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1)\n            startDot = i;\n          else if (preDotState !== 1)\n            preDotState = 1;\n      } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n        // We saw a non-dot character immediately before the dot\n        preDotState === 0 ||\n        // The (right-most) trimmed path component is exactly '..'\n        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      return '';\n    }\n    return path.slice(startDot, end);\n  },\n\n  format: function format(pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n      throw new TypeError('The \"pathObject\" argument must be of type Object. Received type ' + typeof pathObject);\n    }\n    return _format('/', pathObject);\n  },\n\n  parse: function parse(path) {\n    assertPath(path);\n\n    var ret = { root: '', dir: '', base: '', ext: '', name: '' };\n    if (path.length === 0) return ret;\n    var code = path.charCodeAt(0);\n    var isAbsolute = code === 47 /*/*/;\n    var start;\n    if (isAbsolute) {\n      ret.root = '/';\n      start = 1;\n    } else {\n      start = 0;\n    }\n    var startDot = -1;\n    var startPart = 0;\n    var end = -1;\n    var matchedSlash = true;\n    var i = path.length - 1;\n\n    // Track the state of characters (if any) we see before our first dot and\n    // after any path separator we find\n    var preDotState = 0;\n\n    // Get non-dir info\n    for (; i >= start; --i) {\n      code = path.charCodeAt(i);\n      if (code === 47 /*/*/) {\n          // If we reached a path separator that was not part of a set of path\n          // separators at the end of the string, stop now\n          if (!matchedSlash) {\n            startPart = i + 1;\n            break;\n          }\n          continue;\n        }\n      if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // extension\n        matchedSlash = false;\n        end = i + 1;\n      }\n      if (code === 46 /*.*/) {\n          // If this is our first dot, mark it as the start of our extension\n          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;\n        } else if (startDot !== -1) {\n        // We saw a non-dot and non-path separator before our dot, so we should\n        // have a good chance at having a non-empty extension\n        preDotState = -1;\n      }\n    }\n\n    if (startDot === -1 || end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n      if (end !== -1) {\n        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);\n      }\n    } else {\n      if (startPart === 0 && isAbsolute) {\n        ret.name = path.slice(1, startDot);\n        ret.base = path.slice(1, end);\n      } else {\n        ret.name = path.slice(startPart, startDot);\n        ret.base = path.slice(startPart, end);\n      }\n      ret.ext = path.slice(startDot, end);\n    }\n\n    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';\n\n    return ret;\n  },\n\n  sep: '/',\n  delimiter: ':',\n  win32: null,\n  posix: null\n};\n\nposix.posix = posix;\n\nmodule.exports = posix;\n","'use strict';\n\nvar unherit = require('unherit');\nvar xtend = require('xtend');\nvar Parser = require('./lib/parser.js');\n\nmodule.exports = parse;\nparse.Parser = Parser;\n\nfunction parse(options) {\n  var Local = unherit(Parser);\n  Local.prototype.options = xtend(Local.prototype.options, this.data('settings'), options);\n  this.Parser = Local;\n}\n","'use strict';\n\nvar xtend = require('xtend');\nvar entities = require('parse-entities');\n\nmodule.exports = factory;\n\n/* Factory to create an entity decoder. */\nfunction factory(ctx) {\n  decoder.raw = decodeRaw;\n\n  return decoder;\n\n  /* Normalize `position` to add an `indent`. */\n  function normalize(position) {\n    var offsets = ctx.offset;\n    var line = position.line;\n    var result = [];\n\n    while (++line) {\n      if (!(line in offsets)) {\n        break;\n      }\n\n      result.push((offsets[line] || 0) + 1);\n    }\n\n    return {\n      start: position,\n      indent: result\n    };\n  }\n\n  /* Handle a warning.\n   * See https://github.com/wooorm/parse-entities\n   * for the warnings. */\n  function handleWarning(reason, position, code) {\n    if (code === 3) {\n      return;\n    }\n\n    ctx.file.message(reason, position);\n  }\n\n  /* Decode `value` (at `position`) into text-nodes. */\n  function decoder(value, position, handler) {\n    entities(value, {\n      position: normalize(position),\n      warning: handleWarning,\n      text: handler,\n      reference: handler,\n      textContext: ctx,\n      referenceContext: ctx\n    });\n  }\n\n  /* Decode `value` (at `position`) into a string. */\n  function decodeRaw(value, position, options) {\n    return entities(value, xtend(options, {\n      position: normalize(position),\n      warning: handleWarning\n    }));\n  }\n}\n","'use strict';\n\nmodule.exports = {\n  position: true,\n  gfm: true,\n  commonmark: false,\n  footnotes: false,\n  pedantic: false,\n  blocks: require('./block-elements.json')\n};\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var index = value.indexOf('\\n', fromIndex);\n\n  while (index > fromIndex) {\n    if (value.charAt(index - 1) !== ' ') {\n      break;\n    }\n\n    index--;\n  }\n\n  return index;\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('`', fromIndex);\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('~~', fromIndex);\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var asterisk = value.indexOf('*', fromIndex);\n  var underscore = value.indexOf('_', fromIndex);\n\n  if (underscore === -1) {\n    return asterisk;\n  }\n\n  if (asterisk === -1) {\n    return underscore;\n  }\n\n  return underscore < asterisk ? underscore : asterisk;\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('\\\\', fromIndex);\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var link = value.indexOf('[', fromIndex);\n  var image = value.indexOf('![', fromIndex);\n\n  if (image === -1) {\n    return link;\n  }\n\n  /* Link can never be `-1` if an image is found, so we don’t need\n   * to check for that :) */\n  return link < image ? link : image;\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  var asterisk = value.indexOf('**', fromIndex);\n  var underscore = value.indexOf('__', fromIndex);\n\n  if (underscore === -1) {\n    return asterisk;\n  }\n\n  if (asterisk === -1) {\n    return underscore;\n  }\n\n  return underscore < asterisk ? underscore : asterisk;\n}\n","'use strict';\n\nmodule.exports = locate;\n\nfunction locate(value, fromIndex) {\n  return value.indexOf('<', fromIndex);\n}\n","'use strict';\n\nmodule.exports = locate;\n\nvar PROTOCOLS = ['https://', 'http://', 'mailto:'];\n\nfunction locate(value, fromIndex) {\n  var length = PROTOCOLS.length;\n  var index = -1;\n  var min = -1;\n  var position;\n\n  if (!this.options.gfm) {\n    return -1;\n  }\n\n  while (++index < length) {\n    position = value.indexOf(PROTOCOLS[index], fromIndex);\n\n    if (position !== -1 && (position < min || min === -1)) {\n      min = position;\n    }\n  }\n\n  return min;\n}\n","'use strict';\n\nvar xtend = require('xtend');\nvar removePosition = require('unist-util-remove-position');\n\nmodule.exports = parse;\n\nvar C_NEWLINE = '\\n';\nvar EXPRESSION_LINE_BREAKS = /\\r\\n|\\r/g;\n\n/* Parse the bound file. */\nfunction parse() {\n  var self = this;\n  var value = String(self.file);\n  var start = {line: 1, column: 1, offset: 0};\n  var content = xtend(start);\n  var node;\n\n  /* Clean non-unix newlines: `\\r\\n` and `\\r` are all\n   * changed to `\\n`.  This should not affect positional\n   * information. */\n  value = value.replace(EXPRESSION_LINE_BREAKS, C_NEWLINE);\n\n  if (value.charCodeAt(0) === 0xFEFF) {\n    value = value.slice(1);\n\n    content.column++;\n    content.offset++;\n  }\n\n  node = {\n    type: 'root',\n    children: self.tokenizeBlock(value, content),\n    position: {\n      start: start,\n      end: self.eof || xtend(start)\n    }\n  };\n\n  if (!self.options.position) {\n    removePosition(node, true);\n  }\n\n  return node;\n}\n","'use strict';\n\nvar xtend = require('xtend');\nvar toggle = require('state-toggle');\nvar vfileLocation = require('vfile-location');\nvar unescape = require('./unescape');\nvar decode = require('./decode');\nvar tokenizer = require('./tokenizer');\n\nmodule.exports = Parser;\n\nfunction Parser(doc, file) {\n  this.file = file;\n  this.offset = {};\n  this.options = xtend(this.options);\n  this.setOptions({});\n\n  this.inList = false;\n  this.inBlock = false;\n  this.inLink = false;\n  this.atStart = true;\n\n  this.toOffset = vfileLocation(file).toOffset;\n  this.unescape = unescape(this, 'escape');\n  this.decode = decode(this);\n}\n\nvar proto = Parser.prototype;\n\n/* Expose core. */\nproto.setOptions = require('./set-options');\nproto.parse = require('./parse');\n\n/* Expose `defaults`. */\nproto.options = require('./defaults');\n\n/* Enter and exit helpers. */\nproto.exitStart = toggle('atStart', true);\nproto.enterList = toggle('inList', false);\nproto.enterLink = toggle('inLink', false);\nproto.enterBlock = toggle('inBlock', false);\n\n/* Nodes that can interupt a paragraph:\n *\n * ```markdown\n * A paragraph, followed by a thematic break.\n * ___\n * ```\n *\n * In the above example, the thematic break “interupts”\n * the paragraph. */\nproto.interruptParagraph = [\n  ['thematicBreak'],\n  ['atxHeading'],\n  ['fencedCode'],\n  ['blockquote'],\n  ['html'],\n  ['setextHeading', {commonmark: false}],\n  ['definition', {commonmark: false}],\n  ['footnote', {commonmark: false}]\n];\n\n/* Nodes that can interupt a list:\n *\n * ```markdown\n * - One\n * ___\n * ```\n *\n * In the above example, the thematic break “interupts”\n * the list. */\nproto.interruptList = [\n  ['atxHeading', {pedantic: false}],\n  ['fencedCode', {pedantic: false}],\n  ['thematicBreak', {pedantic: false}],\n  ['definition', {commonmark: false}],\n  ['footnote', {commonmark: false}]\n];\n\n/* Nodes that can interupt a blockquote:\n *\n * ```markdown\n * > A paragraph.\n * ___\n * ```\n *\n * In the above example, the thematic break “interupts”\n * the blockquote. */\nproto.interruptBlockquote = [\n  ['indentedCode', {commonmark: true}],\n  ['fencedCode', {commonmark: true}],\n  ['atxHeading', {commonmark: true}],\n  ['setextHeading', {commonmark: true}],\n  ['thematicBreak', {commonmark: true}],\n  ['html', {commonmark: true}],\n  ['list', {commonmark: true}],\n  ['definition', {commonmark: false}],\n  ['footnote', {commonmark: false}]\n];\n\n/* Handlers. */\nproto.blockTokenizers = {\n  newline: require('./tokenize/newline'),\n  indentedCode: require('./tokenize/code-indented'),\n  fencedCode: require('./tokenize/code-fenced'),\n  blockquote: require('./tokenize/blockquote'),\n  atxHeading: require('./tokenize/heading-atx'),\n  thematicBreak: require('./tokenize/thematic-break'),\n  list: require('./tokenize/list'),\n  setextHeading: require('./tokenize/heading-setext'),\n  html: require('./tokenize/html-block'),\n  footnote: require('./tokenize/footnote-definition'),\n  definition: require('./tokenize/definition'),\n  table: require('./tokenize/table'),\n  paragraph: require('./tokenize/paragraph')\n};\n\nproto.inlineTokenizers = {\n  escape: require('./tokenize/escape'),\n  autoLink: require('./tokenize/auto-link'),\n  url: require('./tokenize/url'),\n  html: require('./tokenize/html-inline'),\n  link: require('./tokenize/link'),\n  reference: require('./tokenize/reference'),\n  strong: require('./tokenize/strong'),\n  emphasis: require('./tokenize/emphasis'),\n  deletion: require('./tokenize/delete'),\n  code: require('./tokenize/code-inline'),\n  break: require('./tokenize/break'),\n  text: require('./tokenize/text')\n};\n\n/* Expose precedence. */\nproto.blockMethods = keys(proto.blockTokenizers);\nproto.inlineMethods = keys(proto.inlineTokenizers);\n\n/* Tokenizers. */\nproto.tokenizeBlock = tokenizer('block');\nproto.tokenizeInline = tokenizer('inline');\nproto.tokenizeFactory = tokenizer;\n\n/* Get all keys in `value`. */\nfunction keys(value) {\n  var result = [];\n  var key;\n\n  for (key in value) {\n    result.push(key);\n  }\n\n  return result;\n}\n","'use strict';\n\nvar xtend = require('xtend');\nvar escapes = require('markdown-escapes');\nvar defaults = require('./defaults');\n\nmodule.exports = setOptions;\n\nfunction setOptions(options) {\n  var self = this;\n  var current = self.options;\n  var key;\n  var value;\n\n  if (options == null) {\n    options = {};\n  } else if (typeof options === 'object') {\n    options = xtend(options);\n  } else {\n    throw new Error(\n      'Invalid value `' + options + '` ' +\n      'for setting `options`'\n    );\n  }\n\n  for (key in defaults) {\n    value = options[key];\n\n    if (value == null) {\n      value = current[key];\n    }\n\n    if (\n      (key !== 'blocks' && typeof value !== 'boolean') ||\n      (key === 'blocks' && typeof value !== 'object')\n    ) {\n      throw new Error('Invalid value `' + value + '` for setting `options.' + key + '`');\n    }\n\n    options[key] = value;\n  }\n\n  self.options = options;\n  self.escape = escapes(options);\n\n  return self;\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar decode = require('parse-entities');\nvar locate = require('../locate/tag');\n\nmodule.exports = autoLink;\nautoLink.locator = locate;\nautoLink.notInLink = true;\n\nvar C_LT = '<';\nvar C_GT = '>';\nvar C_AT_SIGN = '@';\nvar C_SLASH = '/';\nvar MAILTO = 'mailto:';\nvar MAILTO_LENGTH = MAILTO.length;\n\n/* Tokenise a link. */\nfunction autoLink(eat, value, silent) {\n  var self;\n  var subvalue;\n  var length;\n  var index;\n  var queue;\n  var character;\n  var hasAtCharacter;\n  var link;\n  var now;\n  var content;\n  var tokenizers;\n  var exit;\n\n  if (value.charAt(0) !== C_LT) {\n    return;\n  }\n\n  self = this;\n  subvalue = '';\n  length = value.length;\n  index = 0;\n  queue = '';\n  hasAtCharacter = false;\n  link = '';\n\n  index++;\n  subvalue = C_LT;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (\n      whitespace(character) ||\n      character === C_GT ||\n      character === C_AT_SIGN ||\n      (character === ':' && value.charAt(index + 1) === C_SLASH)\n    ) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  link += queue;\n  queue = '';\n\n  character = value.charAt(index);\n  link += character;\n  index++;\n\n  if (character === C_AT_SIGN) {\n    hasAtCharacter = true;\n  } else {\n    if (\n      character !== ':' ||\n      value.charAt(index + 1) !== C_SLASH\n    ) {\n      return;\n    }\n\n    link += C_SLASH;\n    index++;\n  }\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (whitespace(character) || character === C_GT) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (!queue || character !== C_GT) {\n    return;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  link += queue;\n  content = link;\n  subvalue += link + character;\n  now = eat.now();\n  now.column++;\n  now.offset++;\n\n  if (hasAtCharacter) {\n    if (link.slice(0, MAILTO_LENGTH).toLowerCase() === MAILTO) {\n      content = content.substr(MAILTO_LENGTH);\n      now.column += MAILTO_LENGTH;\n      now.offset += MAILTO_LENGTH;\n    } else {\n      link = MAILTO + link;\n    }\n  }\n\n  /* Temporarily remove all tokenizers except text in autolinks. */\n  tokenizers = self.inlineTokenizers;\n  self.inlineTokenizers = {text: tokenizers.text};\n\n  exit = self.enterLink();\n\n  content = self.tokenizeInline(content, now);\n\n  self.inlineTokenizers = tokenizers;\n  exit();\n\n  return eat(subvalue)({\n    type: 'link',\n    title: null,\n    url: decode(link, {nonTerminated: false}),\n    children: content\n  });\n}\n","'use strict';\n\nvar trim = require('trim');\nvar interrupt = require('../util/interrupt');\n\nmodule.exports = blockquote;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_GT = '>';\n\n/* Tokenise a blockquote. */\nfunction blockquote(eat, value, silent) {\n  var self = this;\n  var offsets = self.offset;\n  var tokenizers = self.blockTokenizers;\n  var interruptors = self.interruptBlockquote;\n  var now = eat.now();\n  var currentLine = now.line;\n  var length = value.length;\n  var values = [];\n  var contents = [];\n  var indents = [];\n  var add;\n  var index = 0;\n  var character;\n  var rest;\n  var nextIndex;\n  var content;\n  var line;\n  var startIndex;\n  var prefixed;\n  var exit;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    index++;\n  }\n\n  if (value.charAt(index) !== C_GT) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  index = 0;\n\n  while (index < length) {\n    nextIndex = value.indexOf(C_NEWLINE, index);\n    startIndex = index;\n    prefixed = false;\n\n    if (nextIndex === -1) {\n      nextIndex = length;\n    }\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== C_SPACE && character !== C_TAB) {\n        break;\n      }\n\n      index++;\n    }\n\n    if (value.charAt(index) === C_GT) {\n      index++;\n      prefixed = true;\n\n      if (value.charAt(index) === C_SPACE) {\n        index++;\n      }\n    } else {\n      index = startIndex;\n    }\n\n    content = value.slice(index, nextIndex);\n\n    if (!prefixed && !trim(content)) {\n      index = startIndex;\n      break;\n    }\n\n    if (!prefixed) {\n      rest = value.slice(index);\n\n      /* Check if the following code contains a possible\n       * block. */\n      if (interrupt(interruptors, tokenizers, self, [eat, rest, true])) {\n        break;\n      }\n    }\n\n    line = startIndex === index ? content : value.slice(startIndex, nextIndex);\n\n    indents.push(index - startIndex);\n    values.push(line);\n    contents.push(content);\n\n    index = nextIndex + 1;\n  }\n\n  index = -1;\n  length = indents.length;\n  add = eat(values.join(C_NEWLINE));\n\n  while (++index < length) {\n    offsets[currentLine] = (offsets[currentLine] || 0) + indents[index];\n    currentLine++;\n  }\n\n  exit = self.enterBlock();\n  contents = self.tokenizeBlock(contents.join(C_NEWLINE), now);\n  exit();\n\n  return add({\n    type: 'blockquote',\n    children: contents\n  });\n}\n","'use strict';\n\nvar locate = require('../locate/break');\n\nmodule.exports = hardBreak;\nhardBreak.locator = locate;\n\nvar MIN_BREAK_LENGTH = 2;\n\nfunction hardBreak(eat, value, silent) {\n  var length = value.length;\n  var index = -1;\n  var queue = '';\n  var character;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character === '\\n') {\n      if (index < MIN_BREAK_LENGTH) {\n        return;\n      }\n\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n\n      queue += character;\n\n      return eat(queue)({type: 'break'});\n    }\n\n    if (character !== ' ') {\n      return;\n    }\n\n    queue += character;\n  }\n}\n","'use strict';\n\nvar trim = require('trim-trailing-lines');\n\nmodule.exports = fencedCode;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_TILDE = '~';\nvar C_TICK = '`';\n\nvar MIN_FENCE_COUNT = 3;\nvar CODE_INDENT_COUNT = 4;\n\nfunction fencedCode(eat, value, silent) {\n  var self = this;\n  var settings = self.options;\n  var length = value.length + 1;\n  var index = 0;\n  var subvalue = '';\n  var fenceCount;\n  var marker;\n  var character;\n  var flag;\n  var queue;\n  var content;\n  var exdentedContent;\n  var closing;\n  var exdentedClosing;\n  var indent;\n  var now;\n\n  if (!settings.gfm) {\n    return;\n  }\n\n  /* Eat initial spacing. */\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  indent = index;\n\n  /* Eat the fence. */\n  character = value.charAt(index);\n\n  if (character !== C_TILDE && character !== C_TICK) {\n    return;\n  }\n\n  index++;\n  marker = character;\n  fenceCount = 1;\n  subvalue += character;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== marker) {\n      break;\n    }\n\n    subvalue += character;\n    fenceCount++;\n    index++;\n  }\n\n  if (fenceCount < MIN_FENCE_COUNT) {\n    return;\n  }\n\n  /* Eat spacing before flag. */\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  /* Eat flag. */\n  flag = '';\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (\n      character === C_NEWLINE ||\n      character === C_TILDE ||\n      character === C_TICK\n    ) {\n      break;\n    }\n\n    if (character === C_SPACE || character === C_TAB) {\n      queue += character;\n    } else {\n      flag += queue + character;\n      queue = '';\n    }\n\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (character && character !== C_NEWLINE) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  now = eat.now();\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n\n  subvalue += flag;\n  flag = self.decode.raw(self.unescape(flag), now);\n\n  if (queue) {\n    subvalue += queue;\n  }\n\n  queue = '';\n  closing = '';\n  exdentedClosing = '';\n  content = '';\n  exdentedContent = '';\n\n  /* Eat content. */\n  while (index < length) {\n    character = value.charAt(index);\n    content += closing;\n    exdentedContent += exdentedClosing;\n    closing = '';\n    exdentedClosing = '';\n\n    if (character !== C_NEWLINE) {\n      content += character;\n      exdentedClosing += character;\n      index++;\n      continue;\n    }\n\n    /* Add the newline to `subvalue` if its the first\n     * character.  Otherwise, add it to the `closing`\n     * queue. */\n    if (content) {\n      closing += character;\n      exdentedClosing += character;\n    } else {\n      subvalue += character;\n    }\n\n    queue = '';\n    index++;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== C_SPACE) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    closing += queue;\n    exdentedClosing += queue.slice(indent);\n\n    if (queue.length >= CODE_INDENT_COUNT) {\n      continue;\n    }\n\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== marker) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    closing += queue;\n    exdentedClosing += queue;\n\n    if (queue.length < fenceCount) {\n      continue;\n    }\n\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character !== C_SPACE && character !== C_TAB) {\n        break;\n      }\n\n      closing += character;\n      exdentedClosing += character;\n      index++;\n    }\n\n    if (!character || character === C_NEWLINE) {\n      break;\n    }\n  }\n\n  subvalue += content + closing;\n\n  return eat(subvalue)({\n    type: 'code',\n    lang: flag || null,\n    value: trim(exdentedContent)\n  });\n}\n","'use strict';\n\nvar repeat = require('repeat-string');\nvar trim = require('trim-trailing-lines');\n\nmodule.exports = indentedCode;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\n\nvar CODE_INDENT_COUNT = 4;\nvar CODE_INDENT = repeat(C_SPACE, CODE_INDENT_COUNT);\n\n/* Tokenise indented code. */\nfunction indentedCode(eat, value, silent) {\n  var index = -1;\n  var length = value.length;\n  var subvalue = '';\n  var content = '';\n  var subvalueQueue = '';\n  var contentQueue = '';\n  var character;\n  var blankQueue;\n  var indent;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (indent) {\n      indent = false;\n\n      subvalue += subvalueQueue;\n      content += contentQueue;\n      subvalueQueue = '';\n      contentQueue = '';\n\n      if (character === C_NEWLINE) {\n        subvalueQueue = character;\n        contentQueue = character;\n      } else {\n        subvalue += character;\n        content += character;\n\n        while (++index < length) {\n          character = value.charAt(index);\n\n          if (!character || character === C_NEWLINE) {\n            contentQueue = character;\n            subvalueQueue = character;\n            break;\n          }\n\n          subvalue += character;\n          content += character;\n        }\n      }\n    } else if (\n      character === C_SPACE &&\n      value.charAt(index + 1) === character &&\n      value.charAt(index + 2) === character &&\n      value.charAt(index + 3) === character\n    ) {\n      subvalueQueue += CODE_INDENT;\n      index += 3;\n      indent = true;\n    } else if (character === C_TAB) {\n      subvalueQueue += character;\n      indent = true;\n    } else {\n      blankQueue = '';\n\n      while (character === C_TAB || character === C_SPACE) {\n        blankQueue += character;\n        character = value.charAt(++index);\n      }\n\n      if (character !== C_NEWLINE) {\n        break;\n      }\n\n      subvalueQueue += blankQueue + character;\n      contentQueue += character;\n    }\n  }\n\n  if (content) {\n    if (silent) {\n      return true;\n    }\n\n    return eat(subvalue)({\n      type: 'code',\n      lang: null,\n      value: trim(content)\n    });\n  }\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/code-inline');\n\nmodule.exports = inlineCode;\ninlineCode.locator = locate;\n\nvar C_TICK = '`';\n\n/* Tokenise inline code. */\nfunction inlineCode(eat, value, silent) {\n  var length = value.length;\n  var index = 0;\n  var queue = '';\n  var tickQueue = '';\n  var contentQueue;\n  var subqueue;\n  var count;\n  var openingCount;\n  var subvalue;\n  var character;\n  var found;\n  var next;\n\n  while (index < length) {\n    if (value.charAt(index) !== C_TICK) {\n      break;\n    }\n\n    queue += C_TICK;\n    index++;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  subvalue = queue;\n  openingCount = index;\n  queue = '';\n  next = value.charAt(index);\n  count = 0;\n\n  while (index < length) {\n    character = next;\n    next = value.charAt(index + 1);\n\n    if (character === C_TICK) {\n      count++;\n      tickQueue += character;\n    } else {\n      count = 0;\n      queue += character;\n    }\n\n    if (count && next !== C_TICK) {\n      if (count === openingCount) {\n        subvalue += queue + tickQueue;\n        found = true;\n        break;\n      }\n\n      queue += tickQueue;\n      tickQueue = '';\n    }\n\n    index++;\n  }\n\n  if (!found) {\n    if (openingCount % 2 !== 0) {\n      return;\n    }\n\n    queue = '';\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  contentQueue = '';\n  subqueue = '';\n  length = queue.length;\n  index = -1;\n\n  while (++index < length) {\n    character = queue.charAt(index);\n\n    if (whitespace(character)) {\n      subqueue += character;\n      continue;\n    }\n\n    if (subqueue) {\n      if (contentQueue) {\n        contentQueue += subqueue;\n      }\n\n      subqueue = '';\n    }\n\n    contentQueue += character;\n  }\n\n  return eat(subvalue)({\n    type: 'inlineCode',\n    value: contentQueue\n  });\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar normalize = require('../util/normalize');\n\nmodule.exports = definition;\ndefinition.notInList = true;\ndefinition.notInBlock = true;\n\nvar C_DOUBLE_QUOTE = '\"';\nvar C_SINGLE_QUOTE = '\\'';\nvar C_BACKSLASH = '\\\\';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_COLON = ':';\nvar C_LT = '<';\nvar C_GT = '>';\n\nfunction definition(eat, value, silent) {\n  var self = this;\n  var commonmark = self.options.commonmark;\n  var index = 0;\n  var length = value.length;\n  var subvalue = '';\n  var beforeURL;\n  var beforeTitle;\n  var queue;\n  var character;\n  var test;\n  var identifier;\n  var url;\n  var title;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n\n  index++;\n  subvalue += character;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_BRACKET_CLOSE) {\n      break;\n    } else if (character === C_BACKSLASH) {\n      queue += character;\n      index++;\n      character = value.charAt(index);\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (\n    !queue ||\n    value.charAt(index) !== C_BRACKET_CLOSE ||\n    value.charAt(index + 1) !== C_COLON\n  ) {\n    return;\n  }\n\n  identifier = queue;\n  subvalue += queue + C_BRACKET_CLOSE + C_COLON;\n  index = subvalue.length;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (\n      character !== C_TAB &&\n      character !== C_SPACE &&\n      character !== C_NEWLINE\n    ) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n  queue = '';\n  beforeURL = subvalue;\n\n  if (character === C_LT) {\n    index++;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (!isEnclosedURLCharacter(character)) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (character === isEnclosedURLCharacter.delimiter) {\n      subvalue += C_LT + queue + character;\n      index++;\n    } else {\n      if (commonmark) {\n        return;\n      }\n\n      index -= queue.length + 1;\n      queue = '';\n    }\n  }\n\n  if (!queue) {\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (!isUnclosedURLCharacter(character)) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    subvalue += queue;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  url = queue;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (\n      character !== C_TAB &&\n      character !== C_SPACE &&\n      character !== C_NEWLINE\n    ) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n  test = null;\n\n  if (character === C_DOUBLE_QUOTE) {\n    test = C_DOUBLE_QUOTE;\n  } else if (character === C_SINGLE_QUOTE) {\n    test = C_SINGLE_QUOTE;\n  } else if (character === C_PAREN_OPEN) {\n    test = C_PAREN_CLOSE;\n  }\n\n  if (!test) {\n    queue = '';\n    index = subvalue.length;\n  } else if (queue) {\n    subvalue += queue + character;\n    index = subvalue.length;\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === test) {\n        break;\n      }\n\n      if (character === C_NEWLINE) {\n        index++;\n        character = value.charAt(index);\n\n        if (character === C_NEWLINE || character === test) {\n          return;\n        }\n\n        queue += C_NEWLINE;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (character !== test) {\n      return;\n    }\n\n    beforeTitle = subvalue;\n    subvalue += queue + character;\n    index++;\n    title = queue;\n    queue = '';\n  } else {\n    return;\n  }\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  if (!character || character === C_NEWLINE) {\n    if (silent) {\n      return true;\n    }\n\n    beforeURL = eat(beforeURL).test().end;\n    url = self.decode.raw(self.unescape(url), beforeURL, {nonTerminated: false});\n\n    if (title) {\n      beforeTitle = eat(beforeTitle).test().end;\n      title = self.decode.raw(self.unescape(title), beforeTitle);\n    }\n\n    return eat(subvalue)({\n      type: 'definition',\n      identifier: normalize(identifier),\n      title: title || null,\n      url: url\n    });\n  }\n}\n\n/* Check if `character` can be inside an enclosed URI. */\nfunction isEnclosedURLCharacter(character) {\n  return character !== C_GT &&\n    character !== C_BRACKET_OPEN &&\n    character !== C_BRACKET_CLOSE;\n}\n\nisEnclosedURLCharacter.delimiter = C_GT;\n\n/* Check if `character` can be inside an unclosed URI. */\nfunction isUnclosedURLCharacter(character) {\n  return character !== C_BRACKET_OPEN &&\n    character !== C_BRACKET_CLOSE &&\n    !whitespace(character);\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/delete');\n\nmodule.exports = strikethrough;\nstrikethrough.locator = locate;\n\nvar C_TILDE = '~';\nvar DOUBLE = '~~';\n\nfunction strikethrough(eat, value, silent) {\n  var self = this;\n  var character = '';\n  var previous = '';\n  var preceding = '';\n  var subvalue = '';\n  var index;\n  var length;\n  var now;\n\n  if (\n    !self.options.gfm ||\n    value.charAt(0) !== C_TILDE ||\n    value.charAt(1) !== C_TILDE ||\n    whitespace(value.charAt(2))\n  ) {\n    return;\n  }\n\n  index = 1;\n  length = value.length;\n  now = eat.now();\n  now.column += 2;\n  now.offset += 2;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (\n      character === C_TILDE &&\n      previous === C_TILDE &&\n      (!preceding || !whitespace(preceding))\n    ) {\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n\n      return eat(DOUBLE + subvalue + DOUBLE)({\n        type: 'delete',\n        children: self.tokenizeInline(subvalue, now)\n      });\n    }\n\n    subvalue += previous;\n    preceding = previous;\n    previous = character;\n  }\n}\n","'use strict';\n\nvar trim = require('trim');\nvar word = require('is-word-character');\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/emphasis');\n\nmodule.exports = emphasis;\nemphasis.locator = locate;\n\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\n\nfunction emphasis(eat, value, silent) {\n  var self = this;\n  var index = 0;\n  var character = value.charAt(index);\n  var now;\n  var pedantic;\n  var marker;\n  var queue;\n  var subvalue;\n  var length;\n  var prev;\n\n  if (character !== C_ASTERISK && character !== C_UNDERSCORE) {\n    return;\n  }\n\n  pedantic = self.options.pedantic;\n  subvalue = character;\n  marker = character;\n  length = value.length;\n  index++;\n  queue = '';\n  character = '';\n\n  if (pedantic && whitespace(value.charAt(index))) {\n    return;\n  }\n\n  while (index < length) {\n    prev = character;\n    character = value.charAt(index);\n\n    if (character === marker && (!pedantic || !whitespace(prev))) {\n      character = value.charAt(++index);\n\n      if (character !== marker) {\n        if (!trim(queue) || prev === marker) {\n          return;\n        }\n\n        if (!pedantic && marker === C_UNDERSCORE && word(character)) {\n          queue += marker;\n          continue;\n        }\n\n        /* istanbul ignore if - never used (yet) */\n        if (silent) {\n          return true;\n        }\n\n        now = eat.now();\n        now.column++;\n        now.offset++;\n\n        return eat(subvalue + queue + marker)({\n          type: 'emphasis',\n          children: self.tokenizeInline(queue, now)\n        });\n      }\n\n      queue += marker;\n    }\n\n    if (!pedantic && character === '\\\\') {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    queue += character;\n    index++;\n  }\n}\n","'use strict';\n\nvar locate = require('../locate/escape');\n\nmodule.exports = escape;\nescape.locator = locate;\n\nfunction escape(eat, value, silent) {\n  var self = this;\n  var character;\n  var node;\n\n  if (value.charAt(0) === '\\\\') {\n    character = value.charAt(1);\n\n    if (self.escape.indexOf(character) !== -1) {\n      /* istanbul ignore if - never used (yet) */\n      if (silent) {\n        return true;\n      }\n\n      if (character === '\\n') {\n        node = {type: 'break'};\n      } else {\n        node = {\n          type: 'text',\n          value: character\n        };\n      }\n\n      return eat('\\\\' + character)(node);\n    }\n  }\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar normalize = require('../util/normalize');\n\nmodule.exports = footnoteDefinition;\nfootnoteDefinition.notInList = true;\nfootnoteDefinition.notInBlock = true;\n\nvar C_BACKSLASH = '\\\\';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_CARET = '^';\nvar C_COLON = ':';\n\nvar EXPRESSION_INITIAL_TAB = /^( {4}|\\t)?/gm;\n\nfunction footnoteDefinition(eat, value, silent) {\n  var self = this;\n  var offsets = self.offset;\n  var index;\n  var length;\n  var subvalue;\n  var now;\n  var currentLine;\n  var content;\n  var queue;\n  var subqueue;\n  var character;\n  var identifier;\n  var add;\n  var exit;\n\n  if (!self.options.footnotes) {\n    return;\n  }\n\n  index = 0;\n  length = value.length;\n  subvalue = '';\n  now = eat.now();\n  currentLine = now.line;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  if (\n    value.charAt(index) !== C_BRACKET_OPEN ||\n    value.charAt(index + 1) !== C_CARET\n  ) {\n    return;\n  }\n\n  subvalue += C_BRACKET_OPEN + C_CARET;\n  index = subvalue.length;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_BRACKET_CLOSE) {\n      break;\n    } else if (character === C_BACKSLASH) {\n      queue += character;\n      index++;\n      character = value.charAt(index);\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (\n    !queue ||\n    value.charAt(index) !== C_BRACKET_CLOSE ||\n    value.charAt(index + 1) !== C_COLON\n  ) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  identifier = normalize(queue);\n  subvalue += queue + C_BRACKET_CLOSE + C_COLON;\n  index = subvalue.length;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  queue = '';\n  content = '';\n  subqueue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_NEWLINE) {\n      subqueue = character;\n      index++;\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character !== C_NEWLINE) {\n          break;\n        }\n\n        subqueue += character;\n        index++;\n      }\n\n      queue += subqueue;\n      subqueue = '';\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character !== C_SPACE) {\n          break;\n        }\n\n        subqueue += character;\n        index++;\n      }\n\n      if (subqueue.length === 0) {\n        break;\n      }\n\n      queue += subqueue;\n    }\n\n    if (queue) {\n      content += queue;\n      queue = '';\n    }\n\n    content += character;\n    index++;\n  }\n\n  subvalue += content;\n\n  content = content.replace(EXPRESSION_INITIAL_TAB, function (line) {\n    offsets[currentLine] = (offsets[currentLine] || 0) + line.length;\n    currentLine++;\n\n    return '';\n  });\n\n  add = eat(subvalue);\n\n  exit = self.enterBlock();\n  content = self.tokenizeBlock(content, now);\n  exit();\n\n  return add({\n    type: 'footnoteDefinition',\n    identifier: identifier,\n    children: content\n  });\n}\n","'use strict';\n\nmodule.exports = atxHeading;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_HASH = '#';\n\nvar MAX_ATX_COUNT = 6;\n\nfunction atxHeading(eat, value, silent) {\n  var self = this;\n  var settings = self.options;\n  var length = value.length + 1;\n  var index = -1;\n  var now = eat.now();\n  var subvalue = '';\n  var content = '';\n  var character;\n  var queue;\n  var depth;\n\n  /* Eat initial spacing. */\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      index--;\n      break;\n    }\n\n    subvalue += character;\n  }\n\n  /* Eat hashes. */\n  depth = 0;\n\n  while (++index <= length) {\n    character = value.charAt(index);\n\n    if (character !== C_HASH) {\n      index--;\n      break;\n    }\n\n    subvalue += character;\n    depth++;\n  }\n\n  if (depth > MAX_ATX_COUNT) {\n    return;\n  }\n\n  if (\n    !depth ||\n    (!settings.pedantic && value.charAt(index + 1) === C_HASH)\n  ) {\n    return;\n  }\n\n  length = value.length + 1;\n\n  /* Eat intermediate white-space. */\n  queue = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE && character !== C_TAB) {\n      index--;\n      break;\n    }\n\n    queue += character;\n  }\n\n  /* Exit when not in pedantic mode without spacing. */\n  if (\n    !settings.pedantic &&\n    queue.length === 0 &&\n    character &&\n    character !== C_NEWLINE\n  ) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  /* Eat content. */\n  subvalue += queue;\n  queue = '';\n  content = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (!character || character === C_NEWLINE) {\n      break;\n    }\n\n    if (\n      character !== C_SPACE &&\n      character !== C_TAB &&\n      character !== C_HASH\n    ) {\n      content += queue + character;\n      queue = '';\n      continue;\n    }\n\n    while (character === C_SPACE || character === C_TAB) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    while (character === C_HASH) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    while (character === C_SPACE || character === C_TAB) {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    index--;\n  }\n\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  subvalue += content + queue;\n\n  return eat(subvalue)({\n    type: 'heading',\n    depth: depth,\n    children: self.tokenizeInline(content, now)\n  });\n}\n","'use strict';\n\nmodule.exports = setextHeading;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_EQUALS = '=';\nvar C_DASH = '-';\n\nvar MAX_HEADING_INDENT = 3;\n\n/* Map of characters which can be used to mark setext\n * headers, mapping to their corresponding depth. */\nvar SETEXT_MARKERS = {};\n\nSETEXT_MARKERS[C_EQUALS] = 1;\nSETEXT_MARKERS[C_DASH] = 2;\n\nfunction setextHeading(eat, value, silent) {\n  var self = this;\n  var now = eat.now();\n  var length = value.length;\n  var index = -1;\n  var subvalue = '';\n  var content;\n  var queue;\n  var character;\n  var marker;\n  var depth;\n\n  /* Eat initial indentation. */\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_SPACE || index >= MAX_HEADING_INDENT) {\n      index--;\n      break;\n    }\n\n    subvalue += character;\n  }\n\n  /* Eat content. */\n  content = '';\n  queue = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character === C_NEWLINE) {\n      index--;\n      break;\n    }\n\n    if (character === C_SPACE || character === C_TAB) {\n      queue += character;\n    } else {\n      content += queue + character;\n      queue = '';\n    }\n  }\n\n  now.column += subvalue.length;\n  now.offset += subvalue.length;\n  subvalue += content + queue;\n\n  /* Ensure the content is followed by a newline and a\n   * valid marker. */\n  character = value.charAt(++index);\n  marker = value.charAt(++index);\n\n  if (character !== C_NEWLINE || !SETEXT_MARKERS[marker]) {\n    return;\n  }\n\n  subvalue += character;\n\n  /* Eat Setext-line. */\n  queue = marker;\n  depth = SETEXT_MARKERS[marker];\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== marker) {\n      if (character !== C_NEWLINE) {\n        return;\n      }\n\n      index--;\n      break;\n    }\n\n    queue += character;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  return eat(subvalue + queue)({\n    type: 'heading',\n    depth: depth,\n    children: self.tokenizeInline(content, now)\n  });\n}\n","'use strict';\n\nvar openCloseTag = require('../util/html').openCloseTag;\n\nmodule.exports = blockHTML;\n\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_LT = '<';\n\nfunction blockHTML(eat, value, silent) {\n  var self = this;\n  var blocks = self.options.blocks;\n  var length = value.length;\n  var index = 0;\n  var next;\n  var line;\n  var offset;\n  var character;\n  var count;\n  var sequence;\n  var subvalue;\n\n  var sequences = [\n    [/^<(script|pre|style)(?=(\\s|>|$))/i, /<\\/(script|pre|style)>/i, true],\n    [/^<!--/, /-->/, true],\n    [/^<\\?/, /\\?>/, true],\n    [/^<![A-Za-z]/, />/, true],\n    [/^<!\\[CDATA\\[/, /\\]\\]>/, true],\n    [new RegExp('^</?(' + blocks.join('|') + ')(?=(\\\\s|/?>|$))', 'i'), /^$/, true],\n    [new RegExp(openCloseTag.source + '\\\\s*$'), /^$/, false]\n  ];\n\n  /* Eat initial spacing. */\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    index++;\n  }\n\n  if (value.charAt(index) !== C_LT) {\n    return;\n  }\n\n  next = value.indexOf(C_NEWLINE, index + 1);\n  next = next === -1 ? length : next;\n  line = value.slice(index, next);\n  offset = -1;\n  count = sequences.length;\n\n  while (++offset < count) {\n    if (sequences[offset][0].test(line)) {\n      sequence = sequences[offset];\n      break;\n    }\n  }\n\n  if (!sequence) {\n    return;\n  }\n\n  if (silent) {\n    return sequence[2];\n  }\n\n  index = next;\n\n  if (!sequence[1].test(line)) {\n    while (index < length) {\n      next = value.indexOf(C_NEWLINE, index + 1);\n      next = next === -1 ? length : next;\n      line = value.slice(index + 1, next);\n\n      if (sequence[1].test(line)) {\n        if (line) {\n          index = next;\n        }\n\n        break;\n      }\n\n      index = next;\n    }\n  }\n\n  subvalue = value.slice(0, index);\n\n  return eat(subvalue)({type: 'html', value: subvalue});\n}\n","'use strict';\n\nvar alphabetical = require('is-alphabetical');\nvar locate = require('../locate/tag');\nvar tag = require('../util/html').tag;\n\nmodule.exports = inlineHTML;\ninlineHTML.locator = locate;\n\nvar EXPRESSION_HTML_LINK_OPEN = /^<a /i;\nvar EXPRESSION_HTML_LINK_CLOSE = /^<\\/a>/i;\n\nfunction inlineHTML(eat, value, silent) {\n  var self = this;\n  var length = value.length;\n  var character;\n  var subvalue;\n\n  if (value.charAt(0) !== '<' || length < 3) {\n    return;\n  }\n\n  character = value.charAt(1);\n\n  if (\n    !alphabetical(character) &&\n    character !== '?' &&\n    character !== '!' &&\n    character !== '/'\n  ) {\n    return;\n  }\n\n  subvalue = value.match(tag);\n\n  if (!subvalue) {\n    return;\n  }\n\n  /* istanbul ignore if - not used yet. */\n  if (silent) {\n    return true;\n  }\n\n  subvalue = subvalue[0];\n\n  if (!self.inLink && EXPRESSION_HTML_LINK_OPEN.test(subvalue)) {\n    self.inLink = true;\n  } else if (self.inLink && EXPRESSION_HTML_LINK_CLOSE.test(subvalue)) {\n    self.inLink = false;\n  }\n\n  return eat(subvalue)({type: 'html', value: subvalue});\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/link');\n\nmodule.exports = link;\nlink.locator = locate;\n\nvar own = {}.hasOwnProperty;\n\nvar C_BACKSLASH = '\\\\';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_LT = '<';\nvar C_GT = '>';\nvar C_TICK = '`';\nvar C_DOUBLE_QUOTE = '\"';\nvar C_SINGLE_QUOTE = '\\'';\n\n/* Map of characters, which can be used to mark link\n * and image titles. */\nvar LINK_MARKERS = {};\n\nLINK_MARKERS[C_DOUBLE_QUOTE] = C_DOUBLE_QUOTE;\nLINK_MARKERS[C_SINGLE_QUOTE] = C_SINGLE_QUOTE;\n\n/* Map of characters, which can be used to mark link\n * and image titles in commonmark-mode. */\nvar COMMONMARK_LINK_MARKERS = {};\n\nCOMMONMARK_LINK_MARKERS[C_DOUBLE_QUOTE] = C_DOUBLE_QUOTE;\nCOMMONMARK_LINK_MARKERS[C_SINGLE_QUOTE] = C_SINGLE_QUOTE;\nCOMMONMARK_LINK_MARKERS[C_PAREN_OPEN] = C_PAREN_CLOSE;\n\nfunction link(eat, value, silent) {\n  var self = this;\n  var subvalue = '';\n  var index = 0;\n  var character = value.charAt(0);\n  var pedantic = self.options.pedantic;\n  var commonmark = self.options.commonmark;\n  var gfm = self.options.gfm;\n  var closed;\n  var count;\n  var opening;\n  var beforeURL;\n  var beforeTitle;\n  var subqueue;\n  var hasMarker;\n  var markers;\n  var isImage;\n  var content;\n  var marker;\n  var length;\n  var title;\n  var depth;\n  var queue;\n  var url;\n  var now;\n  var exit;\n  var node;\n\n  /* Detect whether this is an image. */\n  if (character === '!') {\n    isImage = true;\n    subvalue = character;\n    character = value.charAt(++index);\n  }\n\n  /* Eat the opening. */\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n\n  /* Exit when this is a link and we’re already inside\n   * a link. */\n  if (!isImage && self.inLink) {\n    return;\n  }\n\n  subvalue += character;\n  queue = '';\n  index++;\n\n  /* Eat the content. */\n  length = value.length;\n  now = eat.now();\n  depth = 0;\n\n  now.column += index;\n  now.offset += index;\n\n  while (index < length) {\n    character = value.charAt(index);\n    subqueue = character;\n\n    if (character === C_TICK) {\n      /* Inline-code in link content. */\n      count = 1;\n\n      while (value.charAt(index + 1) === C_TICK) {\n        subqueue += character;\n        index++;\n        count++;\n      }\n\n      if (!opening) {\n        opening = count;\n      } else if (count >= opening) {\n        opening = 0;\n      }\n    } else if (character === C_BACKSLASH) {\n      /* Allow brackets to be escaped. */\n      index++;\n      subqueue += value.charAt(index);\n    /* In GFM mode, brackets in code still count.\n     * In all other modes, they don’t.  This empty\n     * block prevents the next statements are\n     * entered. */\n    } else if ((!opening || gfm) && character === C_BRACKET_OPEN) {\n      depth++;\n    } else if ((!opening || gfm) && character === C_BRACKET_CLOSE) {\n      if (depth) {\n        depth--;\n      } else {\n        /* Allow white-space between content and\n         * url in GFM mode. */\n        if (!pedantic) {\n          while (index < length) {\n            character = value.charAt(index + 1);\n\n            if (!whitespace(character)) {\n              break;\n            }\n\n            subqueue += character;\n            index++;\n          }\n        }\n\n        if (value.charAt(index + 1) !== C_PAREN_OPEN) {\n          return;\n        }\n\n        subqueue += C_PAREN_OPEN;\n        closed = true;\n        index++;\n\n        break;\n      }\n    }\n\n    queue += subqueue;\n    subqueue = '';\n    index++;\n  }\n\n  /* Eat the content closing. */\n  if (!closed) {\n    return;\n  }\n\n  content = queue;\n  subvalue += queue + subqueue;\n  index++;\n\n  /* Eat white-space. */\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    subvalue += character;\n    index++;\n  }\n\n  /* Eat the URL. */\n  character = value.charAt(index);\n  markers = commonmark ? COMMONMARK_LINK_MARKERS : LINK_MARKERS;\n  queue = '';\n  beforeURL = subvalue;\n\n  if (character === C_LT) {\n    index++;\n    beforeURL += C_LT;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === C_GT) {\n        break;\n      }\n\n      if (commonmark && character === '\\n') {\n        return;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    if (value.charAt(index) !== C_GT) {\n      return;\n    }\n\n    subvalue += C_LT + queue + C_GT;\n    url = queue;\n    index++;\n  } else {\n    character = null;\n    subqueue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (subqueue && own.call(markers, character)) {\n        break;\n      }\n\n      if (whitespace(character)) {\n        if (!pedantic) {\n          break;\n        }\n\n        subqueue += character;\n      } else {\n        if (character === C_PAREN_OPEN) {\n          depth++;\n        } else if (character === C_PAREN_CLOSE) {\n          if (depth === 0) {\n            break;\n          }\n\n          depth--;\n        }\n\n        queue += subqueue;\n        subqueue = '';\n\n        if (character === C_BACKSLASH) {\n          queue += C_BACKSLASH;\n          character = value.charAt(++index);\n        }\n\n        queue += character;\n      }\n\n      index++;\n    }\n\n    subvalue += queue;\n    url = queue;\n    index = subvalue.length;\n  }\n\n  /* Eat white-space. */\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n  subvalue += queue;\n\n  /* Eat the title. */\n  if (queue && own.call(markers, character)) {\n    index++;\n    subvalue += character;\n    queue = '';\n    marker = markers[character];\n    beforeTitle = subvalue;\n\n    /* In commonmark-mode, things are pretty easy: the\n     * marker cannot occur inside the title.\n     *\n     * Non-commonmark does, however, support nested\n     * delimiters. */\n    if (commonmark) {\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character === marker) {\n          break;\n        }\n\n        if (character === C_BACKSLASH) {\n          queue += C_BACKSLASH;\n          character = value.charAt(++index);\n        }\n\n        index++;\n        queue += character;\n      }\n\n      character = value.charAt(index);\n\n      if (character !== marker) {\n        return;\n      }\n\n      title = queue;\n      subvalue += queue + character;\n      index++;\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (!whitespace(character)) {\n          break;\n        }\n\n        subvalue += character;\n        index++;\n      }\n    } else {\n      subqueue = '';\n\n      while (index < length) {\n        character = value.charAt(index);\n\n        if (character === marker) {\n          if (hasMarker) {\n            queue += marker + subqueue;\n            subqueue = '';\n          }\n\n          hasMarker = true;\n        } else if (!hasMarker) {\n          queue += character;\n        } else if (character === C_PAREN_CLOSE) {\n          subvalue += queue + marker + subqueue;\n          title = queue;\n          break;\n        } else if (whitespace(character)) {\n          subqueue += character;\n        } else {\n          queue += marker + subqueue + character;\n          subqueue = '';\n          hasMarker = false;\n        }\n\n        index++;\n      }\n    }\n  }\n\n  if (value.charAt(index) !== C_PAREN_CLOSE) {\n    return;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  subvalue += C_PAREN_CLOSE;\n\n  url = self.decode.raw(self.unescape(url), eat(beforeURL).test().end, {nonTerminated: false});\n\n  if (title) {\n    beforeTitle = eat(beforeTitle).test().end;\n    title = self.decode.raw(self.unescape(title), beforeTitle);\n  }\n\n  node = {\n    type: isImage ? 'image' : 'link',\n    title: title || null,\n    url: url\n  };\n\n  if (isImage) {\n    node.alt = self.decode.raw(self.unescape(content), now) || null;\n  } else {\n    exit = self.enterLink();\n    node.children = self.tokenizeInline(content, now);\n    exit();\n  }\n\n  return eat(subvalue)(node);\n}\n","'use strict';\n\n/* eslint-disable max-params */\n\nvar trim = require('trim');\nvar repeat = require('repeat-string');\nvar decimal = require('is-decimal');\nvar getIndent = require('../util/get-indentation');\nvar removeIndent = require('../util/remove-indentation');\nvar interrupt = require('../util/interrupt');\n\nmodule.exports = list;\n\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\nvar C_PLUS = '+';\nvar C_DASH = '-';\nvar C_DOT = '.';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_PAREN_CLOSE = ')';\nvar C_X_LOWER = 'x';\n\nvar TAB_SIZE = 4;\nvar EXPRESSION_LOOSE_LIST_ITEM = /\\n\\n(?!\\s*$)/;\nvar EXPRESSION_TASK_ITEM = /^\\[([ \\t]|x|X)][ \\t]/;\nvar EXPRESSION_BULLET = /^([ \\t]*)([*+-]|\\d+[.)])( {1,4}(?! )| |\\t|$|(?=\\n))([^\\n]*)/;\nvar EXPRESSION_PEDANTIC_BULLET = /^([ \\t]*)([*+-]|\\d+[.)])([ \\t]+)/;\nvar EXPRESSION_INITIAL_INDENT = /^( {1,4}|\\t)?/gm;\n\n/* Map of characters which can be used to mark\n * list-items. */\nvar LIST_UNORDERED_MARKERS = {};\n\nLIST_UNORDERED_MARKERS[C_ASTERISK] = true;\nLIST_UNORDERED_MARKERS[C_PLUS] = true;\nLIST_UNORDERED_MARKERS[C_DASH] = true;\n\n/* Map of characters which can be used to mark\n * list-items after a digit. */\nvar LIST_ORDERED_MARKERS = {};\n\nLIST_ORDERED_MARKERS[C_DOT] = true;\n\n/* Map of characters which can be used to mark\n * list-items after a digit. */\nvar LIST_ORDERED_COMMONMARK_MARKERS = {};\n\nLIST_ORDERED_COMMONMARK_MARKERS[C_DOT] = true;\nLIST_ORDERED_COMMONMARK_MARKERS[C_PAREN_CLOSE] = true;\n\nfunction list(eat, value, silent) {\n  var self = this;\n  var commonmark = self.options.commonmark;\n  var pedantic = self.options.pedantic;\n  var tokenizers = self.blockTokenizers;\n  var interuptors = self.interruptList;\n  var markers;\n  var index = 0;\n  var length = value.length;\n  var start = null;\n  var size = 0;\n  var queue;\n  var ordered;\n  var character;\n  var marker;\n  var nextIndex;\n  var startIndex;\n  var prefixed;\n  var currentMarker;\n  var content;\n  var line;\n  var prevEmpty;\n  var empty;\n  var items;\n  var allLines;\n  var emptyLines;\n  var item;\n  var enterTop;\n  var exitBlockquote;\n  var isLoose;\n  var node;\n  var now;\n  var end;\n  var indented;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_TAB) {\n      size += TAB_SIZE - (size % TAB_SIZE);\n    } else if (character === C_SPACE) {\n      size++;\n    } else {\n      break;\n    }\n\n    index++;\n  }\n\n  if (size >= TAB_SIZE) {\n    return;\n  }\n\n  character = value.charAt(index);\n\n  markers = commonmark ?\n    LIST_ORDERED_COMMONMARK_MARKERS :\n    LIST_ORDERED_MARKERS;\n\n  if (LIST_UNORDERED_MARKERS[character] === true) {\n    marker = character;\n    ordered = false;\n  } else {\n    ordered = true;\n    queue = '';\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (!decimal(character)) {\n        break;\n      }\n\n      queue += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (!queue || markers[character] !== true) {\n      return;\n    }\n\n    start = parseInt(queue, 10);\n    marker = character;\n  }\n\n  character = value.charAt(++index);\n\n  if (character !== C_SPACE && character !== C_TAB) {\n    return;\n  }\n\n  if (silent) {\n    return true;\n  }\n\n  index = 0;\n  items = [];\n  allLines = [];\n  emptyLines = [];\n\n  while (index < length) {\n    nextIndex = value.indexOf(C_NEWLINE, index);\n    startIndex = index;\n    prefixed = false;\n    indented = false;\n\n    if (nextIndex === -1) {\n      nextIndex = length;\n    }\n\n    end = index + TAB_SIZE;\n    size = 0;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === C_TAB) {\n        size += TAB_SIZE - (size % TAB_SIZE);\n      } else if (character === C_SPACE) {\n        size++;\n      } else {\n        break;\n      }\n\n      index++;\n    }\n\n    if (size >= TAB_SIZE) {\n      indented = true;\n    }\n\n    if (item && size >= item.indent) {\n      indented = true;\n    }\n\n    character = value.charAt(index);\n    currentMarker = null;\n\n    if (!indented) {\n      if (LIST_UNORDERED_MARKERS[character] === true) {\n        currentMarker = character;\n        index++;\n        size++;\n      } else {\n        queue = '';\n\n        while (index < length) {\n          character = value.charAt(index);\n\n          if (!decimal(character)) {\n            break;\n          }\n\n          queue += character;\n          index++;\n        }\n\n        character = value.charAt(index);\n        index++;\n\n        if (queue && markers[character] === true) {\n          currentMarker = character;\n          size += queue.length + 1;\n        }\n      }\n\n      if (currentMarker) {\n        character = value.charAt(index);\n\n        if (character === C_TAB) {\n          size += TAB_SIZE - (size % TAB_SIZE);\n          index++;\n        } else if (character === C_SPACE) {\n          end = index + TAB_SIZE;\n\n          while (index < end) {\n            if (value.charAt(index) !== C_SPACE) {\n              break;\n            }\n\n            index++;\n            size++;\n          }\n\n          if (index === end && value.charAt(index) === C_SPACE) {\n            index -= TAB_SIZE - 1;\n            size -= TAB_SIZE - 1;\n          }\n        } else if (character !== C_NEWLINE && character !== '') {\n          currentMarker = null;\n        }\n      }\n    }\n\n    if (currentMarker) {\n      if (!pedantic && marker !== currentMarker) {\n        break;\n      }\n\n      prefixed = true;\n    } else {\n      if (!commonmark && !indented && value.charAt(startIndex) === C_SPACE) {\n        indented = true;\n      } else if (commonmark && item) {\n        indented = size >= item.indent || size > TAB_SIZE;\n      }\n\n      prefixed = false;\n      index = startIndex;\n    }\n\n    line = value.slice(startIndex, nextIndex);\n    content = startIndex === index ? line : value.slice(index, nextIndex);\n\n    if (\n      currentMarker === C_ASTERISK ||\n      currentMarker === C_UNDERSCORE ||\n      currentMarker === C_DASH\n    ) {\n      if (tokenizers.thematicBreak.call(self, eat, line, true)) {\n        break;\n      }\n    }\n\n    prevEmpty = empty;\n    empty = !trim(content).length;\n\n    if (indented && item) {\n      item.value = item.value.concat(emptyLines, line);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    } else if (prefixed) {\n      if (emptyLines.length !== 0) {\n        item.value.push('');\n        item.trail = emptyLines.concat();\n      }\n\n      item = {\n        value: [line],\n        indent: size,\n        trail: []\n      };\n\n      items.push(item);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    } else if (empty) {\n      if (prevEmpty) {\n        break;\n      }\n\n      emptyLines.push(line);\n    } else {\n      if (prevEmpty) {\n        break;\n      }\n\n      if (interrupt(interuptors, tokenizers, self, [eat, line, true])) {\n        break;\n      }\n\n      item.value = item.value.concat(emptyLines, line);\n      allLines = allLines.concat(emptyLines, line);\n      emptyLines = [];\n    }\n\n    index = nextIndex + 1;\n  }\n\n  node = eat(allLines.join(C_NEWLINE)).reset({\n    type: 'list',\n    ordered: ordered,\n    start: start,\n    loose: null,\n    children: []\n  });\n\n  enterTop = self.enterList();\n  exitBlockquote = self.enterBlock();\n  isLoose = false;\n  index = -1;\n  length = items.length;\n\n  while (++index < length) {\n    item = items[index].value.join(C_NEWLINE);\n    now = eat.now();\n\n    item = eat(item)(listItem(self, item, now), node);\n\n    if (item.loose) {\n      isLoose = true;\n    }\n\n    item = items[index].trail.join(C_NEWLINE);\n\n    if (index !== length - 1) {\n      item += C_NEWLINE;\n    }\n\n    eat(item);\n  }\n\n  enterTop();\n  exitBlockquote();\n\n  node.loose = isLoose;\n\n  return node;\n}\n\nfunction listItem(ctx, value, position) {\n  var offsets = ctx.offset;\n  var fn = ctx.options.pedantic ? pedanticListItem : normalListItem;\n  var checked = null;\n  var task;\n  var indent;\n\n  value = fn.apply(null, arguments);\n\n  if (ctx.options.gfm) {\n    task = value.match(EXPRESSION_TASK_ITEM);\n\n    if (task) {\n      indent = task[0].length;\n      checked = task[1].toLowerCase() === C_X_LOWER;\n      offsets[position.line] += indent;\n      value = value.slice(indent);\n    }\n  }\n\n  return {\n    type: 'listItem',\n    loose: EXPRESSION_LOOSE_LIST_ITEM.test(value) ||\n      value.charAt(value.length - 1) === C_NEWLINE,\n    checked: checked,\n    children: ctx.tokenizeBlock(value, position)\n  };\n}\n\n/* Create a list-item using overly simple mechanics. */\nfunction pedanticListItem(ctx, value, position) {\n  var offsets = ctx.offset;\n  var line = position.line;\n\n  /* Remove the list-item’s bullet. */\n  value = value.replace(EXPRESSION_PEDANTIC_BULLET, replacer);\n\n  /* The initial line was also matched by the below, so\n   * we reset the `line`. */\n  line = position.line;\n\n  return value.replace(EXPRESSION_INITIAL_INDENT, replacer);\n\n  /* A simple replacer which removed all matches,\n   * and adds their length to `offset`. */\n  function replacer($0) {\n    offsets[line] = (offsets[line] || 0) + $0.length;\n    line++;\n\n    return '';\n  }\n}\n\n/* Create a list-item using sane mechanics. */\nfunction normalListItem(ctx, value, position) {\n  var offsets = ctx.offset;\n  var line = position.line;\n  var max;\n  var bullet;\n  var rest;\n  var lines;\n  var trimmedLines;\n  var index;\n  var length;\n\n  /* Remove the list-item’s bullet. */\n  value = value.replace(EXPRESSION_BULLET, replacer);\n\n  lines = value.split(C_NEWLINE);\n\n  trimmedLines = removeIndent(value, getIndent(max).indent).split(C_NEWLINE);\n\n  /* We replaced the initial bullet with something\n   * else above, which was used to trick\n   * `removeIndentation` into removing some more\n   * characters when possible.  However, that could\n   * result in the initial line to be stripped more\n   * than it should be. */\n  trimmedLines[0] = rest;\n\n  offsets[line] = (offsets[line] || 0) + bullet.length;\n  line++;\n\n  index = 0;\n  length = lines.length;\n\n  while (++index < length) {\n    offsets[line] = (offsets[line] || 0) +\n      lines[index].length - trimmedLines[index].length;\n    line++;\n  }\n\n  return trimmedLines.join(C_NEWLINE);\n\n  function replacer($0, $1, $2, $3, $4) {\n    bullet = $1 + $2 + $3;\n    rest = $4;\n\n    /* Make sure that the first nine numbered list items\n     * can indent with an extra space.  That is, when\n     * the bullet did not receive an extra final space. */\n    if (Number($2) < 10 && bullet.length % 2 === 1) {\n      $2 = C_SPACE + $2;\n    }\n\n    max = $1 + repeat(C_SPACE, $2.length) + $3;\n\n    return max + rest;\n  }\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nmodule.exports = newline;\n\n/* Tokenise newline. */\nfunction newline(eat, value, silent) {\n  var character = value.charAt(0);\n  var length;\n  var subvalue;\n  var queue;\n  var index;\n\n  if (character !== '\\n') {\n    return;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  index = 1;\n  length = value.length;\n  subvalue = character;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    queue += character;\n\n    if (character === '\\n') {\n      subvalue += queue;\n      queue = '';\n    }\n\n    index++;\n  }\n\n  eat(subvalue);\n}\n","'use strict';\n\nvar trim = require('trim');\nvar decimal = require('is-decimal');\nvar trimTrailingLines = require('trim-trailing-lines');\nvar interrupt = require('../util/interrupt');\n\nmodule.exports = paragraph;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\n\nvar TAB_SIZE = 4;\n\n/* Tokenise paragraph. */\nfunction paragraph(eat, value, silent) {\n  var self = this;\n  var settings = self.options;\n  var commonmark = settings.commonmark;\n  var gfm = settings.gfm;\n  var tokenizers = self.blockTokenizers;\n  var interruptors = self.interruptParagraph;\n  var index = value.indexOf(C_NEWLINE);\n  var length = value.length;\n  var position;\n  var subvalue;\n  var character;\n  var size;\n  var now;\n\n  while (index < length) {\n    /* Eat everything if there’s no following newline. */\n    if (index === -1) {\n      index = length;\n      break;\n    }\n\n    /* Stop if the next character is NEWLINE. */\n    if (value.charAt(index + 1) === C_NEWLINE) {\n      break;\n    }\n\n    /* In commonmark-mode, following indented lines\n     * are part of the paragraph. */\n    if (commonmark) {\n      size = 0;\n      position = index + 1;\n\n      while (position < length) {\n        character = value.charAt(position);\n\n        if (character === C_TAB) {\n          size = TAB_SIZE;\n          break;\n        } else if (character === C_SPACE) {\n          size++;\n        } else {\n          break;\n        }\n\n        position++;\n      }\n\n      if (size >= TAB_SIZE) {\n        index = value.indexOf(C_NEWLINE, index + 1);\n        continue;\n      }\n    }\n\n    subvalue = value.slice(index + 1);\n\n    /* Check if the following code contains a possible\n     * block. */\n    if (interrupt(interruptors, tokenizers, self, [eat, subvalue, true])) {\n      break;\n    }\n\n    /* Break if the following line starts a list, when\n     * already in a list, or when in commonmark, or when\n     * in gfm mode and the bullet is *not* numeric. */\n    if (\n      tokenizers.list.call(self, eat, subvalue, true) &&\n      (\n        self.inList ||\n        commonmark ||\n        (gfm && !decimal(trim.left(subvalue).charAt(0)))\n      )\n    ) {\n      break;\n    }\n\n    position = index;\n    index = value.indexOf(C_NEWLINE, index + 1);\n\n    if (index !== -1 && trim(value.slice(position, index)) === '') {\n      index = position;\n      break;\n    }\n  }\n\n  subvalue = value.slice(0, index);\n\n  if (trim(subvalue) === '') {\n    eat(subvalue);\n\n    return null;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  now = eat.now();\n  subvalue = trimTrailingLines(subvalue);\n\n  return eat(subvalue)({\n    type: 'paragraph',\n    children: self.tokenizeInline(subvalue, now)\n  });\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/link');\nvar normalize = require('../util/normalize');\n\nmodule.exports = reference;\nreference.locator = locate;\n\nvar T_LINK = 'link';\nvar T_IMAGE = 'image';\nvar T_FOOTNOTE = 'footnote';\nvar REFERENCE_TYPE_SHORTCUT = 'shortcut';\nvar REFERENCE_TYPE_COLLAPSED = 'collapsed';\nvar REFERENCE_TYPE_FULL = 'full';\nvar C_CARET = '^';\nvar C_BACKSLASH = '\\\\';\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\n\nfunction reference(eat, value, silent) {\n  var self = this;\n  var character = value.charAt(0);\n  var index = 0;\n  var length = value.length;\n  var subvalue = '';\n  var intro = '';\n  var type = T_LINK;\n  var referenceType = REFERENCE_TYPE_SHORTCUT;\n  var content;\n  var identifier;\n  var now;\n  var node;\n  var exit;\n  var queue;\n  var bracketed;\n  var depth;\n\n  /* Check whether we’re eating an image. */\n  if (character === '!') {\n    type = T_IMAGE;\n    intro = character;\n    character = value.charAt(++index);\n  }\n\n  if (character !== C_BRACKET_OPEN) {\n    return;\n  }\n\n  index++;\n  intro += character;\n  queue = '';\n\n  /* Check whether we’re eating a footnote. */\n  if (self.options.footnotes && value.charAt(index) === C_CARET) {\n    /* Exit if `![^` is found, so the `!` will be seen as text after this,\n     * and we’ll enter this function again when `[^` is found. */\n    if (type === T_IMAGE) {\n      return;\n    }\n\n    intro += C_CARET;\n    index++;\n    type = T_FOOTNOTE;\n  }\n\n  /* Eat the text. */\n  depth = 0;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (character === C_BRACKET_OPEN) {\n      bracketed = true;\n      depth++;\n    } else if (character === C_BRACKET_CLOSE) {\n      if (!depth) {\n        break;\n      }\n\n      depth--;\n    }\n\n    if (character === C_BACKSLASH) {\n      queue += C_BACKSLASH;\n      character = value.charAt(++index);\n    }\n\n    queue += character;\n    index++;\n  }\n\n  subvalue = queue;\n  content = queue;\n  character = value.charAt(index);\n\n  if (character !== C_BRACKET_CLOSE) {\n    return;\n  }\n\n  index++;\n  subvalue += character;\n  queue = '';\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (!whitespace(character)) {\n      break;\n    }\n\n    queue += character;\n    index++;\n  }\n\n  character = value.charAt(index);\n\n  /* Inline footnotes cannot have an identifier. */\n  if (type !== T_FOOTNOTE && character === C_BRACKET_OPEN) {\n    identifier = '';\n    queue += character;\n    index++;\n\n    while (index < length) {\n      character = value.charAt(index);\n\n      if (character === C_BRACKET_OPEN || character === C_BRACKET_CLOSE) {\n        break;\n      }\n\n      if (character === C_BACKSLASH) {\n        identifier += C_BACKSLASH;\n        character = value.charAt(++index);\n      }\n\n      identifier += character;\n      index++;\n    }\n\n    character = value.charAt(index);\n\n    if (character === C_BRACKET_CLOSE) {\n      referenceType = identifier ? REFERENCE_TYPE_FULL : REFERENCE_TYPE_COLLAPSED;\n      queue += identifier + character;\n      index++;\n    } else {\n      identifier = '';\n    }\n\n    subvalue += queue;\n    queue = '';\n  } else {\n    if (!content) {\n      return;\n    }\n\n    identifier = content;\n  }\n\n  /* Brackets cannot be inside the identifier. */\n  if (referenceType !== REFERENCE_TYPE_FULL && bracketed) {\n    return;\n  }\n\n  subvalue = intro + subvalue;\n\n  if (type === T_LINK && self.inLink) {\n    return null;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  if (type === T_FOOTNOTE && content.indexOf(' ') !== -1) {\n    return eat(subvalue)({\n      type: 'footnote',\n      children: this.tokenizeInline(content, eat.now())\n    });\n  }\n\n  now = eat.now();\n  now.column += intro.length;\n  now.offset += intro.length;\n  identifier = referenceType === REFERENCE_TYPE_FULL ? identifier : content;\n\n  node = {\n    type: type + 'Reference',\n    identifier: normalize(identifier)\n  };\n\n  if (type === T_LINK || type === T_IMAGE) {\n    node.referenceType = referenceType;\n  }\n\n  if (type === T_LINK) {\n    exit = self.enterLink();\n    node.children = self.tokenizeInline(content, now);\n    exit();\n  } else if (type === T_IMAGE) {\n    node.alt = self.decode.raw(self.unescape(content), now) || null;\n  }\n\n  return eat(subvalue)(node);\n}\n","'use strict';\n\nvar trim = require('trim');\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/strong');\n\nmodule.exports = strong;\nstrong.locator = locate;\n\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\n\nfunction strong(eat, value, silent) {\n  var self = this;\n  var index = 0;\n  var character = value.charAt(index);\n  var now;\n  var pedantic;\n  var marker;\n  var queue;\n  var subvalue;\n  var length;\n  var prev;\n\n  if (\n    (character !== C_ASTERISK && character !== C_UNDERSCORE) ||\n    value.charAt(++index) !== character\n  ) {\n    return;\n  }\n\n  pedantic = self.options.pedantic;\n  marker = character;\n  subvalue = marker + marker;\n  length = value.length;\n  index++;\n  queue = '';\n  character = '';\n\n  if (pedantic && whitespace(value.charAt(index))) {\n    return;\n  }\n\n  while (index < length) {\n    prev = character;\n    character = value.charAt(index);\n\n    if (\n      character === marker &&\n      value.charAt(index + 1) === marker &&\n      (!pedantic || !whitespace(prev))\n    ) {\n      character = value.charAt(index + 2);\n\n      if (character !== marker) {\n        if (!trim(queue)) {\n          return;\n        }\n\n        /* istanbul ignore if - never used (yet) */\n        if (silent) {\n          return true;\n        }\n\n        now = eat.now();\n        now.column += 2;\n        now.offset += 2;\n\n        return eat(subvalue + queue + subvalue)({\n          type: 'strong',\n          children: self.tokenizeInline(queue, now)\n        });\n      }\n    }\n\n    if (!pedantic && character === '\\\\') {\n      queue += character;\n      character = value.charAt(++index);\n    }\n\n    queue += character;\n    index++;\n  }\n}\n","'use strict';\n\nvar whitespace = require('is-whitespace-character');\n\nmodule.exports = table;\n\nvar C_BACKSLASH = '\\\\';\nvar C_TICK = '`';\nvar C_DASH = '-';\nvar C_PIPE = '|';\nvar C_COLON = ':';\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\n\nvar MIN_TABLE_COLUMNS = 1;\nvar MIN_TABLE_ROWS = 2;\n\nvar TABLE_ALIGN_LEFT = 'left';\nvar TABLE_ALIGN_CENTER = 'center';\nvar TABLE_ALIGN_RIGHT = 'right';\nvar TABLE_ALIGN_NONE = null;\n\nfunction table(eat, value, silent) {\n  var self = this;\n  var index;\n  var alignments;\n  var alignment;\n  var subvalue;\n  var row;\n  var length;\n  var lines;\n  var queue;\n  var character;\n  var hasDash;\n  var align;\n  var cell;\n  var preamble;\n  var count;\n  var opening;\n  var now;\n  var position;\n  var lineCount;\n  var line;\n  var rows;\n  var table;\n  var lineIndex;\n  var pipeIndex;\n  var first;\n\n  /* Exit when not in gfm-mode. */\n  if (!self.options.gfm) {\n    return;\n  }\n\n  /* Get the rows.\n   * Detecting tables soon is hard, so there are some\n   * checks for performance here, such as the minimum\n   * number of rows, and allowed characters in the\n   * alignment row. */\n  index = 0;\n  lineCount = 0;\n  length = value.length + 1;\n  lines = [];\n\n  while (index < length) {\n    lineIndex = value.indexOf(C_NEWLINE, index);\n    pipeIndex = value.indexOf(C_PIPE, index + 1);\n\n    if (lineIndex === -1) {\n      lineIndex = value.length;\n    }\n\n    if (pipeIndex === -1 || pipeIndex > lineIndex) {\n      if (lineCount < MIN_TABLE_ROWS) {\n        return;\n      }\n\n      break;\n    }\n\n    lines.push(value.slice(index, lineIndex));\n    lineCount++;\n    index = lineIndex + 1;\n  }\n\n  /* Parse the alignment row. */\n  subvalue = lines.join(C_NEWLINE);\n  alignments = lines.splice(1, 1)[0] || [];\n  index = 0;\n  length = alignments.length;\n  lineCount--;\n  alignment = false;\n  align = [];\n\n  while (index < length) {\n    character = alignments.charAt(index);\n\n    if (character === C_PIPE) {\n      hasDash = null;\n\n      if (alignment === false) {\n        if (first === false) {\n          return;\n        }\n      } else {\n        align.push(alignment);\n        alignment = false;\n      }\n\n      first = false;\n    } else if (character === C_DASH) {\n      hasDash = true;\n      alignment = alignment || TABLE_ALIGN_NONE;\n    } else if (character === C_COLON) {\n      if (alignment === TABLE_ALIGN_LEFT) {\n        alignment = TABLE_ALIGN_CENTER;\n      } else if (hasDash && alignment === TABLE_ALIGN_NONE) {\n        alignment = TABLE_ALIGN_RIGHT;\n      } else {\n        alignment = TABLE_ALIGN_LEFT;\n      }\n    } else if (!whitespace(character)) {\n      return;\n    }\n\n    index++;\n  }\n\n  if (alignment !== false) {\n    align.push(alignment);\n  }\n\n  /* Exit when without enough columns. */\n  if (align.length < MIN_TABLE_COLUMNS) {\n    return;\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  /* Parse the rows. */\n  position = -1;\n  rows = [];\n\n  table = eat(subvalue).reset({\n    type: 'table',\n    align: align,\n    children: rows\n  });\n\n  while (++position < lineCount) {\n    line = lines[position];\n    row = {type: 'tableRow', children: []};\n\n    /* Eat a newline character when this is not the\n     * first row. */\n    if (position) {\n      eat(C_NEWLINE);\n    }\n\n    /* Eat the row. */\n    eat(line).reset(row, table);\n\n    length = line.length + 1;\n    index = 0;\n    queue = '';\n    cell = '';\n    preamble = true;\n    count = null;\n    opening = null;\n\n    while (index < length) {\n      character = line.charAt(index);\n\n      if (character === C_TAB || character === C_SPACE) {\n        if (cell) {\n          queue += character;\n        } else {\n          eat(character);\n        }\n\n        index++;\n        continue;\n      }\n\n      if (character === '' || character === C_PIPE) {\n        if (preamble) {\n          eat(character);\n        } else {\n          if (character && opening) {\n            queue += character;\n            index++;\n            continue;\n          }\n\n          if ((cell || character) && !preamble) {\n            subvalue = cell;\n\n            if (queue.length > 1) {\n              if (character) {\n                subvalue += queue.slice(0, queue.length - 1);\n                queue = queue.charAt(queue.length - 1);\n              } else {\n                subvalue += queue;\n                queue = '';\n              }\n            }\n\n            now = eat.now();\n\n            eat(subvalue)({\n              type: 'tableCell',\n              children: self.tokenizeInline(cell, now)\n            }, row);\n          }\n\n          eat(queue + character);\n\n          queue = '';\n          cell = '';\n        }\n      } else {\n        if (queue) {\n          cell += queue;\n          queue = '';\n        }\n\n        cell += character;\n\n        if (character === C_BACKSLASH && index !== length - 2) {\n          cell += line.charAt(index + 1);\n          index++;\n        }\n\n        if (character === C_TICK) {\n          count = 1;\n\n          while (line.charAt(index + 1) === character) {\n            cell += character;\n            index++;\n            count++;\n          }\n\n          if (!opening) {\n            opening = count;\n          } else if (count >= opening) {\n            opening = 0;\n          }\n        }\n      }\n\n      preamble = false;\n      index++;\n    }\n\n    /* Eat the alignment row. */\n    if (!position) {\n      eat(C_NEWLINE + alignments);\n    }\n  }\n\n  return table;\n}\n","'use strict';\n\nmodule.exports = text;\n\nfunction text(eat, value, silent) {\n  var self = this;\n  var methods;\n  var tokenizers;\n  var index;\n  var length;\n  var subvalue;\n  var position;\n  var tokenizer;\n  var name;\n  var min;\n  var now;\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  methods = self.inlineMethods;\n  length = methods.length;\n  tokenizers = self.inlineTokenizers;\n  index = -1;\n  min = value.length;\n\n  while (++index < length) {\n    name = methods[index];\n\n    if (name === 'text' || !tokenizers[name]) {\n      continue;\n    }\n\n    tokenizer = tokenizers[name].locator;\n\n    if (!tokenizer) {\n      eat.file.fail('Missing locator: `' + name + '`');\n    }\n\n    position = tokenizer.call(self, value, 1);\n\n    if (position !== -1 && position < min) {\n      min = position;\n    }\n  }\n\n  subvalue = value.slice(0, min);\n  now = eat.now();\n\n  self.decode(subvalue, now, function (content, position, source) {\n    eat(source || content)({\n      type: 'text',\n      value: content\n    });\n  });\n}\n","'use strict';\n\nmodule.exports = thematicBreak;\n\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\nvar C_SPACE = ' ';\nvar C_ASTERISK = '*';\nvar C_UNDERSCORE = '_';\nvar C_DASH = '-';\n\nvar THEMATIC_BREAK_MARKER_COUNT = 3;\n\nfunction thematicBreak(eat, value, silent) {\n  var index = -1;\n  var length = value.length + 1;\n  var subvalue = '';\n  var character;\n  var marker;\n  var markerCount;\n  var queue;\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character !== C_TAB && character !== C_SPACE) {\n      break;\n    }\n\n    subvalue += character;\n  }\n\n  if (\n    character !== C_ASTERISK &&\n    character !== C_DASH &&\n    character !== C_UNDERSCORE\n  ) {\n    return;\n  }\n\n  marker = character;\n  subvalue += character;\n  markerCount = 1;\n  queue = '';\n\n  while (++index < length) {\n    character = value.charAt(index);\n\n    if (character === marker) {\n      markerCount++;\n      subvalue += queue + marker;\n      queue = '';\n    } else if (character === C_SPACE) {\n      queue += character;\n    } else if (\n      markerCount >= THEMATIC_BREAK_MARKER_COUNT &&\n      (!character || character === C_NEWLINE)\n    ) {\n      subvalue += queue;\n\n      if (silent) {\n        return true;\n      }\n\n      return eat(subvalue)({type: 'thematicBreak'});\n    } else {\n      return;\n    }\n  }\n}\n","'use strict';\n\nvar decode = require('parse-entities');\nvar whitespace = require('is-whitespace-character');\nvar locate = require('../locate/url');\n\nmodule.exports = url;\nurl.locator = locate;\nurl.notInLink = true;\n\nvar C_BRACKET_OPEN = '[';\nvar C_BRACKET_CLOSE = ']';\nvar C_PAREN_OPEN = '(';\nvar C_PAREN_CLOSE = ')';\nvar C_LT = '<';\nvar C_AT_SIGN = '@';\n\nvar HTTP_PROTOCOL = 'http://';\nvar HTTPS_PROTOCOL = 'https://';\nvar MAILTO_PROTOCOL = 'mailto:';\n\nvar PROTOCOLS = [\n  HTTP_PROTOCOL,\n  HTTPS_PROTOCOL,\n  MAILTO_PROTOCOL\n];\n\nvar PROTOCOLS_LENGTH = PROTOCOLS.length;\n\nfunction url(eat, value, silent) {\n  var self = this;\n  var subvalue;\n  var content;\n  var character;\n  var index;\n  var position;\n  var protocol;\n  var match;\n  var length;\n  var queue;\n  var parenCount;\n  var nextCharacter;\n  var exit;\n\n  if (!self.options.gfm) {\n    return;\n  }\n\n  subvalue = '';\n  index = -1;\n  length = PROTOCOLS_LENGTH;\n\n  while (++index < length) {\n    protocol = PROTOCOLS[index];\n    match = value.slice(0, protocol.length);\n\n    if (match.toLowerCase() === protocol) {\n      subvalue = match;\n      break;\n    }\n  }\n\n  if (!subvalue) {\n    return;\n  }\n\n  index = subvalue.length;\n  length = value.length;\n  queue = '';\n  parenCount = 0;\n\n  while (index < length) {\n    character = value.charAt(index);\n\n    if (whitespace(character) || character === C_LT) {\n      break;\n    }\n\n    if (\n      character === '.' ||\n      character === ',' ||\n      character === ':' ||\n      character === ';' ||\n      character === '\"' ||\n      character === '\\'' ||\n      character === ')' ||\n      character === ']'\n    ) {\n      nextCharacter = value.charAt(index + 1);\n\n      if (!nextCharacter || whitespace(nextCharacter)) {\n        break;\n      }\n    }\n\n    if (character === C_PAREN_OPEN || character === C_BRACKET_OPEN) {\n      parenCount++;\n    }\n\n    if (character === C_PAREN_CLOSE || character === C_BRACKET_CLOSE) {\n      parenCount--;\n\n      if (parenCount < 0) {\n        break;\n      }\n    }\n\n    queue += character;\n    index++;\n  }\n\n  if (!queue) {\n    return;\n  }\n\n  subvalue += queue;\n  content = subvalue;\n\n  if (protocol === MAILTO_PROTOCOL) {\n    position = queue.indexOf(C_AT_SIGN);\n\n    if (position === -1 || position === length - 1) {\n      return;\n    }\n\n    content = content.substr(MAILTO_PROTOCOL.length);\n  }\n\n  /* istanbul ignore if - never used (yet) */\n  if (silent) {\n    return true;\n  }\n\n  exit = self.enterLink();\n  content = self.tokenizeInline(content, eat.now());\n  exit();\n\n  return eat(subvalue)({\n    type: 'link',\n    title: null,\n    url: decode(subvalue, {nonTerminated: false}),\n    children: content\n  });\n}\n","'use strict';\n\nmodule.exports = factory;\n\nvar MERGEABLE_NODES = {\n  text: mergeText,\n  blockquote: mergeBlockquote\n};\n\n/* Check whether a node is mergeable with adjacent nodes. */\nfunction mergeable(node) {\n  var start;\n  var end;\n\n  if (node.type !== 'text' || !node.position) {\n    return true;\n  }\n\n  start = node.position.start;\n  end = node.position.end;\n\n  /* Only merge nodes which occupy the same size as their\n   * `value`. */\n  return start.line !== end.line ||\n      end.column - start.column === node.value.length;\n}\n\n/* Merge two text nodes: `node` into `prev`. */\nfunction mergeText(prev, node) {\n  prev.value += node.value;\n\n  return prev;\n}\n\n/* Merge two blockquotes: `node` into `prev`, unless in\n * CommonMark mode. */\nfunction mergeBlockquote(prev, node) {\n  if (this.options.commonmark) {\n    return node;\n  }\n\n  prev.children = prev.children.concat(node.children);\n\n  return prev;\n}\n\n/* Construct a tokenizer.  This creates both\n * `tokenizeInline` and `tokenizeBlock`. */\nfunction factory(type) {\n  return tokenize;\n\n  /* Tokenizer for a bound `type`. */\n  function tokenize(value, location) {\n    var self = this;\n    var offset = self.offset;\n    var tokens = [];\n    var methods = self[type + 'Methods'];\n    var tokenizers = self[type + 'Tokenizers'];\n    var line = location.line;\n    var column = location.column;\n    var index;\n    var length;\n    var method;\n    var name;\n    var matched;\n    var valueLength;\n\n    /* Trim white space only lines. */\n    if (!value) {\n      return tokens;\n    }\n\n    /* Expose on `eat`. */\n    eat.now = now;\n    eat.file = self.file;\n\n    /* Sync initial offset. */\n    updatePosition('');\n\n    /* Iterate over `value`, and iterate over all\n     * tokenizers.  When one eats something, re-iterate\n     * with the remaining value.  If no tokenizer eats,\n     * something failed (should not happen) and an\n     * exception is thrown. */\n    while (value) {\n      index = -1;\n      length = methods.length;\n      matched = false;\n\n      while (++index < length) {\n        name = methods[index];\n        method = tokenizers[name];\n\n        if (\n          method &&\n          /* istanbul ignore next */ (!method.onlyAtStart || self.atStart) &&\n          (!method.notInList || !self.inList) &&\n          (!method.notInBlock || !self.inBlock) &&\n          (!method.notInLink || !self.inLink)\n        ) {\n          valueLength = value.length;\n\n          method.apply(self, [eat, value]);\n\n          matched = valueLength !== value.length;\n\n          if (matched) {\n            break;\n          }\n        }\n      }\n\n      /* istanbul ignore if */\n      if (!matched) {\n        self.file.fail(new Error('Infinite loop'), eat.now());\n      }\n    }\n\n    self.eof = now();\n\n    return tokens;\n\n    /* Update line, column, and offset based on\n     * `value`. */\n    function updatePosition(subvalue) {\n      var lastIndex = -1;\n      var index = subvalue.indexOf('\\n');\n\n      while (index !== -1) {\n        line++;\n        lastIndex = index;\n        index = subvalue.indexOf('\\n', index + 1);\n      }\n\n      if (lastIndex === -1) {\n        column += subvalue.length;\n      } else {\n        column = subvalue.length - lastIndex;\n      }\n\n      if (line in offset) {\n        if (lastIndex !== -1) {\n          column += offset[line];\n        } else if (column <= offset[line]) {\n          column = offset[line] + 1;\n        }\n      }\n    }\n\n    /* Get offset.  Called before the first character is\n     * eaten to retrieve the range's offsets. */\n    function getOffset() {\n      var indentation = [];\n      var pos = line + 1;\n\n      /* Done.  Called when the last character is\n       * eaten to retrieve the range’s offsets. */\n      return function () {\n        var last = line + 1;\n\n        while (pos < last) {\n          indentation.push((offset[pos] || 0) + 1);\n\n          pos++;\n        }\n\n        return indentation;\n      };\n    }\n\n    /* Get the current position. */\n    function now() {\n      var pos = {line: line, column: column};\n\n      pos.offset = self.toOffset(pos);\n\n      return pos;\n    }\n\n    /* Store position information for a node. */\n    function Position(start) {\n      this.start = start;\n      this.end = now();\n    }\n\n    /* Throw when a value is incorrectly eaten.\n     * This shouldn’t happen but will throw on new,\n     * incorrect rules. */\n    function validateEat(subvalue) {\n      /* istanbul ignore if */\n      if (value.substring(0, subvalue.length) !== subvalue) {\n        /* Capture stack-trace. */\n        self.file.fail(\n          new Error(\n            'Incorrectly eaten value: please report this ' +\n            'warning on http://git.io/vg5Ft'\n          ),\n          now()\n        );\n      }\n    }\n\n    /* Mark position and patch `node.position`. */\n    function position() {\n      var before = now();\n\n      return update;\n\n      /* Add the position to a node. */\n      function update(node, indent) {\n        var prev = node.position;\n        var start = prev ? prev.start : before;\n        var combined = [];\n        var n = prev && prev.end.line;\n        var l = before.line;\n\n        node.position = new Position(start);\n\n        /* If there was already a `position`, this\n         * node was merged.  Fixing `start` wasn’t\n         * hard, but the indent is different.\n         * Especially because some information, the\n         * indent between `n` and `l` wasn’t\n         * tracked.  Luckily, that space is\n         * (should be?) empty, so we can safely\n         * check for it now. */\n        if (prev && indent && prev.indent) {\n          combined = prev.indent;\n\n          if (n < l) {\n            while (++n < l) {\n              combined.push((offset[n] || 0) + 1);\n            }\n\n            combined.push(before.column);\n          }\n\n          indent = combined.concat(indent);\n        }\n\n        node.position.indent = indent || [];\n\n        return node;\n      }\n    }\n\n    /* Add `node` to `parent`s children or to `tokens`.\n     * Performs merges where possible. */\n    function add(node, parent) {\n      var children = parent ? parent.children : tokens;\n      var prev = children[children.length - 1];\n\n      if (\n        prev &&\n        node.type === prev.type &&\n        node.type in MERGEABLE_NODES &&\n        mergeable(prev) &&\n        mergeable(node)\n      ) {\n        node = MERGEABLE_NODES[node.type].call(self, prev, node);\n      }\n\n      if (node !== prev) {\n        children.push(node);\n      }\n\n      if (self.atStart && tokens.length !== 0) {\n        self.exitStart();\n      }\n\n      return node;\n    }\n\n    /* Remove `subvalue` from `value`.\n     * `subvalue` must be at the start of `value`. */\n    function eat(subvalue) {\n      var indent = getOffset();\n      var pos = position();\n      var current = now();\n\n      validateEat(subvalue);\n\n      apply.reset = reset;\n      reset.test = test;\n      apply.test = test;\n\n      value = value.substring(subvalue.length);\n\n      updatePosition(subvalue);\n\n      indent = indent();\n\n      return apply;\n\n      /* Add the given arguments, add `position` to\n       * the returned node, and return the node. */\n      function apply(node, parent) {\n        return pos(add(pos(node), parent), indent);\n      }\n\n      /* Functions just like apply, but resets the\n       * content:  the line and column are reversed,\n       * and the eaten value is re-added.\n       * This is useful for nodes with a single\n       * type of content, such as lists and tables.\n       * See `apply` above for what parameters are\n       * expected. */\n      function reset() {\n        var node = apply.apply(null, arguments);\n\n        line = current.line;\n        column = current.column;\n        value = subvalue + value;\n\n        return node;\n      }\n\n      /* Test the position, after eating, and reverse\n       * to a not-eaten state. */\n      function test() {\n        var result = pos({});\n\n        line = current.line;\n        column = current.column;\n        value = subvalue + value;\n\n        return result.position;\n      }\n    }\n  }\n}\n","'use strict';\n\nmodule.exports = factory;\n\n/* Factory to de-escape a value, based on a list at `key`\n * in `ctx`. */\nfunction factory(ctx, key) {\n  return unescape;\n\n  /* De-escape a string using the expression at `key`\n   * in `ctx`. */\n  function unescape(value) {\n    var prev = 0;\n    var index = value.indexOf('\\\\');\n    var escape = ctx[key];\n    var queue = [];\n    var character;\n\n    while (index !== -1) {\n      queue.push(value.slice(prev, index));\n      prev = index + 1;\n      character = value.charAt(prev);\n\n      /* If the following character is not a valid escape,\n       * add the slash. */\n      if (!character || escape.indexOf(character) === -1) {\n        queue.push('\\\\');\n      }\n\n      index = value.indexOf('\\\\', prev);\n    }\n\n    queue.push(value.slice(prev));\n\n    return queue.join('');\n  }\n}\n","'use strict';\n\nmodule.exports = indentation;\n\n/* Map of characters, and their column length,\n * which can be used as indentation. */\nvar characters = {' ': 1, '\\t': 4};\n\n/* Gets indentation information for a line. */\nfunction indentation(value) {\n  var index = 0;\n  var indent = 0;\n  var character = value.charAt(index);\n  var stops = {};\n  var size;\n\n  while (character in characters) {\n    size = characters[character];\n\n    indent += size;\n\n    if (size > 1) {\n      indent = Math.floor(indent / size) * size;\n    }\n\n    stops[indent] = index;\n\n    character = value.charAt(++index);\n  }\n\n  return {indent: indent, stops: stops};\n}\n","'use strict';\n\nvar attributeName = '[a-zA-Z_:][a-zA-Z0-9:._-]*';\nvar unquoted = '[^\"\\'=<>`\\\\u0000-\\\\u0020]+';\nvar singleQuoted = '\\'[^\\']*\\'';\nvar doubleQuoted = '\"[^\"]*\"';\nvar attributeValue = '(?:' + unquoted + '|' + singleQuoted + '|' + doubleQuoted + ')';\nvar attribute = '(?:\\\\s+' + attributeName + '(?:\\\\s*=\\\\s*' + attributeValue + ')?)';\nvar openTag = '<[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?>';\nvar closeTag = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>';\nvar comment = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';\nvar processing = '<[?].*?[?]>';\nvar declaration = '<![A-Za-z]+\\\\s+[^>]*>';\nvar cdata = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>';\n\nexports.openCloseTag = new RegExp('^(?:' + openTag + '|' + closeTag + ')');\n\nexports.tag = new RegExp('^(?:' +\n  openTag + '|' +\n  closeTag + '|' +\n  comment + '|' +\n  processing + '|' +\n  declaration + '|' +\n  cdata +\n')');\n","'use strict';\n\nmodule.exports = interrupt;\n\nfunction interrupt(interruptors, tokenizers, ctx, params) {\n  var bools = ['pedantic', 'commonmark'];\n  var count = bools.length;\n  var length = interruptors.length;\n  var index = -1;\n  var interruptor;\n  var config;\n  var fn;\n  var offset;\n  var bool;\n  var ignore;\n\n  while (++index < length) {\n    interruptor = interruptors[index];\n    config = interruptor[1] || {};\n    fn = interruptor[0];\n    offset = -1;\n    ignore = false;\n\n    while (++offset < count) {\n      bool = bools[offset];\n\n      if (config[bool] !== undefined && config[bool] !== ctx.options[bool]) {\n        ignore = true;\n        break;\n      }\n    }\n\n    if (ignore) {\n      continue;\n    }\n\n    if (tokenizers[fn].apply(ctx, params)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n","'use strict';\n\nvar collapseWhiteSpace = require('collapse-white-space');\n\nmodule.exports = normalize;\n\n/* Normalize an identifier.  Collapses multiple white space\n * characters into a single space, and removes casing. */\nfunction normalize(value) {\n  return collapseWhiteSpace(value).toLowerCase();\n}\n","'use strict';\n\nvar trim = require('trim');\nvar repeat = require('repeat-string');\nvar getIndent = require('./get-indentation');\n\nmodule.exports = indentation;\n\nvar C_SPACE = ' ';\nvar C_NEWLINE = '\\n';\nvar C_TAB = '\\t';\n\n/* Remove the minimum indent from every line in `value`.\n * Supports both tab, spaced, and mixed indentation (as\n * well as possible). */\nfunction indentation(value, maximum) {\n  var values = value.split(C_NEWLINE);\n  var position = values.length + 1;\n  var minIndent = Infinity;\n  var matrix = [];\n  var index;\n  var indentation;\n  var stops;\n  var padding;\n\n  values.unshift(repeat(C_SPACE, maximum) + '!');\n\n  while (position--) {\n    indentation = getIndent(values[position]);\n\n    matrix[position] = indentation.stops;\n\n    if (trim(values[position]).length === 0) {\n      continue;\n    }\n\n    if (indentation.indent) {\n      if (indentation.indent > 0 && indentation.indent < minIndent) {\n        minIndent = indentation.indent;\n      }\n    } else {\n      minIndent = Infinity;\n\n      break;\n    }\n  }\n\n  if (minIndent !== Infinity) {\n    position = values.length;\n\n    while (position--) {\n      stops = matrix[position];\n      index = minIndent;\n\n      while (index && !(index in stops)) {\n        index--;\n      }\n\n      if (\n        trim(values[position]).length !== 0 &&\n        minIndent &&\n        index !== minIndent\n      ) {\n        padding = C_TAB;\n      } else {\n        padding = '';\n      }\n\n      values[position] = padding + values[position].slice(\n        index in stops ? stops[index] + 1 : 0\n      );\n    }\n  }\n\n  values.shift();\n\n  return values.join(C_NEWLINE);\n}\n","/*!\n * repeat-string <https://github.com/jonschlinkert/repeat-string>\n *\n * Copyright (c) 2014-2015, Jon Schlinkert.\n * Licensed under the MIT License.\n */\n\n'use strict';\n\n/**\n * Results cache\n */\n\nvar res = '';\nvar cache;\n\n/**\n * Expose `repeat`\n */\n\nmodule.exports = repeat;\n\n/**\n * Repeat the given `string` the specified `number`\n * of times.\n *\n * **Example:**\n *\n * ```js\n * var repeat = require('repeat-string');\n * repeat('A', 5);\n * //=> AAAAA\n * ```\n *\n * @param {String} `string` The string to repeat\n * @param {Number} `number` The number of times to repeat the string\n * @return {String} Repeated string\n * @api public\n */\n\nfunction repeat(str, num) {\n  if (typeof str !== 'string') {\n    throw new TypeError('expected a string');\n  }\n\n  // cover common, quick use cases\n  if (num === 1) return str;\n  if (num === 2) return str + str;\n\n  var max = str.length * num;\n  if (cache !== str || typeof cache === 'undefined') {\n    cache = str;\n    res = '';\n  } else if (res.length >= max) {\n    return res.substr(0, max);\n  }\n\n  while (max > res.length && num > 1) {\n    if (num & 1) {\n      res += str;\n    }\n\n    num >>= 1;\n    str += str;\n  }\n\n  res += str;\n  res = res.substr(0, max);\n  return res;\n}\n","'use strict';\n\nvar path = require('path');\n\nfunction replaceExt(npath, ext) {\n  if (typeof npath !== 'string') {\n    return npath;\n  }\n\n  if (npath.length === 0) {\n    return npath;\n  }\n\n  var nFileName = path.basename(npath, path.extname(npath)) + ext;\n  return path.join(path.dirname(npath), nFileName);\n}\n\nmodule.exports = replaceExt;\n","'use strict'\n\nmodule.exports = factory\n\n// Construct a state `toggler`: a function which inverses `property` in context\n// based on its current value.\n// The by `toggler` returned function restores that value.\nfunction factory(key, state, ctx) {\n  return enter\n\n  function enter() {\n    var context = ctx || this\n    var current = context[key]\n\n    context[key] = !state\n\n    return exit\n\n    function exit() {\n      context[key] = current\n    }\n  }\n}\n","'use strict'\n\nmodule.exports = trimTrailingLines\n\n// Remove final newline characters from `value`.\nfunction trimTrailingLines(value) {\n  return String(value).replace(/\\n+$/, '')\n}\n","\nexports = module.exports = trim;\n\nfunction trim(str){\n  return str.replace(/^\\s*|\\s*$/g, '');\n}\n\nexports.left = function(str){\n  return str.replace(/^\\s*/, '');\n};\n\nexports.right = function(str){\n  return str.replace(/\\s*$/, '');\n};\n","'use strict'\n\nvar wrap = require('./wrap.js')\n\nmodule.exports = trough\n\ntrough.wrap = wrap\n\nvar slice = [].slice\n\n// Create new middleware.\nfunction trough() {\n  var fns = []\n  var middleware = {}\n\n  middleware.run = run\n  middleware.use = use\n\n  return middleware\n\n  // Run `fns`.  Last argument must be a completion handler.\n  function run() {\n    var index = -1\n    var input = slice.call(arguments, 0, -1)\n    var done = arguments[arguments.length - 1]\n\n    if (typeof done !== 'function') {\n      throw new Error('Expected function as last argument, not ' + done)\n    }\n\n    next.apply(null, [null].concat(input))\n\n    // Run the next `fn`, if any.\n    function next(err) {\n      var fn = fns[++index]\n      var params = slice.call(arguments, 0)\n      var values = params.slice(1)\n      var length = input.length\n      var pos = -1\n\n      if (err) {\n        done(err)\n        return\n      }\n\n      // Copy non-nully input into values.\n      while (++pos < length) {\n        if (values[pos] === null || values[pos] === undefined) {\n          values[pos] = input[pos]\n        }\n      }\n\n      input = values\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next).apply(null, input)\n      } else {\n        done.apply(null, [null].concat(input))\n      }\n    }\n  }\n\n  // Add `fn` to the list.\n  function use(fn) {\n    if (typeof fn !== 'function') {\n      throw new Error('Expected `fn` to be a function, not ' + fn)\n    }\n\n    fns.push(fn)\n\n    return middleware\n  }\n}\n","'use strict'\n\nvar slice = [].slice\n\nmodule.exports = wrap\n\n// Wrap `fn`.\n// Can be sync or async; return a promise, receive a completion handler, return\n// new values and errors.\nfunction wrap(fn, callback) {\n  var invoked\n\n  return wrapped\n\n  function wrapped() {\n    var params = slice.call(arguments, 0)\n    var callback = fn.length > params.length\n    var result\n\n    if (callback) {\n      params.push(done)\n    }\n\n    try {\n      result = fn.apply(null, params)\n    } catch (error) {\n      // Well, this is quite the pickle.\n      // `fn` received a callback and invoked it (thus continuing the pipeline),\n      // but later also threw an error.\n      // We’re not about to restart the pipeline again, so the only thing left\n      // to do is to throw the thing instead.\n      if (callback && invoked) {\n        throw error\n      }\n\n      return done(error)\n    }\n\n    if (!callback) {\n      if (result && typeof result.then === 'function') {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  // Invoke `next`, only once.\n  function done() {\n    if (!invoked) {\n      invoked = true\n\n      callback.apply(null, arguments)\n    }\n  }\n\n  // Invoke `done` with one value.\n  // Tracks if an error is passed, too.\n  function then(value) {\n    done(null, value)\n  }\n}\n","'use strict'\n\nvar xtend = require('xtend')\nvar inherits = require('inherits')\n\nmodule.exports = unherit\n\n// Create a custom constructor which can be modified without affecting the\n// original class.\nfunction unherit(Super) {\n  var result\n  var key\n  var value\n\n  inherits(Of, Super)\n  inherits(From, Of)\n\n  // Clone values.\n  result = Of.prototype\n\n  for (key in result) {\n    value = result[key]\n\n    if (value && typeof value === 'object') {\n      result[key] = 'concat' in value ? value.concat() : xtend(value)\n    }\n  }\n\n  return Of\n\n  // Constructor accepting a single argument, which itself is an `arguments`\n  // object.\n  function From(parameters) {\n    return Super.apply(this, parameters)\n  }\n\n  // Constructor accepting variadic arguments.\n  function Of() {\n    if (!(this instanceof Of)) {\n      return new From(arguments)\n    }\n\n    return Super.apply(this, arguments)\n  }\n}\n","'use strict'\n\n/* Dependencies. */\nvar extend = require('extend')\nvar bail = require('bail')\nvar vfile = require('vfile')\nvar trough = require('trough')\nvar string = require('x-is-string')\nvar plain = require('is-plain-obj')\n\n/* Expose a frozen processor. */\nmodule.exports = unified().freeze()\n\nvar slice = [].slice\nvar own = {}.hasOwnProperty\n\n/* Process pipeline. */\nvar pipeline = trough()\n  .use(pipelineParse)\n  .use(pipelineRun)\n  .use(pipelineStringify)\n\nfunction pipelineParse(p, ctx) {\n  ctx.tree = p.parse(ctx.file)\n}\n\nfunction pipelineRun(p, ctx, next) {\n  p.run(ctx.tree, ctx.file, done)\n\n  function done(err, tree, file) {\n    if (err) {\n      next(err)\n    } else {\n      ctx.tree = tree\n      ctx.file = file\n      next()\n    }\n  }\n}\n\nfunction pipelineStringify(p, ctx) {\n  ctx.file.contents = p.stringify(ctx.tree, ctx.file)\n}\n\n/* Function to create the first processor. */\nfunction unified() {\n  var attachers = []\n  var transformers = trough()\n  var namespace = {}\n  var frozen = false\n  var freezeIndex = -1\n\n  /* Data management. */\n  processor.data = data\n\n  /* Lock. */\n  processor.freeze = freeze\n\n  /* Plug-ins. */\n  processor.attachers = attachers\n  processor.use = use\n\n  /* API. */\n  processor.parse = parse\n  processor.stringify = stringify\n  processor.run = run\n  processor.runSync = runSync\n  processor.process = process\n  processor.processSync = processSync\n\n  /* Expose. */\n  return processor\n\n  /* Create a new processor based on the processor\n   * in the current scope. */\n  function processor() {\n    var destination = unified()\n    var length = attachers.length\n    var index = -1\n\n    while (++index < length) {\n      destination.use.apply(null, attachers[index])\n    }\n\n    destination.data(extend(true, {}, namespace))\n\n    return destination\n  }\n\n  /* Freeze: used to signal a processor that has finished\n   * configuration.\n   *\n   * For example, take unified itself.  It’s frozen.\n   * Plug-ins should not be added to it.  Rather, it should\n   * be extended, by invoking it, before modifying it.\n   *\n   * In essence, always invoke this when exporting a\n   * processor. */\n  function freeze() {\n    var values\n    var plugin\n    var options\n    var transformer\n\n    if (frozen) {\n      return processor\n    }\n\n    while (++freezeIndex < attachers.length) {\n      values = attachers[freezeIndex]\n      plugin = values[0]\n      options = values[1]\n      transformer = null\n\n      if (options === false) {\n        continue\n      }\n\n      if (options === true) {\n        values[1] = undefined\n      }\n\n      transformer = plugin.apply(processor, values.slice(1))\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer)\n      }\n    }\n\n    frozen = true\n    freezeIndex = Infinity\n\n    return processor\n  }\n\n  /* Data management.\n   * Getter / setter for processor-specific informtion. */\n  function data(key, value) {\n    if (string(key)) {\n      /* Set `key`. */\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen)\n\n        namespace[key] = value\n\n        return processor\n      }\n\n      /* Get `key`. */\n      return (own.call(namespace, key) && namespace[key]) || null\n    }\n\n    /* Set space. */\n    if (key) {\n      assertUnfrozen('data', frozen)\n      namespace = key\n      return processor\n    }\n\n    /* Get space. */\n    return namespace\n  }\n\n  /* Plug-in management.\n   *\n   * Pass it:\n   * *   an attacher and options,\n   * *   a preset,\n   * *   a list of presets, attachers, and arguments (list\n   *     of attachers and options). */\n  function use(value) {\n    var settings\n\n    assertUnfrozen('use', frozen)\n\n    if (value === null || value === undefined) {\n      /* Empty */\n    } else if (typeof value === 'function') {\n      addPlugin.apply(null, arguments)\n    } else if (typeof value === 'object') {\n      if ('length' in value) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new Error('Expected usable value, not `' + value + '`')\n    }\n\n    if (settings) {\n      namespace.settings = extend(namespace.settings || {}, settings)\n    }\n\n    return processor\n\n    function addPreset(result) {\n      addList(result.plugins)\n\n      if (result.settings) {\n        settings = extend(settings || {}, result.settings)\n      }\n    }\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value)\n      } else if (typeof value === 'object') {\n        if ('length' in value) {\n          addPlugin.apply(null, value)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new Error('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    function addList(plugins) {\n      var length\n      var index\n\n      if (plugins === null || plugins === undefined) {\n        /* Empty */\n      } else if (typeof plugins === 'object' && 'length' in plugins) {\n        length = plugins.length\n        index = -1\n\n        while (++index < length) {\n          add(plugins[index])\n        }\n      } else {\n        throw new Error('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    function addPlugin(plugin, value) {\n      var entry = find(plugin)\n\n      if (entry) {\n        if (plain(entry[1]) && plain(value)) {\n          value = extend(entry[1], value)\n        }\n\n        entry[1] = value\n      } else {\n        attachers.push(slice.call(arguments))\n      }\n    }\n  }\n\n  function find(plugin) {\n    var length = attachers.length\n    var index = -1\n    var entry\n\n    while (++index < length) {\n      entry = attachers[index]\n\n      if (entry[0] === plugin) {\n        return entry\n      }\n    }\n  }\n\n  /* Parse a file (in string or VFile representation)\n   * into a Unist node using the `Parser` on the\n   * processor. */\n  function parse(doc) {\n    var file = vfile(doc)\n    var Parser\n\n    freeze()\n    Parser = processor.Parser\n    assertParser('parse', Parser)\n\n    if (newable(Parser)) {\n      return new Parser(String(file), file).parse()\n    }\n\n    return Parser(String(file), file) // eslint-disable-line new-cap\n  }\n\n  /* Run transforms on a Unist node representation of a file\n   * (in string or VFile representation), async. */\n  function run(node, file, cb) {\n    assertNode(node)\n    freeze()\n\n    if (!cb && typeof file === 'function') {\n      cb = file\n      file = null\n    }\n\n    if (!cb) {\n      return new Promise(executor)\n    }\n\n    executor(null, cb)\n\n    function executor(resolve, reject) {\n      transformers.run(node, vfile(file), done)\n\n      function done(err, tree, file) {\n        tree = tree || node\n        if (err) {\n          reject(err)\n        } else if (resolve) {\n          resolve(tree)\n        } else {\n          cb(null, tree, file)\n        }\n      }\n    }\n  }\n\n  /* Run transforms on a Unist node representation of a file\n   * (in string or VFile representation), sync. */\n  function runSync(node, file) {\n    var complete = false\n    var result\n\n    run(node, file, done)\n\n    assertDone('runSync', 'run', complete)\n\n    return result\n\n    function done(err, tree) {\n      complete = true\n      bail(err)\n      result = tree\n    }\n  }\n\n  /* Stringify a Unist node representation of a file\n   * (in string or VFile representation) into a string\n   * using the `Compiler` on the processor. */\n  function stringify(node, doc) {\n    var file = vfile(doc)\n    var Compiler\n\n    freeze()\n    Compiler = processor.Compiler\n    assertCompiler('stringify', Compiler)\n    assertNode(node)\n\n    if (newable(Compiler)) {\n      return new Compiler(node, file).compile()\n    }\n\n    return Compiler(node, file) // eslint-disable-line new-cap\n  }\n\n  /* Parse a file (in string or VFile representation)\n   * into a Unist node using the `Parser` on the processor,\n   * then run transforms on that node, and compile the\n   * resulting node using the `Compiler` on the processor,\n   * and store that result on the VFile. */\n  function process(doc, cb) {\n    freeze()\n    assertParser('process', processor.Parser)\n    assertCompiler('process', processor.Compiler)\n\n    if (!cb) {\n      return new Promise(executor)\n    }\n\n    executor(null, cb)\n\n    function executor(resolve, reject) {\n      var file = vfile(doc)\n\n      pipeline.run(processor, {file: file}, done)\n\n      function done(err) {\n        if (err) {\n          reject(err)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          cb(null, file)\n        }\n      }\n    }\n  }\n\n  /* Process the given document (in string or VFile\n   * representation), sync. */\n  function processSync(doc) {\n    var complete = false\n    var file\n\n    freeze()\n    assertParser('processSync', processor.Parser)\n    assertCompiler('processSync', processor.Compiler)\n    file = vfile(doc)\n\n    process(file, done)\n\n    assertDone('processSync', 'process', complete)\n\n    return file\n\n    function done(err) {\n      complete = true\n      bail(err)\n    }\n  }\n}\n\n/* Check if `func` is a constructor. */\nfunction newable(value) {\n  return typeof value === 'function' && keys(value.prototype)\n}\n\n/* Check if `value` is an object with keys. */\nfunction keys(value) {\n  var key\n  for (key in value) {\n    return true\n  }\n  return false\n}\n\n/* Assert a parser is available. */\nfunction assertParser(name, Parser) {\n  if (typeof Parser !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Parser`')\n  }\n}\n\n/* Assert a compiler is available. */\nfunction assertCompiler(name, Compiler) {\n  if (typeof Compiler !== 'function') {\n    throw new Error('Cannot `' + name + '` without `Compiler`')\n  }\n}\n\n/* Assert the processor is not frozen. */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      [\n        'Cannot invoke `' + name + '` on a frozen processor.\\nCreate a new ',\n        'processor first, by invoking it: use `processor()` instead of ',\n        '`processor`.'\n      ].join('')\n    )\n  }\n}\n\n/* Assert `node` is a Unist node. */\nfunction assertNode(node) {\n  if (!node || !string(node.type)) {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n}\n\n/* Assert that `complete` is `true`. */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n","'use strict'\n\nmodule.exports = convert\n\nfunction convert(test) {\n  if (typeof test === 'string') {\n    return typeFactory(test)\n  }\n\n  if (test === null || test === undefined) {\n    return ok\n  }\n\n  if (typeof test === 'object') {\n    return ('length' in test ? anyFactory : matchesFactory)(test)\n  }\n\n  if (typeof test === 'function') {\n    return test\n  }\n\n  throw new Error('Expected function, string, or object as test')\n}\n\nfunction convertAll(tests) {\n  var results = []\n  var length = tests.length\n  var index = -1\n\n  while (++index < length) {\n    results[index] = convert(tests[index])\n  }\n\n  return results\n}\n\n// Utility assert each property in `test` is represented in `node`, and each\n// values are strictly equal.\nfunction matchesFactory(test) {\n  return matches\n\n  function matches(node) {\n    var key\n\n    for (key in test) {\n      if (node[key] !== test[key]) {\n        return false\n      }\n    }\n\n    return true\n  }\n}\n\nfunction anyFactory(tests) {\n  var checks = convertAll(tests)\n  var length = checks.length\n\n  return matches\n\n  function matches() {\n    var index = -1\n\n    while (++index < length) {\n      if (checks[index].apply(this, arguments)) {\n        return true\n      }\n    }\n\n    return false\n  }\n}\n\n// Utility to convert a string into a function which checks a given node’s type\n// for said string.\nfunction typeFactory(test) {\n  return type\n\n  function type(node) {\n    return Boolean(node && node.type === test)\n  }\n}\n\n// Utility to return true.\nfunction ok() {\n  return true\n}\n","'use strict'\n\nvar visit = require('unist-util-visit')\n\nmodule.exports = removePosition\n\nfunction removePosition(node, force) {\n  visit(node, force ? hard : soft)\n  return node\n}\n\nfunction hard(node) {\n  delete node.position\n}\n\nfunction soft(node) {\n  node.position = undefined\n}\n","'use strict'\n\nvar own = {}.hasOwnProperty\n\nmodule.exports = stringify\n\nfunction stringify(value) {\n  /* Nothing. */\n  if (!value || typeof value !== 'object') {\n    return null\n  }\n\n  /* Node. */\n  if (own.call(value, 'position') || own.call(value, 'type')) {\n    return position(value.position)\n  }\n\n  /* Position. */\n  if (own.call(value, 'start') || own.call(value, 'end')) {\n    return position(value)\n  }\n\n  /* Point. */\n  if (own.call(value, 'line') || own.call(value, 'column')) {\n    return point(value)\n  }\n\n  /* ? */\n  return null\n}\n\nfunction point(point) {\n  if (!point || typeof point !== 'object') {\n    point = {}\n  }\n\n  return index(point.line) + ':' + index(point.column)\n}\n\nfunction position(pos) {\n  if (!pos || typeof pos !== 'object') {\n    pos = {}\n  }\n\n  return point(pos.start) + '-' + point(pos.end)\n}\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","'use strict'\n\n/* Expose. */\nmodule.exports = visitParents\n\n/* Visit. */\nfunction visitParents(tree, type, visitor) {\n  var stack = []\n\n  if (typeof type === 'function') {\n    visitor = type\n    type = null\n  }\n\n  one(tree)\n\n  /* Visit a single node. */\n  function one(node) {\n    var result\n\n    if (!type || node.type === type) {\n      result = visitor(node, stack.concat())\n    }\n\n    if (node.children && result !== false) {\n      return all(node.children, node)\n    }\n\n    return result\n  }\n\n  /* Visit children in `parent`. */\n  function all(children, parent) {\n    var length = children.length\n    var index = -1\n    var child\n\n    stack.push(parent)\n\n    while (++index < length) {\n      child = children[index]\n\n      if (child && one(child) === false) {\n        return false\n      }\n    }\n\n    stack.pop()\n\n    return true\n  }\n}\n","'use strict'\n\nmodule.exports = visit\n\nvar visitParents = require('unist-util-visit-parents')\n\nvar CONTINUE = visitParents.CONTINUE\nvar SKIP = visitParents.SKIP\nvar EXIT = visitParents.EXIT\n\nvisit.CONTINUE = CONTINUE\nvisit.SKIP = SKIP\nvisit.EXIT = EXIT\n\nfunction visit(tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    visitor = test\n    test = null\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  function overload(node, parents) {\n    var parent = parents[parents.length - 1]\n    var index = parent ? parent.children.indexOf(node) : null\n    return visitor(node, index, parent)\n  }\n}\n","'use strict'\n\nmodule.exports = visitParents\n\nvar convert = require('unist-util-is/convert')\n\nvar CONTINUE = true\nvar SKIP = 'skip'\nvar EXIT = false\n\nvisitParents.CONTINUE = CONTINUE\nvisitParents.SKIP = SKIP\nvisitParents.EXIT = EXIT\n\nfunction visitParents(tree, test, visitor, reverse) {\n  var is\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    visitor = test\n    test = null\n  }\n\n  is = convert(test)\n\n  one(tree, null, [])\n\n  // Visit a single node.\n  function one(node, index, parents) {\n    var result = []\n    var subresult\n\n    if (!test || is(node, index, parents[parents.length - 1] || null)) {\n      result = toResult(visitor(node, parents))\n\n      if (result[0] === EXIT) {\n        return result\n      }\n    }\n\n    if (node.children && result[0] !== SKIP) {\n      subresult = toResult(all(node.children, parents.concat(node)))\n      return subresult[0] === EXIT ? subresult : result\n    }\n\n    return result\n  }\n\n  // Visit children in `parent`.\n  function all(children, parents) {\n    var min = -1\n    var step = reverse ? -1 : 1\n    var index = (reverse ? children.length : min) + step\n    var result\n\n    while (index > min && index < children.length) {\n      result = one(children[index], index, parents)\n\n      if (result[0] === EXIT) {\n        return result\n      }\n\n      index = typeof result[1] === 'number' ? result[1] : index + step\n    }\n  }\n}\n\nfunction toResult(value) {\n  if (value !== null && typeof value === 'object' && 'length' in value) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return [value]\n}\n","'use strict'\n\nmodule.exports = factory\n\nfunction factory(file) {\n  var contents = indices(String(file))\n\n  return {\n    toPosition: offsetToPositionFactory(contents),\n    toOffset: positionToOffsetFactory(contents)\n  }\n}\n\n// Factory to get the line and column-based `position` for `offset` in the bound\n// indices.\nfunction offsetToPositionFactory(indices) {\n  return offsetToPosition\n\n  // Get the line and column-based `position` for `offset` in the bound indices.\n  function offsetToPosition(offset) {\n    var index = -1\n    var length = indices.length\n\n    if (offset < 0) {\n      return {}\n    }\n\n    while (++index < length) {\n      if (indices[index] > offset) {\n        return {\n          line: index + 1,\n          column: offset - (indices[index - 1] || 0) + 1,\n          offset: offset\n        }\n      }\n    }\n\n    return {}\n  }\n}\n\n// Factory to get the `offset` for a line and column-based `position` in the\n// bound indices.\nfunction positionToOffsetFactory(indices) {\n  return positionToOffset\n\n  // Get the `offset` for a line and column-based `position` in the bound\n  // indices.\n  function positionToOffset(position) {\n    var line = position && position.line\n    var column = position && position.column\n\n    if (!isNaN(line) && !isNaN(column) && line - 1 in indices) {\n      return (indices[line - 2] || 0) + column - 1 || 0\n    }\n\n    return -1\n  }\n}\n\n// Get indices of line-breaks in `value`.\nfunction indices(value) {\n  var result = []\n  var index = value.indexOf('\\n')\n\n  while (index !== -1) {\n    result.push(index + 1)\n    index = value.indexOf('\\n', index + 1)\n  }\n\n  result.push(value.length + 1)\n\n  return result\n}\n","'use strict'\n\nvar stringify = require('unist-util-stringify-position')\n\nmodule.exports = VMessage\n\n// Inherit from `Error#`.\nfunction VMessagePrototype() {}\nVMessagePrototype.prototype = Error.prototype\nVMessage.prototype = new VMessagePrototype()\n\n// Message properties.\nvar proto = VMessage.prototype\n\nproto.file = ''\nproto.name = ''\nproto.reason = ''\nproto.message = ''\nproto.stack = ''\nproto.fatal = null\nproto.column = null\nproto.line = null\n\n// Construct a new VMessage.\n//\n// Note: We cannot invoke `Error` on the created context, as that adds readonly\n// `line` and `column` attributes on Safari 9, thus throwing and failing the\n// data.\nfunction VMessage(reason, position, origin) {\n  var parts\n  var range\n  var location\n\n  if (typeof position === 'string') {\n    origin = position\n    position = null\n  }\n\n  parts = parseOrigin(origin)\n  range = stringify(position) || '1:1'\n\n  location = {\n    start: {line: null, column: null},\n    end: {line: null, column: null}\n  }\n\n  // Node.\n  if (position && position.position) {\n    position = position.position\n  }\n\n  if (position) {\n    // Position.\n    if (position.start) {\n      location = position\n      position = position.start\n    } else {\n      // Point.\n      location.start = position\n    }\n  }\n\n  if (reason.stack) {\n    this.stack = reason.stack\n    reason = reason.message\n  }\n\n  this.message = reason\n  this.name = range\n  this.reason = reason\n  this.line = position ? position.line : null\n  this.column = position ? position.column : null\n  this.location = location\n  this.source = parts[0]\n  this.ruleId = parts[1]\n}\n\nfunction parseOrigin(origin) {\n  var result = [null, null]\n  var index\n\n  if (typeof origin === 'string') {\n    index = origin.indexOf(':')\n\n    if (index === -1) {\n      result[1] = origin\n    } else {\n      result[0] = origin.slice(0, index)\n      result[1] = origin.slice(index + 1)\n    }\n  }\n\n  return result\n}\n","'use strict';\n\nvar path = require('path');\nvar replace = require('replace-ext');\nvar buffer = require('is-buffer');\n\nmodule.exports = VFile;\n\nvar own = {}.hasOwnProperty;\nvar proto = VFile.prototype;\n\nproto.toString = toString;\n\n/* Order of setting (least specific to most), we need this because\n * otherwise `{stem: 'a', path: '~/b.js'}` would throw, as a path\n * is needed before a stem can be set. */\nvar order = [\n  'history',\n  'path',\n  'basename',\n  'stem',\n  'extname',\n  'dirname'\n];\n\n/* Construct a new file. */\nfunction VFile(options) {\n  var prop;\n  var index;\n  var length;\n\n  if (!options) {\n    options = {};\n  } else if (typeof options === 'string' || buffer(options)) {\n    options = {contents: options};\n  } else if ('message' in options && 'messages' in options) {\n    return options;\n  }\n\n  if (!(this instanceof VFile)) {\n    return new VFile(options);\n  }\n\n  this.data = {};\n  this.messages = [];\n  this.history = [];\n  this.cwd = process.cwd();\n\n  /* Set path related properties in the correct order. */\n  index = -1;\n  length = order.length;\n\n  while (++index < length) {\n    prop = order[index];\n\n    if (own.call(options, prop)) {\n      this[prop] = options[prop];\n    }\n  }\n\n  /* Set non-path related properties. */\n  for (prop in options) {\n    if (order.indexOf(prop) === -1) {\n      this[prop] = options[prop];\n    }\n  }\n}\n\n/* Access full path (`~/index.min.js`). */\nObject.defineProperty(proto, 'path', {\n  get: function () {\n    return this.history[this.history.length - 1];\n  },\n  set: function (path) {\n    assertNonEmpty(path, 'path');\n\n    if (path !== this.path) {\n      this.history.push(path);\n    }\n  }\n});\n\n/* Access parent path (`~`). */\nObject.defineProperty(proto, 'dirname', {\n  get: function () {\n    return typeof this.path === 'string' ? path.dirname(this.path) : undefined;\n  },\n  set: function (dirname) {\n    assertPath(this.path, 'dirname');\n    this.path = path.join(dirname || '', this.basename);\n  }\n});\n\n/* Access basename (`index.min.js`). */\nObject.defineProperty(proto, 'basename', {\n  get: function () {\n    return typeof this.path === 'string' ? path.basename(this.path) : undefined;\n  },\n  set: function (basename) {\n    assertNonEmpty(basename, 'basename');\n    assertPart(basename, 'basename');\n    this.path = path.join(this.dirname || '', basename);\n  }\n});\n\n/* Access extname (`.js`). */\nObject.defineProperty(proto, 'extname', {\n  get: function () {\n    return typeof this.path === 'string' ? path.extname(this.path) : undefined;\n  },\n  set: function (extname) {\n    var ext = extname || '';\n\n    assertPart(ext, 'extname');\n    assertPath(this.path, 'extname');\n\n    if (ext) {\n      if (ext.charAt(0) !== '.') {\n        throw new Error('`extname` must start with `.`');\n      }\n\n      if (ext.indexOf('.', 1) !== -1) {\n        throw new Error('`extname` cannot contain multiple dots');\n      }\n    }\n\n    this.path = replace(this.path, ext);\n  }\n});\n\n/* Access stem (`index.min`). */\nObject.defineProperty(proto, 'stem', {\n  get: function () {\n    return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined;\n  },\n  set: function (stem) {\n    assertNonEmpty(stem, 'stem');\n    assertPart(stem, 'stem');\n    this.path = path.join(this.dirname || '', stem + (this.extname || ''));\n  }\n});\n\n/* Get the value of the file. */\nfunction toString(encoding) {\n  var value = this.contents || '';\n  return buffer(value) ? value.toString(encoding) : String(value);\n}\n\n/* Assert that `part` is not a path (i.e., does\n * not contain `path.sep`). */\nfunction assertPart(part, name) {\n  if (part.indexOf(path.sep) !== -1) {\n    throw new Error('`' + name + '` cannot be a path: did not expect `' + path.sep + '`');\n  }\n}\n\n/* Assert that `part` is not empty. */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty');\n  }\n}\n\n/* Assert `path` exists. */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too');\n  }\n}\n","'use strict';\n\nvar VMessage = require('vfile-message');\nvar VFile = require('./core.js');\n\nmodule.exports = VFile;\n\nvar proto = VFile.prototype;\n\nproto.message = message;\nproto.info = info;\nproto.fail = fail;\n\n/* Slight backwards compatibility.  Remove in the future. */\nproto.warn = message;\n\n/* Create a message with `reason` at `position`.\n * When an error is passed in as `reason`, copies the stack. */\nfunction message(reason, position, origin) {\n  var filePath = this.path;\n  var message = new VMessage(reason, position, origin);\n\n  if (filePath) {\n    message.name = filePath + ':' + message.name;\n    message.file = filePath;\n  }\n\n  message.fatal = false;\n\n  this.messages.push(message);\n\n  return message;\n}\n\n/* Fail. Creates a vmessage, associates it with the file,\n * and throws it. */\nfunction fail() {\n  var message = this.message.apply(this, arguments);\n\n  message.fatal = true;\n\n  throw message;\n}\n\n/* Info. Creates a vmessage, associates it with the file,\n * and marks the fatality as null. */\nfunction info() {\n  var message = this.message.apply(this, arguments);\n\n  message.fatal = null;\n\n  return message;\n}\n","var toString = Object.prototype.toString\n\nmodule.exports = isString\n\nfunction isString(obj) {\n    return toString.call(obj) === \"[object String]\"\n}\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n"],"names":["DashMath","_Component","_inherits","_super","props","_this","_classCallCheck","call","span_element","React","key","value","this","renderMath","prevProps","tex","inline","current","lazyLoadMathJax","then","window","MathJax","typeset","ref","Component","propTypes","PropTypes","defaultProps","MarkdownHighlighter","loadhljs","Promise","resolve","hljs","result","default","hljsResolve","isReady","DashMarkdown","setState","highlightCode","bind","_assertThisInitialized","dedent","mdContainer","nodes","querySelectorAll","i","length","highlightElement","text","_step","lines","split","commonPrefix","_iterator","_createForOfIteratorHelper","s","n","done","line","preMatch","match","prefix","substr","err","e","f","commonLen","map","join","_this2","_this$props","id","style","className","highlight_config","loading_state","dangerously_allow_html","link_target","mathjax","children","textProp","type","displayText","componentTransforms","dccLink","DccLink","dccMarkdown","Markdown","mergeDeepRight","pick","dashMathjax","Math","node","theme","concat","is_loading","undefined","source","escapeHtml","linkTarget","plugins","RemarkMath","renderers","math","inlineMath","html","JsxParser","jsx","replace","m","tag","src","indexOf","components","renderInWrapper","toString","Object","prototype","module","exports","x","getPrototypeOf","t","require","r","l","c","d","o","defineProperty","enumerable","get","Symbol","toStringTag","__esModule","create","hasOwnProperty","p","ot","q","O","j","ct","Vt","M","R","C","b","E","S","w","Bt","Dt","ut","k","Ut","Mt","strict","strictBind","a","h","RegExp","u","test","String","fromCharCode","label","keyword","beforeExpr","startsExpr","isLoop","isAssign","postfix","binop","updateContext","g","y","v","_","num","regexp","string","name","eof","bracketL","bracketR","braceL","braceR","parenL","parenR","comma","semi","colon","dot","question","arrow","template","invalidTemplate","ellipsis","backQuote","dollarBraceL","eq","assign","incDec","logicalOR","logicalAND","bitwiseOR","bitwiseXOR","bitwiseAND","equality","relational","bitShift","plusMin","modulo","star","slash","starstar","_break","_case","_catch","_continue","_debugger","_default","_do","_else","_finally","_for","_function","_if","_return","_switch","_throw","_try","_var","_const","_while","_with","_new","_class","_extends","_export","_import","_null","_true","_false","_in","_instanceof","_typeof","_void","_delete","A","I","T","P","N","L","Array","isArray","V","column","offset","start","end","sourceFile","lastIndex","exec","index","ecmaVersion","sourceType","onInsertedSemicolon","onTrailingComma","allowReserved","allowReturnOutsideFunction","allowImportExportEverywhere","allowAwaitOutsideFunction","allowHashBang","locations","onToken","onComment","ranges","program","directSourceFile","preserveParens","H","options","push","loc","range","B","keywords","reservedWords","reservedWordsStrict","reservedWordsStrictBind","input","containsEsc","pos","lineStart","lastIndexOf","curLine","slice","startLoc","endLoc","curPosition","lastTokEndLoc","lastTokStartLoc","lastTokStart","lastTokEnd","context","initialContext","exprAllowed","inModule","strictDirective","potentialArrowAt","yieldPos","awaitPos","awaitIdentPos","labels","undefinedExports","skipLineComment","scopeStack","enterScope","regexpState","W","inFunction","configurable","inGenerator","inAsync","allowSuper","allowDirectSuper","treatFunctionsAsVar","parse","startNode","nextToken","parseTopLevel","currentVarScope","flags","currentThisScope","treatFunctionsAsVarInScope","currentScope","inNonArrowFunction","extend","arguments","parseExpressionAt","parseExpression","tokenizer","defineProperties","X","z","J","shorthandAssign","trailingComma","parenthesizedAssign","parenthesizedBind","doubleProto","eat","next","isContextual","eatContextual","expectContextual","unexpected","canInsertSemicolon","insertSemicolon","semicolon","afterTrailingComma","expect","raise","checkPatternErrors","raiseRecoverable","checkExpressionErrors","checkYieldAwaitInDefaultParams","isSimpleAssignTarget","expression","K","body","parseStatement","keys","adaptDirectivePrologue","finishNode","Q","kind","Z","isLet","charCodeAt","isAsyncFunction","charAt","parseBreakContinueStatement","parseDebuggerStatement","parseDoStatement","parseForStatement","parseFunctionStatement","parseClass","parseIfStatement","parseReturnStatement","parseSwitchStatement","parseThrowStatement","parseTryStatement","parseVarStatement","parseWhileStatement","parseWithStatement","parseBlock","parseEmptyStatement","parseExpressionStatement","parseImport","parseExport","parseLabeledStatement","parseIdent","pop","parseParenExpression","parseFor","parseVar","declarations","await","parseForIn","toAssignable","checkLVal","parseFunction","$","tt","consequent","alternate","argument","discriminant","cases","exitScope","Y","block","handler","param","parseBindingAtom","finalizer","object","statementStart","init","update","left","right","parseMaybeAssign","parseVarId","initFunction","generator","async","parseFunctionParams","parseFunctionBody","params","parseBindingList","parseClassId","parseClassSuper","parseClassElement","superClass","computed","startNodeAt","static","parsePropertyName","parseClassMethod","parseMethod","parseExprSubscripts","parseExprAtom","checkExport","declaration","shouldParseExportStatement","checkVariableExport","specifiers","parseExportSpecifiers","checkUnreserved","local","checkLocalExport","checkPatternExport","properties","elements","exported","parseImportSpecifiers","imported","isDirectiveCandidate","directive","raw","et","toAssignableList","operator","parseSpread","parseRestBinding","parseObj","parseBindingListItem","parseMaybeDefault","declareName","it","checkPropClash","method","shorthand","proto","set","expressions","parseYield","parseMaybeConditional","parseExprOps","parseMaybeUnary","parseExprOp","buildBinary","parseAwait","parseSubscripts","parseSubscript","property","parseExprList","parseArrowExpression","callee","quasi","parseTemplate","isTagged","readRegexp","parseLiteral","regex","pattern","parseParenAndDistinguishExpression","parseNew","parseExprImport","parseDynamicImport","bigint","parseParenItem","parseParenArrowList","finishNodeAt","st","meta","parseTemplateElement","cooked","tail","quasis","isAsyncProp","parseProperty","parsePropertyValue","checkParams","isSimpleParamList","delegate","rt","SyntaxError","raisedAt","nt","at","var","lexical","functions","ht","pt","token","isExpr","preserveSpace","override","b_stat","b_expr","b_tmpl","p_stat","p_expr","q_tmpl","tryReadTemplateToken","f_stat","f_expr","f_expr_gen","f_gen","lt","braceIsBlock","curContext","inGeneratorContext","dt","mt","xt","gt","vt","bt","_t","binary","nonBinary","General_Category","Script","Script_Extensions","gc","sc","scx","kt","Et","parser","validFlags","unicodeProperties","switchU","switchN","lastIntValue","lastStringValue","lastAssertionIsQuantifiable","numCapturingParens","maxBackReference","groupNames","backReferenceNames","St","Ct","wt","At","It","Tt","Pt","Nt","Lt","reset","nextIndex","lookahead","advance","validateRegExpFlags","validateRegExpPattern","regexp_pattern","regexp_disjunction","regexp_alternative","regexp_eatQuantifier","regexp_eatTerm","regexp_eatAssertion","regexp_eatAtom","regexp_eatExtendedAtom","regexp_eatQuantifierPrefix","regexp_eatBracedQuantifier","regexp_eatDecimalDigits","regexp_eatPatternCharacters","regexp_eatReverseSolidusAtomEscape","regexp_eatCharacterClass","regexp_eatUncapturingGroup","regexp_eatCapturingGroup","regexp_eatAtomEscape","regexp_groupSpecifier","regexp_eatInvalidBracedQuantifier","regexp_eatExtendedPatternCharacter","regexp_eatSyntaxCharacter","regexp_eatGroupName","regexp_eatRegExpIdentifierName","regexp_eatRegExpIdentifierStart","regexp_eatRegExpIdentifierPart","regexp_eatRegExpUnicodeEscapeSequence","regexp_eatBackReference","regexp_eatCharacterClassEscape","regexp_eatCharacterEscape","regexp_eatKGroupName","regexp_eatDecimalEscape","regexp_eatControlEscape","regexp_eatCControlLetter","regexp_eatZero","regexp_eatHexEscapeSequence","regexp_eatLegacyOctalEscapeSequence","regexp_eatIdentityEscape","regexp_eatControlLetter","regexp_eatFixedHexDigits","regexp_eatHexDigits","regexp_eatUnicodePropertyValueExpression","regexp_eatUnicodePropertyName","regexp_eatUnicodePropertyValue","regexp_validateUnicodePropertyNameAndValue","regexp_eatLoneUnicodePropertyNameOrValue","regexp_validateUnicodePropertyNameOrValue","regexp_classRanges","regexp_eatClassAtom","regexp_eatClassEscape","regexp_eatClassControlLetter","regexp_eatOctalDigit","Ot","jt","getToken","iterator","skipSpace","finishToken","readToken","fullCharCodeAtPos","readWord","getTokenFromCode","skipBlockComment","readToken_dot","readNumber","readToken_slash","finishOp","readToken_mult_modulo_exp","readToken_pipe_amp","readToken_caret","readToken_plus_min","readToken_lt_gt","readToken_eq_excl","readRadixNumber","readString","readWord1","readInt","BigInt","parseInt","parseFloat","readCodePoint","readHexChar","invalidStringToken","readEscapedChar","Rt","inTemplateElement","readTmplToken","readInvalidTemplateToken","acorn","Parser","version","defaultOptions","Position","SourceLocation","getLineInfo","Node","TokenType","tokTypes","keywordTypes","TokContext","tokContexts","isIdentifierChar","isIdentifierStart","Token","isNewLine","lineBreak","lineBreakG","nonASCIIwhitespace","WeakMap","tc_oTag","tc_cTag","tc_expr","jsxName","jsxText","jsxTagStart","jsxTagEnd","namespace","_e","apply","jsx_readEntity","jsx_readNewLine","jsx_parseIdentifier","allowNamespaces","jsx_parseNamespacedName","allowNamespacedObjects","jsx_parseExpressionContainer","jsx_parseEmptyExpression","jsx_parseAttributeValue","attributes","jsx_parseElementName","jsx_parseAttribute","selfClosing","jsx_parseOpeningElementAt","jsx_parseClosingElementAt","jsx_parseElementAt","jsx_parseText","jsx_parseElement","_get","_getPrototypeOf","jsx_readToken","jsx_readWord","jsx_readString","quot","amp","apos","nbsp","iexcl","cent","pound","curren","yen","brvbar","sect","uml","copy","ordf","laquo","not","shy","reg","macr","deg","plusmn","sup2","sup3","acute","micro","para","middot","cedil","sup1","ordm","raquo","frac14","frac12","frac34","iquest","Agrave","Aacute","Acirc","Atilde","Auml","Aring","AElig","Ccedil","Egrave","Eacute","Ecirc","Euml","Igrave","Iacute","Icirc","Iuml","ETH","Ntilde","Ograve","Oacute","Ocirc","Otilde","Ouml","times","Oslash","Ugrave","Uacute","Ucirc","Uuml","Yacute","THORN","szlig","agrave","aacute","acirc","atilde","auml","aring","aelig","ccedil","egrave","eacute","ecirc","euml","igrave","iacute","icirc","iuml","eth","ntilde","ograve","oacute","ocirc","otilde","ouml","divide","oslash","ugrave","uacute","ucirc","uuml","yacute","thorn","yuml","OElig","oelig","Scaron","scaron","Yuml","fnof","circ","tilde","Alpha","Beta","Gamma","Delta","Epsilon","Zeta","Eta","Theta","Iota","Kappa","Lambda","Mu","Nu","Xi","Omicron","Pi","Rho","Sigma","Tau","Upsilon","Phi","Chi","Psi","Omega","alpha","beta","gamma","delta","epsilon","zeta","eta","theta","iota","kappa","lambda","mu","nu","xi","omicron","pi","rho","sigmaf","sigma","tau","upsilon","phi","chi","psi","omega","thetasym","upsih","piv","ensp","emsp","thinsp","zwnj","zwj","lrm","rlm","ndash","mdash","lsquo","rsquo","sbquo","ldquo","rdquo","bdquo","dagger","Dagger","bull","hellip","permil","prime","Prime","lsaquo","rsaquo","oline","frasl","euro","image","weierp","real","trade","alefsym","larr","uarr","rarr","darr","harr","crarr","lArr","uArr","rArr","dArr","hArr","forall","part","exist","empty","nabla","isin","notin","ni","prod","sum","minus","lowast","radic","prop","infin","ang","and","or","cap","cup","int","there4","sim","cong","asymp","ne","equiv","le","ge","sub","sup","nsub","sube","supe","oplus","otimes","perp","sdot","lceil","rceil","lfloor","rfloor","lang","rang","loz","spades","clubs","hearts","diams","class","for","maxlength","colspan","rowspan","forEach","abs","random","filter","reduce","trim","toLowerCase","toUpperCase","showWarnings","console","warn","onError","renderError","error","Boolean","parseElement","disableKeyGeneration","disableFragments","createElement","Fragment","pow","Error","bindings","parseName","allowUnknownElements","componentsOnly","openingElement","blacklistedAttrs","blacklistedTags","document","HTMLUnknownElement","ParsedChildren","parseJSX","xtend","ReactIs","defaultNodePosition","assignDefined","target","attrs","astToReact","parent","renderer","position","isValidElementType","nodeProps","opts","isTagRenderer","sourcePos","flattenPosition","rawSourcePos","sourcePosition","includeNodeIndex","parentChildCount","identifier","definitions","nodeKey","level","depth","ordered","tight","loose","checked","array","child","unwrapParagraphs","getListItemChildren","childNode","title","url","language","href","transformLinkUri","alt","transformImageUri","columnAlignment","align","isHeader","isBlock","skipHtml","parsedChildren","element","el","Children","toArray","cloneElement","mergeNodeChildren","getNodeProps","getDefinitions","defs","visit","untangle","mode","splice","args","ofType","types","disallow","ifNotMatch","allowNode","selfClosingRe","simpleTagRe","tree","open","currentParent","getSelfClosing","opening","getSimpleTag","matching","matchingTag","findAndPull","fromNode","toNode","fromIndex","toIndex","indent","virtual","unified","addListMetadata","naiveHtml","disallowNode","wrapTableRows","uriTransformer","defaultRenderers","symbols","allTypes","ReactMarkdown","parserOptions","allowedTypes","disallowedTypes","applyParserPlugin","rawAst","renderProps","astPlugins","removalMethod","unwrapDisallowed","renderHtml","hasHtmlParser","some","item","identity","HtmlParser","determineAstPlugins","transformedAst","runSync","ast","plugin","use","arr","arr2","_arrayWithoutHoles","iter","from","_iterableToArray","TypeError","_nonIterableSpread","bool","func","arrayOf","oneOf","oneOfType","supportsStringRender","SimpleRenderer","getCoreProps","break","paragraph","emphasis","strong","thematicBreak","blockquote","delete","link","linkReference","imageReference","table","tableHead","tableBody","tableRow","tableCell","textAlign","coreProps","root","useFragment","list","listItem","checkbox","readOnly","definition","heading","inlineCode","code","comp","dangerouslySetInnerHTML","__html","virtualHtml","parsedHtml","protocols","uri","first","protocol","wrap","util","compiler","Compiler","isRemarkParser","blockMethods","interruptParagraph","interruptList","interruptBlockquote","blockTokenizers","silent","content","lineEnd","lineIndex","openingFenceIndentSize","openingFenceSize","openingFenceContentStart","closingFence","closingFenceSize","lineContentStart","lineContentEnd","space","dollarSign","minFenceCount","lineFeed","lineFeedChar","dollarSignChar","data","hName","hProperties","classList","hChildren","attachParser","isRemarkCompiler","visitors","attachCompiler","inlinePlugin","blockPlugin","settings","inlineMethods","mathInlineTokenizer","previous","contentStart","contentEnd","valueEnd","double","escaped","backslash","tab","digit0","digit9","inlineMathDouble","mathDisplay","locator","inlineTokenizers","fence","includes","hasOwn","toStr","gOPD","getOwnPropertyDescriptor","isPlainObject","obj","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","newValue","writable","getProperty","copyIsArray","clone","deep","character","alphabetical","decimal","isBuffer","readFloatLE","isSlowBuffer","_isBuffer","re","fromCode","escapes","defaults","gfm","commonmark","visitWithParents","listNode","parents","characters","char","entity","innerHTML","textContent","legacy","invalid","hexadecimal","alphanumerical","decodeEntity","option","entityCharacters","namedEntity","terminated","reference","following","warning","reason","output","begin","prev","diff","additional","nonTerminated","handleText","handleReference","handleWarning","textContext","referenceContext","warningContext","queue","now","messages","noop","ampersand","formFeed","lessThan","numberSign","uppercaseX","lowercaseX","hexa","deci","tests","own","namedUnknown","namedNotTerminated","namedEmpty","attribute","equalsTo","numericNotTerminated","bases","numericProhibited","replacementCharacter","numericDisallowed","disallowed","numericEmpty","flush","Function","assertPath","path","JSON","stringify","normalizeStringPosix","allowAboveRoot","res","lastSegmentLength","lastSlash","dots","lastSlashIndex","posix","cwd","resolvedPath","resolvedAbsolute","process","normalize","isAbsolute","trailingSeparator","joined","arg","relative","to","fromStart","fromEnd","fromLen","toStart","toLen","lastCommonSep","out","_makeLong","dirname","hasRoot","matchedSlash","basename","ext","extIdx","firstNonSlashEnd","extname","startDot","startPart","preDotState","format","pathObject","sep","dir","base","_format","ret","delimiter","win32","unherit","Local","entities","ctx","decoder","offsets","file","message","footnotes","pedantic","blocks","asterisk","underscore","PROTOCOLS","min","removePosition","self","EXPRESSION_LINE_BREAKS","C_NEWLINE","tokenizeBlock","toggle","vfileLocation","unescape","decode","doc","setOptions","inList","inBlock","inLink","atStart","toOffset","exitStart","enterList","enterLink","enterBlock","newline","indentedCode","fencedCode","atxHeading","setextHeading","footnote","escape","autoLink","deletion","tokenizeInline","tokenizeFactory","whitespace","locate","notInLink","C_LT","C_GT","C_AT_SIGN","C_SLASH","MAILTO","MAILTO_LENGTH","subvalue","hasAtCharacter","tokenizers","exit","interrupt","add","rest","startIndex","prefixed","interruptors","currentLine","values","contents","indents","C_SPACE","C_TAB","hardBreak","MIN_BREAK_LENGTH","fenceCount","marker","flag","exdentedContent","closing","exdentedClosing","C_TILDE","C_TICK","MIN_FENCE_COUNT","CODE_INDENT_COUNT","repeat","blankQueue","subvalueQueue","contentQueue","CODE_INDENT","subqueue","count","openingCount","found","tickQueue","notInList","notInBlock","C_DOUBLE_QUOTE","C_SINGLE_QUOTE","C_BACKSLASH","C_BRACKET_OPEN","C_BRACKET_CLOSE","C_PAREN_OPEN","C_PAREN_CLOSE","C_COLON","beforeURL","beforeTitle","isEnclosedURLCharacter","isUnclosedURLCharacter","strikethrough","DOUBLE","preceding","word","C_ASTERISK","C_UNDERSCORE","footnoteDefinition","C_CARET","EXPRESSION_INITIAL_TAB","C_HASH","MAX_ATX_COUNT","MAX_HEADING_INDENT","SETEXT_MARKERS","openCloseTag","sequence","sequences","inlineHTML","EXPRESSION_HTML_LINK_OPEN","EXPRESSION_HTML_LINK_CLOSE","LINK_MARKERS","COMMONMARK_LINK_MARKERS","closed","hasMarker","markers","isImage","getIndent","removeIndent","currentMarker","prevEmpty","items","allLines","emptyLines","enterTop","exitBlockquote","isLoose","indented","interuptors","size","TAB_SIZE","LIST_ORDERED_COMMONMARK_MARKERS","LIST_ORDERED_MARKERS","LIST_UNORDERED_MARKERS","C_DASH","trail","C_X_LOWER","EXPRESSION_LOOSE_LIST_ITEM","EXPRESSION_TASK_ITEM","EXPRESSION_BULLET","EXPRESSION_PEDANTIC_BULLET","EXPRESSION_INITIAL_INDENT","task","pedanticListItem","normalListItem","replacer","$0","max","bullet","trimmedLines","$1","$2","$3","$4","Number","trimTrailingLines","T_LINK","T_IMAGE","T_FOOTNOTE","REFERENCE_TYPE_SHORTCUT","REFERENCE_TYPE_COLLAPSED","REFERENCE_TYPE_FULL","bracketed","intro","referenceType","alignments","alignment","row","hasDash","cell","preamble","lineCount","rows","pipeIndex","C_PIPE","MIN_TABLE_ROWS","TABLE_ALIGN_NONE","TABLE_ALIGN_LEFT","TABLE_ALIGN_CENTER","TABLE_ALIGN_RIGHT","MIN_TABLE_COLUMNS","methods","fail","markerCount","THEMATIC_BREAK_MARKER_COUNT","MAILTO_PROTOCOL","PROTOCOLS_LENGTH","parenCount","nextCharacter","location","matched","valueLength","tokens","updatePosition","onlyAtStart","before","indentation","last","getOffset","combined","substring","validateEat","MERGEABLE_NODES","mergeable","stops","floor","openTag","closeTag","interruptor","config","fn","ignore","bools","collapseWhiteSpace","maximum","padding","minIndent","Infinity","matrix","unshift","shift","cache","str","npath","nFileName","state","trough","fns","middleware","callback","invoked","inherits","Super","Of","From","parameters","bail","vfile","plain","attachers","transformers","frozen","freezeIndex","processor","assertUnfrozen","freeze","addPlugin","addList","addPreset","entry","find","assertParser","newable","assertCompiler","assertNode","compile","run","complete","assertDone","processSync","destination","transformer","cb","executor","reject","pipeline","asyncName","convert","typeFactory","ok","anyFactory","matchesFactory","checks","results","convertAll","hard","soft","force","point","visitor","stack","one","all","visitParents","CONTINUE","SKIP","EXIT","reverse","is","subresult","toResult","step","positionToOffsetFactory","indices","isNaN","toPosition","VMessagePrototype","VMessage","origin","parts","parseOrigin","ruleId","fatal","buffer","VFile","encoding","order","history","assertPart","assertNonEmpty","stem","filePath","info"],"sourceRoot":""}