@vc-shell/framework 2.0.0-alpha.8 → 2.0.0-pr221.637b802

package/dist/chunks/vendor-prosemirror-markdown-rpUTSG_Q.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor-prosemirror-markdown-rpUTSG_Q.js","sources":["../../../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 } },\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 => ({ 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 => ({ 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 => m.type.name == \"em\" }\n            ],\n            toDOM() { return [\"em\"]; }\n        },\n        strong: {\n            parseDOM: [\n                { tag: \"strong\" },\n                { tag: \"b\", getAttrs: node => node.style.fontWeight != \"normal\" && null },\n                { style: \"font-weight=400\", clearMark: m => m.type.name == \"strong\" },\n                { style: \"font-weight\", getAttrs: value => /^(bold(er)?|[5-9]\\d{2,})$/.test(value) && 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 && b.isText && 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 && (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 < 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) => {\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) => state.openNode(nodeType, attrs(spec, tok, tokens, i));\n                handlers[type + \"_close\"] = state => state.closeNode();\n            }\n        }\n        else if (spec.node) {\n            let nodeType = schema.nodeType(spec.node);\n            handlers[type] = (state, tok, tokens, i) => 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) => {\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) => state.openMark(markType.create(attrs(spec, tok, tokens, i)));\n                handlers[type + \"_close\"] = state => 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) => state.addText(tok.content);\n    handlers.inline = (state, tok) => state.parseTokens(tok.children);\n    handlers.softbreak = handlers.softbreak || (state => 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 < 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) => ({ tight: listIsTight(tokens, i) }) },\n    ordered_list: { block: \"ordered_list\", getAttrs: (tok, tokens, i) => ({\n            order: +tok.attrGet(\"start\") || 1,\n            tight: listIsTight(tokens, i)\n        }) },\n    heading: { block: \"heading\", getAttrs: tok => ({ level: +tok.tag.slice(1) }) },\n    code_block: { block: \"code_block\", noCloseToken: true },\n    fence: { block: \"code_block\", getAttrs: tok => ({ params: tok.info || \"\" }), noCloseToken: true },\n    hr: { node: \"horizontal_rule\" },\n    image: { node: \"image\", getAttrs: tok => ({\n            src: tok.attrGet(\"src\"),\n            title: tok.attrGet(\"title\") || null,\n            alt: tok.children[0] && 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 => ({\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(\"> \", null, node, () => 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, \"  \", () => (node.attrs.bullet || \"*\") + \" \");\n    },\n    ordered_list(state, node) {\n        let start = node.attrs.order || 1;\n        let maxW = String(start + node.childCount - 1).length;\n        let space = state.repeat(\" \", maxW + 2);\n        state.renderList(node, space, i => {\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, \"\\\\$&\") +\n            (node.attrs.title ? ' \"' + node.attrs.title.replace(/\"/g, '\\\\\"') + '\"' : \"\") + \")\");\n    },\n    hard_break(state, node, parent, index) {\n        for (let i = index + 1; i < 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 ? \"<\" : \"[\";\n        },\n        close(state, mark, parent, index) {\n            let { inAutolink } = state;\n            state.inAutolink = undefined;\n            return inAutolink ? \">\"\n                : \"](\" + mark.attrs.href.replace(/[\\(\\)\"]/g, \"\\\\$&\") + (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 > 0 && side > 0 ? \" `\" : \"`\";\n    for (let i = 0; i < len; i++)\n        result += \"`\";\n    if (len > 0 && side < 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 > 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 < 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 /(^|\\n)$/.test(this.out);\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 && 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 < lines.length; i++) {\n            this.write();\n            // Escape exclamation marks in front of links\n            if (!escape && lines[i][0] == \"[\" && /(^|[^\\\\])\\!$/.test(this.out))\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) => 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) => {\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 && node.type.name === this.options.hardBreakNodeName)\n                marks = marks.filter(m => {\n                    if (index + 1 == parent.childCount)\n                        return false;\n                    let next = parent.child(index + 1);\n                    return m.isInSet(next.marks) && (!next.isText || /\\S/.test(next.text));\n                });\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 && node.isText && marks.some(mark => {\n                let info = this.getMark(mark.type.name);\n                return info && info.expelEnclosingWhitespace && !mark.isInSet(active);\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 && node.isText && marks.some(mark => {\n                let info = this.getMark(mark.type.name);\n                return info && info.expelEnclosingWhitespace && !this.isMarkAhead(parent, index + 1, mark);\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            let inner = marks.length ? marks[marks.length - 1] : null;\n            let noEsc = inner && 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 < len; i++) {\n                let mark = marks[i];\n                if (!this.getMark(mark.type.name).mixable)\n                    break;\n                for (let j = 0; j < 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 > j)\n                            marks = marks.slice(0, j).concat(mark).concat(marks.slice(j, i)).concat(marks.slice(i + 1, len));\n                        else if (j > 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 < Math.min(active.length, len) && marks[keep].eq(active[keep]))\n                ++keep;\n            // Close the marks that need to be closed\n            while (keep < 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 < 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 && 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            }\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 === null || node === void 0 ? void 0 : node.isText) && node.nodeSize > 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 && 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) => {\n            if (i && isTight)\n                this.flushClose(1);\n            this.wrapBlock(delim, firstDelim(i), node, () => 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) => m == \"_\" && i > 0 && i + 1 < str.length && str[i - 1].match(/\\w/) && str[i + 1].match(/\\w/) ? m : \"\\\\\" + m);\n        if (startOfLine)\n            str = str.replace(/^(\\+[ ]|[\\-*>])/, \"\\\\$&\").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, \"\\\\$&\");\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 < 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, mark) {\n        for (;; index++) {\n            if (index >= parent.childCount)\n                return false;\n            let next = parent.child(index);\n            if (next.type.name != this.options.hardBreakNodeName)\n                return mark.isInSet(next.marks);\n            index++;\n        }\n    }\n}\n\nexport { MarkdownParser, MarkdownSerializer, MarkdownSerializerState, defaultMarkdownParser, defaultMarkdownSerializer, schema };\n"],"names":["schema","Schema","node","dom","m","value","maybeMerge","a","b","Mark","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","MarkdownIt","_","blankMark","MarkdownSerializer","marks","options","MarkdownSerializerState","defaultMarkdownSerializer","backticks","fence","start","maxW","space","nStr","parent","index","isPlainURL","inAutolink","_state","_mark","backticksFor","side","ticks","len","result","link","MarkdownSerializerState$1","size","delimMin","trim","name","delim","firstDelim","f","old","escape","lines","fromBlockStart","active","trailing","progress","offset","next","leading","lead","rest","trail","inner","noEsc","outer","j","other","keep","add","isTight","prevTight","child","startOfLine","wrap","n","out","open"],"mappings":"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","x_google_ignoreList":[0]}