{"mappings":"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","names":["Schema","Mark","MarkdownIt","schema","node","dom","m","value","maybeMerge","a","b","MarkdownParseState","tokenHandlers","elt","text","top","nodes","last","merged","mark","toks","i","tok","handler","type","attrs","content","info","spec","token","tokens","noCloseToken","withoutTrailingNewline","str","noOp","handlers","nodeType","state","markType","MarkdownParser","tokenizer","markdownEnv","doc","listIsTight","defaultMarkdownParser","_","blankMark","MarkdownSerializer","marks","options","MarkdownSerializerState","defaultMarkdownSerializer","backticks","fence","_a","start","maxW","space","nStr","parent","index","isPlainURL","inAutolink","_state","_mark","backticksFor","side","ticks","len","result","link","size","delimMin","trim","name","delim","firstDelim","f","old","escape","lines","fromBlockStart","active","trailing","progress","offset","next","inner","noEsc","outer","j","other","keep","leading","lead","rest","trail","add","isTight","prevTight","child","startOfLine","wrap","n","out","open"],"sources":["../esm/npm/prosemirror-markdown@1.13.9/deps-bd7a952899125290df78e9ae28b07b086df03db9fcb88e4d301fd4c0b2f720eb/node_modules/prosemirror-markdown/dist/index.js"],"sourcesContent":["import { Schema, Mark } from 'prosemirror-model';\nimport MarkdownIt from 'markdown-it';\n\n/**\nDocument schema for the data model used by CommonMark.\n*/\nconst schema = new Schema({\n    nodes: {\n        doc: {\n            content: \"block+\"\n        },\n        paragraph: {\n            content: \"inline*\",\n            group: \"block\",\n            parseDOM: [{ tag: \"p\" }],\n            toDOM() { return [\"p\", 0]; }\n        },\n        blockquote: {\n            content: \"block+\",\n            group: \"block\",\n            parseDOM: [{ tag: \"blockquote\" }],\n            toDOM() { return [\"blockquote\", 0]; }\n        },\n        horizontal_rule: {\n            group: \"block\",\n            parseDOM: [{ tag: \"hr\" }],\n            toDOM() { return [\"div\", [\"hr\"]]; }\n        },\n        heading: {\n            attrs: { level: { default: 1, validate: \"number\" } },\n            content: \"(text | image)*\",\n            group: \"block\",\n            defining: true,\n            parseDOM: [{ tag: \"h1\", attrs: { level: 1 } },\n                { tag: \"h2\", attrs: { level: 2 } },\n                { tag: \"h3\", attrs: { level: 3 } },\n                { tag: \"h4\", attrs: { level: 4 } },\n                { tag: \"h5\", attrs: { level: 5 } },\n                { tag: \"h6\", attrs: { level: 6 } }],\n            toDOM(node) { return [\"h\" + +node.attrs.level, 0]; }\n        },\n        code_block: {\n            content: \"text*\",\n            group: \"block\",\n            code: true,\n            defining: true,\n            marks: \"\",\n            attrs: { params: { default: \"\" } },\n            parseDOM: [{ tag: \"pre\", preserveWhitespace: \"full\", getAttrs: node =\u003e ({ params: node.getAttribute(\"data-params\") || \"\" }) }],\n            toDOM(node) { return [\"pre\", node.attrs.params ? { \"data-params\": node.attrs.params } : {}, [\"code\", 0]]; }\n        },\n        ordered_list: {\n            content: \"list_item+\",\n            group: \"block\",\n            attrs: { order: { default: 1 }, tight: { default: false } },\n            parseDOM: [{ tag: \"ol\", getAttrs(dom) {\n                        return { order: dom.hasAttribute(\"start\") ? +dom.getAttribute(\"start\") : 1,\n                            tight: dom.hasAttribute(\"data-tight\") };\n                    } }],\n            toDOM(node) {\n                return [\"ol\", { start: node.attrs.order == 1 ? null : node.attrs.order,\n                        \"data-tight\": node.attrs.tight ? \"true\" : null }, 0];\n            }\n        },\n        bullet_list: {\n            content: \"list_item+\",\n            group: \"block\",\n            attrs: { tight: { default: false } },\n            parseDOM: [{ tag: \"ul\", getAttrs: dom =\u003e ({ tight: dom.hasAttribute(\"data-tight\") }) }],\n            toDOM(node) { return [\"ul\", { \"data-tight\": node.attrs.tight ? \"true\" : null }, 0]; }\n        },\n        list_item: {\n            content: \"block+\",\n            defining: true,\n            parseDOM: [{ tag: \"li\" }],\n            toDOM() { return [\"li\", 0]; }\n        },\n        text: {\n            group: \"inline\"\n        },\n        image: {\n            inline: true,\n            attrs: {\n                src: {},\n                alt: { default: null },\n                title: { default: null }\n            },\n            group: \"inline\",\n            draggable: true,\n            parseDOM: [{ tag: \"img[src]\", getAttrs(dom) {\n                        return {\n                            src: dom.getAttribute(\"src\"),\n                            title: dom.getAttribute(\"title\"),\n                            alt: dom.getAttribute(\"alt\")\n                        };\n                    } }],\n            toDOM(node) { return [\"img\", node.attrs]; }\n        },\n        hard_break: {\n            inline: true,\n            group: \"inline\",\n            selectable: false,\n            parseDOM: [{ tag: \"br\" }],\n            toDOM() { return [\"br\"]; }\n        }\n    },\n    marks: {\n        em: {\n            parseDOM: [\n                { tag: \"i\" }, { tag: \"em\" },\n                { style: \"font-style=italic\" },\n                { style: \"font-style=normal\", clearMark: m =\u003e m.type.name == \"em\" }\n            ],\n            toDOM() { return [\"em\"]; }\n        },\n        strong: {\n            parseDOM: [\n                { tag: \"strong\" },\n                { tag: \"b\", getAttrs: node =\u003e node.style.fontWeight != \"normal\" \u0026\u0026 null },\n                { style: \"font-weight=400\", clearMark: m =\u003e m.type.name == \"strong\" },\n                { style: \"font-weight\", getAttrs: value =\u003e /^(bold(er)?|[5-9]\\d{2,})$/.test(value) \u0026\u0026 null }\n            ],\n            toDOM() { return [\"strong\"]; }\n        },\n        link: {\n            attrs: {\n                href: {},\n                title: { default: null }\n            },\n            inclusive: false,\n            parseDOM: [{ tag: \"a[href]\", getAttrs(dom) {\n                        return { href: dom.getAttribute(\"href\"), title: dom.getAttribute(\"title\") };\n                    } }],\n            toDOM(node) { return [\"a\", node.attrs]; }\n        },\n        code: {\n            code: true,\n            parseDOM: [{ tag: \"code\" }],\n            toDOM() { return [\"code\"]; }\n        }\n    }\n});\n\n// @ts-ignore\nfunction maybeMerge(a, b) {\n    if (a.isText \u0026\u0026 b.isText \u0026\u0026 Mark.sameSet(a.marks, b.marks))\n        return a.withText(a.text + b.text);\n}\n// Object used to track the context of a running parse.\nclass MarkdownParseState {\n    constructor(schema, tokenHandlers) {\n        this.schema = schema;\n        this.tokenHandlers = tokenHandlers;\n        this.stack = [{ type: schema.topNodeType, attrs: null, content: [], marks: Mark.none }];\n    }\n    top() {\n        return this.stack[this.stack.length - 1];\n    }\n    push(elt) {\n        if (this.stack.length)\n            this.top().content.push(elt);\n    }\n    // Adds the given text to the current position in the document,\n    // using the current marks as styling.\n    addText(text) {\n        if (!text)\n            return;\n        let top = this.top(), nodes = top.content, last = nodes[nodes.length - 1];\n        let node = this.schema.text(text, top.marks), merged;\n        if (last \u0026\u0026 (merged = maybeMerge(last, node)))\n            nodes[nodes.length - 1] = merged;\n        else\n            nodes.push(node);\n    }\n    // Adds the given mark to the set of active marks.\n    openMark(mark) {\n        let top = this.top();\n        top.marks = mark.addToSet(top.marks);\n    }\n    // Removes the given mark from the set of active marks.\n    closeMark(mark) {\n        let top = this.top();\n        top.marks = mark.removeFromSet(top.marks);\n    }\n    parseTokens(toks) {\n        for (let i = 0; i \u003c toks.length; i++) {\n            let tok = toks[i];\n            let handler = this.tokenHandlers[tok.type];\n            if (!handler)\n                throw new Error(\"Token type `\" + tok.type + \"` not supported by Markdown parser\");\n            handler(this, tok, toks, i);\n        }\n    }\n    // Add a node at the current position.\n    addNode(type, attrs, content) {\n        let top = this.top();\n        let node = type.createAndFill(attrs, content, top ? top.marks : []);\n        if (!node)\n            return null;\n        this.push(node);\n        return node;\n    }\n    // Wrap subsequent content in a node of the given type.\n    openNode(type, attrs) {\n        this.stack.push({ type: type, attrs: attrs, content: [], marks: Mark.none });\n    }\n    // Close and return the node that is currently on top of the stack.\n    closeNode() {\n        let info = this.stack.pop();\n        return this.addNode(info.type, info.attrs, info.content);\n    }\n}\nfunction attrs(spec, token, tokens, i) {\n    if (spec.getAttrs)\n        return spec.getAttrs(token, tokens, i);\n    // For backwards compatibility when `attrs` is a Function\n    else if (spec.attrs instanceof Function)\n        return spec.attrs(token);\n    else\n        return spec.attrs;\n}\n// Code content is represented as a single token with a `content`\n// property in Markdown-it.\nfunction noCloseToken(spec, type) {\n    return spec.noCloseToken || type == \"code_inline\" || type == \"code_block\" || type == \"fence\";\n}\nfunction withoutTrailingNewline(str) {\n    return str[str.length - 1] == \"\\n\" ? str.slice(0, str.length - 1) : str;\n}\nfunction noOp() { }\nfunction tokenHandlers(schema, tokens) {\n    let handlers = Object.create(null);\n    for (let type in tokens) {\n        let spec = tokens[type];\n        if (spec.block) {\n            let nodeType = schema.nodeType(spec.block);\n            if (noCloseToken(spec, type)) {\n                handlers[type] = (state, tok, tokens, i) =\u003e {\n                    state.openNode(nodeType, attrs(spec, tok, tokens, i));\n                    state.addText(withoutTrailingNewline(tok.content));\n                    state.closeNode();\n                };\n            }\n            else {\n                handlers[type + \"_open\"] = (state, tok, tokens, i) =\u003e state.openNode(nodeType, attrs(spec, tok, tokens, i));\n                handlers[type + \"_close\"] = state =\u003e state.closeNode();\n            }\n        }\n        else if (spec.node) {\n            let nodeType = schema.nodeType(spec.node);\n            handlers[type] = (state, tok, tokens, i) =\u003e state.addNode(nodeType, attrs(spec, tok, tokens, i));\n        }\n        else if (spec.mark) {\n            let markType = schema.marks[spec.mark];\n            if (noCloseToken(spec, type)) {\n                handlers[type] = (state, tok, tokens, i) =\u003e {\n                    state.openMark(markType.create(attrs(spec, tok, tokens, i)));\n                    state.addText(withoutTrailingNewline(tok.content));\n                    state.closeMark(markType);\n                };\n            }\n            else {\n                handlers[type + \"_open\"] = (state, tok, tokens, i) =\u003e state.openMark(markType.create(attrs(spec, tok, tokens, i)));\n                handlers[type + \"_close\"] = state =\u003e state.closeMark(markType);\n            }\n        }\n        else if (spec.ignore) {\n            if (noCloseToken(spec, type)) {\n                handlers[type] = noOp;\n            }\n            else {\n                handlers[type + \"_open\"] = noOp;\n                handlers[type + \"_close\"] = noOp;\n            }\n        }\n        else {\n            throw new RangeError(\"Unrecognized parsing spec \" + JSON.stringify(spec));\n        }\n    }\n    handlers.text = (state, tok) =\u003e state.addText(tok.content);\n    handlers.inline = (state, tok) =\u003e state.parseTokens(tok.children);\n    handlers.softbreak = handlers.softbreak || (state =\u003e state.addText(\" \"));\n    return handlers;\n}\n/**\nA configuration of a Markdown parser. Such a parser uses\n[markdown-it](https://github.com/markdown-it/markdown-it) to\ntokenize a file, and then runs the custom rules it is given over\nthe tokens to create a ProseMirror document tree.\n*/\nclass MarkdownParser {\n    /**\n    Create a parser with the given configuration. You can configure\n    the markdown-it parser to parse the dialect you want, and provide\n    a description of the ProseMirror entities those tokens map to in\n    the `tokens` object, which maps token names to descriptions of\n    what to do with them. Such a description is an object, and may\n    have the following properties:\n    */\n    constructor(\n    /**\n    The parser's document schema.\n    */\n    schema, \n    /**\n    This parser's markdown-it tokenizer.\n    */\n    tokenizer, \n    /**\n    The value of the `tokens` object used to construct this\n    parser. Can be useful to copy and modify to base other parsers\n    on.\n    */\n    tokens) {\n        this.schema = schema;\n        this.tokenizer = tokenizer;\n        this.tokens = tokens;\n        this.tokenHandlers = tokenHandlers(schema, tokens);\n    }\n    /**\n    Parse a string as [CommonMark](http://commonmark.org/) markup,\n    and create a ProseMirror document as prescribed by this parser's\n    rules.\n    \n    The second argument, when given, is passed through to the\n    [Markdown\n    parser](https://markdown-it.github.io/markdown-it/#MarkdownIt.parse).\n    */\n    parse(text, markdownEnv = {}) {\n        let state = new MarkdownParseState(this.schema, this.tokenHandlers), doc;\n        state.parseTokens(this.tokenizer.parse(text, markdownEnv));\n        do {\n            doc = state.closeNode();\n        } while (state.stack.length);\n        return doc || this.schema.topNodeType.createAndFill();\n    }\n}\nfunction listIsTight(tokens, i) {\n    while (++i \u003c tokens.length)\n        if (tokens[i].type != \"list_item_open\")\n            return tokens[i].hidden;\n    return false;\n}\n/**\nA parser parsing unextended [CommonMark](http://commonmark.org/),\nwithout inline HTML, and producing a document in the basic schema.\n*/\nconst defaultMarkdownParser = new MarkdownParser(schema, MarkdownIt(\"commonmark\", { html: false }), {\n    blockquote: { block: \"blockquote\" },\n    paragraph: { block: \"paragraph\" },\n    list_item: { block: \"list_item\" },\n    bullet_list: { block: \"bullet_list\", getAttrs: (_, tokens, i) =\u003e ({ tight: listIsTight(tokens, i) }) },\n    ordered_list: { block: \"ordered_list\", getAttrs: (tok, tokens, i) =\u003e ({\n            order: +tok.attrGet(\"start\") || 1,\n            tight: listIsTight(tokens, i)\n        }) },\n    heading: { block: \"heading\", getAttrs: tok =\u003e ({ level: +tok.tag.slice(1) }) },\n    code_block: { block: \"code_block\", noCloseToken: true },\n    fence: { block: \"code_block\", getAttrs: tok =\u003e ({ params: tok.info || \"\" }), noCloseToken: true },\n    hr: { node: \"horizontal_rule\" },\n    image: { node: \"image\", getAttrs: tok =\u003e ({\n            src: tok.attrGet(\"src\"),\n            title: tok.attrGet(\"title\") || null,\n            alt: tok.children[0] \u0026\u0026 tok.children[0].content || null\n        }) },\n    hardbreak: { node: \"hard_break\" },\n    em: { mark: \"em\" },\n    strong: { mark: \"strong\" },\n    link: { mark: \"link\", getAttrs: tok =\u003e ({\n            href: tok.attrGet(\"href\"),\n            title: tok.attrGet(\"title\") || null\n        }) },\n    code_inline: { mark: \"code\", noCloseToken: true }\n});\n\nconst blankMark = { open: \"\", close: \"\", mixable: true };\n/**\nA specification for serializing a ProseMirror document as\nMarkdown/CommonMark text.\n*/\nclass MarkdownSerializer {\n    /**\n    Construct a serializer with the given configuration. The `nodes`\n    object should map node names in a given schema to function that\n    take a serializer state and such a node, and serialize the node.\n    */\n    constructor(\n    /**\n    The node serializer functions for this serializer.\n    */\n    nodes, \n    /**\n    The mark serializer info.\n    */\n    marks, options = {}) {\n        this.nodes = nodes;\n        this.marks = marks;\n        this.options = options;\n    }\n    /**\n    Serialize the content of the given node to\n    [CommonMark](http://commonmark.org/).\n    */\n    serialize(content, options = {}) {\n        options = Object.assign({}, this.options, options);\n        let state = new MarkdownSerializerState(this.nodes, this.marks, options);\n        state.renderContent(content);\n        return state.out;\n    }\n}\n/**\nA serializer for the [basic schema](https://prosemirror.net/docs/ref/#schema).\n*/\nconst defaultMarkdownSerializer = new MarkdownSerializer({\n    blockquote(state, node) {\n        state.wrapBlock(\"\u003e \", null, node, () =\u003e state.renderContent(node));\n    },\n    code_block(state, node) {\n        // Make sure the front matter fences are longer than any dash sequence within it\n        const backticks = node.textContent.match(/`{3,}/gm);\n        const fence = backticks ? (backticks.sort().slice(-1)[0] + \"`\") : \"```\";\n        state.write(fence + (node.attrs.params || \"\") + \"\\n\");\n        state.text(node.textContent, false);\n        // Add a newline to the current content before adding closing marker\n        state.write(\"\\n\");\n        state.write(fence);\n        state.closeBlock(node);\n    },\n    heading(state, node) {\n        state.write(state.repeat(\"#\", node.attrs.level) + \" \");\n        state.renderInline(node, false);\n        state.closeBlock(node);\n    },\n    horizontal_rule(state, node) {\n        state.write(node.attrs.markup || \"---\");\n        state.closeBlock(node);\n    },\n    bullet_list(state, node) {\n        state.renderList(node, \"  \", () =\u003e (node.attrs.bullet || \"*\") + \" \");\n    },\n    ordered_list(state, node) {\n        var _a;\n        let start = (_a = node.attrs.order) !== null \u0026\u0026 _a !== void 0 ? _a : 1;\n        let maxW = String(start + node.childCount - 1).length;\n        let space = state.repeat(\" \", maxW + 2);\n        state.renderList(node, space, i =\u003e {\n            let nStr = String(start + i);\n            return state.repeat(\" \", maxW - nStr.length) + nStr + \". \";\n        });\n    },\n    list_item(state, node) {\n        state.renderContent(node);\n    },\n    paragraph(state, node) {\n        state.renderInline(node);\n        state.closeBlock(node);\n    },\n    image(state, node) {\n        state.write(\"![\" + state.esc(node.attrs.alt || \"\") + \"](\" + node.attrs.src.replace(/[\\(\\)]/g, \"\\\\$\u0026\") +\n            (node.attrs.title ? ' \"' + node.attrs.title.replace(/\"/g, '\\\\\"') + '\"' : \"\") + \")\");\n    },\n    hard_break(state, node, parent, index) {\n        for (let i = index + 1; i \u003c parent.childCount; i++)\n            if (parent.child(i).type != node.type) {\n                state.write(\"\\\\\\n\");\n                return;\n            }\n    },\n    text(state, node) {\n        state.text(node.text, !state.inAutolink);\n    }\n}, {\n    em: { open: \"*\", close: \"*\", mixable: true, expelEnclosingWhitespace: true },\n    strong: { open: \"**\", close: \"**\", mixable: true, expelEnclosingWhitespace: true },\n    link: {\n        open(state, mark, parent, index) {\n            state.inAutolink = isPlainURL(mark, parent, index);\n            return state.inAutolink ? \"\u003c\" : \"[\";\n        },\n        close(state, mark, parent, index) {\n            let { inAutolink } = state;\n            state.inAutolink = undefined;\n            return inAutolink ? \"\u003e\"\n                : \"](\" + mark.attrs.href.replace(/[\\(\\)\"]/g, \"\\\\$\u0026\") + (mark.attrs.title ? ` \"${mark.attrs.title.replace(/\"/g, '\\\\\"')}\"` : \"\") + \")\";\n        },\n        mixable: true\n    },\n    code: { open(_state, _mark, parent, index) { return backticksFor(parent.child(index), -1); },\n        close(_state, _mark, parent, index) { return backticksFor(parent.child(index - 1), 1); },\n        escape: false }\n});\nfunction backticksFor(node, side) {\n    let ticks = /`+/g, m, len = 0;\n    if (node.isText)\n        while (m = ticks.exec(node.text))\n            len = Math.max(len, m[0].length);\n    let result = len \u003e 0 \u0026\u0026 side \u003e 0 ? \" `\" : \"`\";\n    for (let i = 0; i \u003c len; i++)\n        result += \"`\";\n    if (len \u003e 0 \u0026\u0026 side \u003c 0)\n        result += \" \";\n    return result;\n}\nfunction isPlainURL(link, parent, index) {\n    if (link.attrs.title || !/^\\w+:/.test(link.attrs.href))\n        return false;\n    let content = parent.child(index);\n    if (!content.isText || content.text != link.attrs.href || content.marks[content.marks.length - 1] != link)\n        return false;\n    return index == parent.childCount - 1 || !link.isInSet(parent.child(index + 1).marks);\n}\n/**\nThis is an object used to track state and expose\nmethods related to markdown serialization. Instances are passed to\nnode and mark serialization methods (see `toMarkdown`).\n*/\nclass MarkdownSerializerState {\n    /**\n    @internal\n    */\n    constructor(\n    /**\n    @internal\n    */\n    nodes, \n    /**\n    @internal\n    */\n    marks, \n    /**\n    The options passed to the serializer.\n    */\n    options) {\n        this.nodes = nodes;\n        this.marks = marks;\n        this.options = options;\n        /**\n        @internal\n        */\n        this.delim = \"\";\n        /**\n        @internal\n        */\n        this.out = \"\";\n        /**\n        @internal\n        */\n        this.closed = null;\n        /**\n        @internal\n        */\n        this.inAutolink = undefined;\n        /**\n        @internal\n        */\n        this.atBlockStart = false;\n        /**\n        @internal\n        */\n        this.inTightList = false;\n        if (typeof this.options.tightLists == \"undefined\")\n            this.options.tightLists = false;\n        if (typeof this.options.hardBreakNodeName == \"undefined\")\n            this.options.hardBreakNodeName = \"hard_break\";\n    }\n    /**\n    @internal\n    */\n    flushClose(size = 2) {\n        if (this.closed) {\n            if (!this.atBlank())\n                this.out += \"\\n\";\n            if (size \u003e 1) {\n                let delimMin = this.delim;\n                let trim = /\\s+$/.exec(delimMin);\n                if (trim)\n                    delimMin = delimMin.slice(0, delimMin.length - trim[0].length);\n                for (let i = 1; i \u003c size; i++)\n                    this.out += delimMin + \"\\n\";\n            }\n            this.closed = null;\n        }\n    }\n    /**\n    @internal\n    */\n    getMark(name) {\n        let info = this.marks[name];\n        if (!info) {\n            if (this.options.strict !== false)\n                throw new Error(`Mark type \\`${name}\\` not supported by Markdown renderer`);\n            info = blankMark;\n        }\n        return info;\n    }\n    /**\n    Render a block, prefixing each line with `delim`, and the first\n    line in `firstDelim`. `node` should be the node that is closed at\n    the end of the block, and `f` is a function that renders the\n    content of the block.\n    */\n    wrapBlock(delim, firstDelim, node, f) {\n        let old = this.delim;\n        this.write(firstDelim != null ? firstDelim : delim);\n        this.delim += delim;\n        f();\n        this.delim = old;\n        this.closeBlock(node);\n    }\n    /**\n    @internal\n    */\n    atBlank() {\n        return !this.out || this.out[this.out.length - 1] == \"\\n\";\n    }\n    /**\n    Ensure the current content ends with a newline.\n    */\n    ensureNewLine() {\n        if (!this.atBlank())\n            this.out += \"\\n\";\n    }\n    /**\n    Prepare the state for writing output (closing closed paragraphs,\n    adding delimiters, and so on), and then optionally add content\n    (unescaped) to the output.\n    */\n    write(content) {\n        this.flushClose();\n        if (this.delim \u0026\u0026 this.atBlank())\n            this.out += this.delim;\n        if (content)\n            this.out += content;\n    }\n    /**\n    Close the block for the given node.\n    */\n    closeBlock(node) {\n        this.closed = node;\n    }\n    /**\n    Add the given text to the document. When escape is not `false`,\n    it will be escaped.\n    */\n    text(text, escape = true) {\n        let lines = text.split(\"\\n\");\n        for (let i = 0; i \u003c lines.length; i++) {\n            this.write();\n            // Escape exclamation marks in front of links\n            if (!escape \u0026\u0026 lines[i][0] == \"[\" \u0026\u0026 /(^|[^\\\\])\\!$/.test(this.out.slice(-2)))\n                this.out = this.out.slice(0, this.out.length - 1) + \"\\\\!\";\n            this.out += escape ? this.esc(lines[i], this.atBlockStart) : lines[i];\n            if (i != lines.length - 1)\n                this.out += \"\\n\";\n        }\n    }\n    /**\n    Render the given node as a block.\n    */\n    render(node, parent, index) {\n        if (this.nodes[node.type.name]) {\n            this.nodes[node.type.name](this, node, parent, index);\n        }\n        else {\n            if (this.options.strict !== false) {\n                throw new Error(\"Token type `\" + node.type.name + \"` not supported by Markdown renderer\");\n            }\n            else if (!node.type.isLeaf) {\n                if (node.type.inlineContent)\n                    this.renderInline(node);\n                else\n                    this.renderContent(node);\n                if (node.isBlock)\n                    this.closeBlock(node);\n            }\n        }\n    }\n    /**\n    Render the contents of `parent` as block nodes.\n    */\n    renderContent(parent) {\n        parent.forEach((node, _, i) =\u003e this.render(node, parent, i));\n    }\n    /**\n    Render the contents of `parent` as inline content.\n    */\n    renderInline(parent, fromBlockStart = true) {\n        this.atBlockStart = fromBlockStart;\n        let active = [], trailing = \"\";\n        let progress = (node, offset, index) =\u003e {\n            let marks = node ? node.marks : [];\n            // Remove marks from `hard_break` that are the last node inside\n            // that mark to prevent parser edge cases with new lines just\n            // before closing marks.\n            if (node \u0026\u0026 node.type.name === this.options.hardBreakNodeName)\n                marks = marks.filter(m =\u003e {\n                    if (index + 1 == parent.childCount)\n                        return false;\n                    let next = parent.child(index + 1);\n                    return m.isInSet(next.marks) \u0026\u0026 (!next.isText || /\\S/.test(next.text));\n                });\n            let inner = marks.length ? marks[marks.length - 1] : null;\n            let noEsc = inner \u0026\u0026 this.getMark(inner.type.name).escape === false;\n            let len = marks.length - (noEsc ? 1 : 0);\n            // Try to reorder 'mixable' marks, such as em and strong, which\n            // in Markdown may be opened and closed in different order, so\n            // that order of the marks for the token matches the order in\n            // active.\n            outer: for (let i = 0; i \u003c len; i++) {\n                let mark = marks[i];\n                if (!this.getMark(mark.type.name).mixable)\n                    break;\n                for (let j = 0; j \u003c active.length; j++) {\n                    let other = active[j];\n                    if (!this.getMark(other.type.name).mixable)\n                        break;\n                    if (mark.eq(other)) {\n                        if (i \u003e j)\n                            marks = marks.slice(0, j).concat(mark).concat(marks.slice(j, i)).concat(marks.slice(i + 1, len));\n                        else if (j \u003e i)\n                            marks = marks.slice(0, i).concat(marks.slice(i + 1, j)).concat(mark).concat(marks.slice(j, len));\n                        continue outer;\n                    }\n                }\n            }\n            // Find the prefix of the mark set that didn't change\n            let keep = 0;\n            while (keep \u003c Math.min(active.length, len) \u0026\u0026 marks[keep].eq(active[keep]))\n                ++keep;\n            let leading = trailing;\n            trailing = \"\";\n            // If whitespace has to be expelled from the node, adjust\n            // leading and trailing accordingly.\n            if (node \u0026\u0026 node.isText \u0026\u0026 marks.some(mark =\u003e {\n                let info = this.getMark(mark.type.name);\n                return info \u0026\u0026 info.expelEnclosingWhitespace \u0026\u0026 !active.some((m, i) =\u003e i \u003c keep \u0026\u0026 m.eq(mark));\n            })) {\n                let [_, lead, rest] = /^(\\s*)(.*)$/m.exec(node.text);\n                if (lead) {\n                    leading += lead;\n                    node = rest ? node.withText(rest) : null;\n                    if (!node)\n                        marks = active;\n                }\n            }\n            if (node \u0026\u0026 node.isText \u0026\u0026 marks.some((mark, i) =\u003e {\n                let info = this.getMark(mark.type.name);\n                return info \u0026\u0026 info.expelEnclosingWhitespace \u0026\u0026 !this.isMarkAhead(parent, index + 1, marks.slice(0, i + 1));\n            })) {\n                let [_, rest, trail] = /^(.*?)(\\s*)$/m.exec(node.text);\n                if (trail) {\n                    trailing = trail;\n                    node = rest ? node.withText(rest) : null;\n                    if (!node)\n                        marks = active;\n                }\n            }\n            // Close the marks that need to be closed\n            if (node || index == parent.childCount)\n                while (keep \u003c active.length)\n                    this.text(this.markString(active.pop(), false, parent, index), false);\n            // Output any previously expelled trailing whitespace outside the marks\n            if (leading)\n                this.text(leading);\n            // Open the marks that need to be opened\n            if (node) {\n                while (active.length \u003c len) {\n                    let add = marks[active.length];\n                    active.push(add);\n                    this.text(this.markString(add, true, parent, index), false);\n                    this.atBlockStart = false;\n                }\n                // Render the node. Special case code marks, since their content\n                // may not be escaped.\n                if (noEsc \u0026\u0026 node.isText)\n                    this.text(this.markString(inner, true, parent, index) + node.text +\n                        this.markString(inner, false, parent, index + 1), false);\n                else\n                    this.render(node, parent, index);\n                this.atBlockStart = false;\n                // After the first non-empty text node is rendered, the end of output\n                // is no longer at block start.\n                //\n                // FIXME: If a non-text node writes something to the output for this\n                // block, the end of output is also no longer at block start. But how\n                // can we detect that?\n                if (node.isText \u0026\u0026 node.nodeSize \u003e 0)\n                    this.atBlockStart = false;\n            }\n        };\n        parent.forEach(progress);\n        progress(null, 0, parent.childCount);\n        this.atBlockStart = false;\n    }\n    /**\n    Render a node's content as a list. `delim` should be the extra\n    indentation added to all lines except the first in an item,\n    `firstDelim` is a function going from an item index to a\n    delimiter for the first line of the item.\n    */\n    renderList(node, delim, firstDelim) {\n        if (this.closed \u0026\u0026 this.closed.type == node.type)\n            this.flushClose(3);\n        else if (this.inTightList)\n            this.flushClose(1);\n        let isTight = typeof node.attrs.tight != \"undefined\" ? node.attrs.tight : this.options.tightLists;\n        let prevTight = this.inTightList;\n        this.inTightList = isTight;\n        node.forEach((child, _, i) =\u003e {\n            if (i \u0026\u0026 isTight)\n                this.flushClose(1);\n            this.wrapBlock(delim, firstDelim(i), node, () =\u003e this.render(child, node, i));\n        });\n        this.inTightList = prevTight;\n    }\n    /**\n    Escape the given string so that it can safely appear in Markdown\n    content. If `startOfLine` is true, also escape characters that\n    have special meaning only at the start of the line.\n    */\n    esc(str, startOfLine = false) {\n        str = str.replace(/[`*\\\\~\\[\\]_]/g, (m, i) =\u003e m == \"_\" \u0026\u0026 i \u003e 0 \u0026\u0026 i + 1 \u003c str.length \u0026\u0026 str[i - 1].match(/\\w/) \u0026\u0026 str[i + 1].match(/\\w/) ? m : \"\\\\\" + m);\n        if (startOfLine)\n            str = str.replace(/^(\\+[ ]|[\\-*\u003e])/, \"\\\\$\u0026\").replace(/^(\\s*)(#{1,6})(\\s|$)/, '$1\\\\$2$3').replace(/^(\\s*\\d+)\\.\\s/, \"$1\\\\. \");\n        if (this.options.escapeExtraCharacters)\n            str = str.replace(this.options.escapeExtraCharacters, \"\\\\$\u0026\");\n        return str;\n    }\n    /**\n    @internal\n    */\n    quote(str) {\n        let wrap = str.indexOf('\"') == -1 ? '\"\"' : str.indexOf(\"'\") == -1 ? \"''\" : \"()\";\n        return wrap[0] + str + wrap[1];\n    }\n    /**\n    Repeat the given string `n` times.\n    */\n    repeat(str, n) {\n        let out = \"\";\n        for (let i = 0; i \u003c n; i++)\n            out += str;\n        return out;\n    }\n    /**\n    Get the markdown string for a given opening or closing mark.\n    */\n    markString(mark, open, parent, index) {\n        let info = this.getMark(mark.type.name);\n        let value = open ? info.open : info.close;\n        return typeof value == \"string\" ? value : value(this, mark, parent, index);\n    }\n    /**\n    Get leading and trailing whitespace from a string. Values of\n    leading or trailing property of the return object will be undefined\n    if there is no match.\n    */\n    getEnclosingWhitespace(text) {\n        return {\n            leading: (text.match(/^(\\s+)/) || [undefined])[0],\n            trailing: (text.match(/(\\s+)$/) || [undefined])[0]\n        };\n    }\n    /**\n    @internal\n    */\n    isMarkAhead(parent, index, marks) {\n        for (;; index++) {\n            if (index \u003e= parent.childCount)\n                return false;\n            let next = parent.child(index);\n            if (next.type.name != this.options.hardBreakNodeName) {\n                return next.marks.length \u003e= marks.length \u0026\u0026 Mark.sameSet(next.marks.slice(0, marks.length), marks);\n            }\n            index++;\n        }\n    }\n}\n\nexport { MarkdownParser, MarkdownSerializer, MarkdownSerializerState, defaultMarkdownParser, defaultMarkdownSerializer, schema };\n"],"version":3}
