`):\n *\n * ```javascript\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * // Actual default values\n * var md = require('markdown-it')({\n * highlight: function (str, lang) {\n * if (lang && hljs.getLanguage(lang)) {\n * try {\n * return '' +\n * hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +\n * '
';\n * } catch (__) {}\n * }\n *\n * return '' + md.utils.escapeHtml(str) + '
';\n * }\n * });\n * ```\n *\n **/\nfunction MarkdownIt (presetName, options) {\n if (!(this instanceof MarkdownIt)) {\n return new MarkdownIt(presetName, options)\n }\n\n if (!options) {\n if (!utils.isString(presetName)) {\n options = presetName || {}\n presetName = 'default'\n }\n }\n\n /**\n * MarkdownIt#inline -> ParserInline\n *\n * Instance of [[ParserInline]]. You may need it to add new rules when\n * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n * [[MarkdownIt.enable]].\n **/\n this.inline = new ParserInline()\n\n /**\n * MarkdownIt#block -> ParserBlock\n *\n * Instance of [[ParserBlock]]. You may need it to add new rules when\n * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n * [[MarkdownIt.enable]].\n **/\n this.block = new ParserBlock()\n\n /**\n * MarkdownIt#core -> Core\n *\n * Instance of [[Core]] chain executor. You may need it to add new rules when\n * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n * [[MarkdownIt.enable]].\n **/\n this.core = new ParserCore()\n\n /**\n * MarkdownIt#renderer -> Renderer\n *\n * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering\n * rules for new token types, generated by plugins.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * function myToken(tokens, idx, options, env, self) {\n * //...\n * return result;\n * };\n *\n * md.renderer.rules['my_token'] = myToken\n * ```\n *\n * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).\n **/\n this.renderer = new Renderer()\n\n /**\n * MarkdownIt#linkify -> LinkifyIt\n *\n * [linkify-it](https://github.com/markdown-it/linkify-it) instance.\n * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)\n * rule.\n **/\n this.linkify = new LinkifyIt()\n\n /**\n * MarkdownIt#validateLink(url) -> Boolean\n *\n * Link validation function. CommonMark allows too much in links. By default\n * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas\n * except some embedded image types.\n *\n * You can change this behaviour:\n *\n * ```javascript\n * var md = require('markdown-it')();\n * // enable everything\n * md.validateLink = function () { return true; }\n * ```\n **/\n this.validateLink = validateLink\n\n /**\n * MarkdownIt#normalizeLink(url) -> String\n *\n * Function used to encode link url to a machine-readable format,\n * which includes url-encoding, punycode, etc.\n **/\n this.normalizeLink = normalizeLink\n\n /**\n * MarkdownIt#normalizeLinkText(url) -> String\n *\n * Function used to decode link url to a human-readable format`\n **/\n this.normalizeLinkText = normalizeLinkText\n\n // Expose utils & helpers for easy acces from plugins\n\n /**\n * MarkdownIt#utils -> utils\n *\n * Assorted utility functions, useful to write plugins. See details\n * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).\n **/\n this.utils = utils\n\n /**\n * MarkdownIt#helpers -> helpers\n *\n * Link components parser functions, useful to write plugins. See details\n * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).\n **/\n this.helpers = utils.assign({}, helpers)\n\n this.options = {}\n this.configure(presetName)\n\n if (options) { this.set(options) }\n}\n\n/** chainable\n * MarkdownIt.set(options)\n *\n * Set parser options (in the same format as in constructor). Probably, you\n * will never need it, but you can change options after constructor call.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n * .set({ html: true, breaks: true })\n * .set({ typographer, true });\n * ```\n *\n * __Note:__ To achieve the best possible performance, don't modify a\n * `markdown-it` instance options on the fly. If you need multiple configurations\n * it's best to create multiple instances and initialize each with separate\n * config.\n **/\nMarkdownIt.prototype.set = function (options) {\n utils.assign(this.options, options)\n return this\n}\n\n/** chainable, internal\n * MarkdownIt.configure(presets)\n *\n * Batch load of all options and compenent settings. This is internal method,\n * and you probably will not need it. But if you will - see available presets\n * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)\n *\n * We strongly recommend to use presets instead of direct config loads. That\n * will give better compatibility with next versions.\n **/\nMarkdownIt.prototype.configure = function (presets) {\n const self = this\n\n if (utils.isString(presets)) {\n const presetName = presets\n presets = config[presetName]\n if (!presets) { throw new Error('Wrong `markdown-it` preset \"' + presetName + '\", check name') }\n }\n\n if (!presets) { throw new Error('Wrong `markdown-it` preset, can\\'t be empty') }\n\n if (presets.options) { self.set(presets.options) }\n\n if (presets.components) {\n Object.keys(presets.components).forEach(function (name) {\n if (presets.components[name].rules) {\n self[name].ruler.enableOnly(presets.components[name].rules)\n }\n if (presets.components[name].rules2) {\n self[name].ruler2.enableOnly(presets.components[name].rules2)\n }\n })\n }\n return this\n}\n\n/** chainable\n * MarkdownIt.enable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to enable\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable list or rules. It will automatically find appropriate components,\n * containing rules with given names. If rule not found, and `ignoreInvalid`\n * not set - throws exception.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n * .enable(['sub', 'sup'])\n * .disable('smartquotes');\n * ```\n **/\nMarkdownIt.prototype.enable = function (list, ignoreInvalid) {\n let result = []\n\n if (!Array.isArray(list)) { list = [list] }\n\n ['core', 'block', 'inline'].forEach(function (chain) {\n result = result.concat(this[chain].ruler.enable(list, true))\n }, this)\n\n result = result.concat(this.inline.ruler2.enable(list, true))\n\n const missed = list.filter(function (name) { return result.indexOf(name) < 0 })\n\n if (missed.length && !ignoreInvalid) {\n throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed)\n }\n\n return this\n}\n\n/** chainable\n * MarkdownIt.disable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * The same as [[MarkdownIt.enable]], but turn specified rules off.\n **/\nMarkdownIt.prototype.disable = function (list, ignoreInvalid) {\n let result = []\n\n if (!Array.isArray(list)) { list = [list] }\n\n ['core', 'block', 'inline'].forEach(function (chain) {\n result = result.concat(this[chain].ruler.disable(list, true))\n }, this)\n\n result = result.concat(this.inline.ruler2.disable(list, true))\n\n const missed = list.filter(function (name) { return result.indexOf(name) < 0 })\n\n if (missed.length && !ignoreInvalid) {\n throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed)\n }\n return this\n}\n\n/** chainable\n * MarkdownIt.use(plugin, params)\n *\n * Load specified plugin with given params into current parser instance.\n * It's just a sugar to call `plugin(md, params)` with curring.\n *\n * ##### Example\n *\n * ```javascript\n * var iterator = require('markdown-it-for-inline');\n * var md = require('markdown-it')()\n * .use(iterator, 'foo_replace', 'text', function (tokens, idx) {\n * tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');\n * });\n * ```\n **/\nMarkdownIt.prototype.use = function (plugin /*, params, ... */) {\n const args = [this].concat(Array.prototype.slice.call(arguments, 1))\n plugin.apply(plugin, args)\n return this\n}\n\n/** internal\n * MarkdownIt.parse(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Parse input string and return list of block tokens (special token type\n * \"inline\" will contain list of inline tokens). You should not call this\n * method directly, until you write custom renderer (for example, to produce\n * AST).\n *\n * `env` is used to pass data between \"distributed\" rules and return additional\n * metadata like reference info, needed for the renderer. It also can be used to\n * inject data in specific cases. Usually, you will be ok to pass `{}`,\n * and then pass updated object to renderer.\n **/\nMarkdownIt.prototype.parse = function (src, env) {\n if (typeof src !== 'string') {\n throw new Error('Input data should be a String')\n }\n\n const state = new this.core.State(src, this, env)\n\n this.core.process(state)\n\n return state.tokens\n}\n\n/**\n * MarkdownIt.render(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Render markdown string into html. It does all magic for you :).\n *\n * `env` can be used to inject additional metadata (`{}` by default).\n * But you will not need it with high probability. See also comment\n * in [[MarkdownIt.parse]].\n **/\nMarkdownIt.prototype.render = function (src, env) {\n env = env || {}\n\n return this.renderer.render(this.parse(src, env), this.options, env)\n}\n\n/** internal\n * MarkdownIt.parseInline(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the\n * block tokens list with the single `inline` element, containing parsed inline\n * tokens in `children` property. Also updates `env` object.\n **/\nMarkdownIt.prototype.parseInline = function (src, env) {\n const state = new this.core.State(src, this, env)\n\n state.inlineMode = true\n this.core.process(state)\n\n return state.tokens\n}\n\n/**\n * MarkdownIt.renderInline(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Similar to [[MarkdownIt.render]] but for single paragraph content. Result\n * will NOT be wrapped into `` tags.\n **/\nMarkdownIt.prototype.renderInline = function (src, env) {\n env = env || {}\n\n return this.renderer.render(this.parseInline(src, env), this.options, env)\n}\n\nexport default MarkdownIt\n","export { default } from './lib/index.mjs'\n","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 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 &&\n (index == parent.childCount - 1 || !mark.isInSet(parent.child(index + 1).marks));\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\nexport { MarkdownParser, MarkdownSerializer, MarkdownSerializerState, defaultMarkdownParser, defaultMarkdownSerializer, schema };\n","var __defProp = Object.defineProperty;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __publicField = (obj, key, value) => {\n __defNormalProp(obj, typeof key !== \"symbol\" ? key + \"\" : key, value);\n return value;\n};\nimport { Extension, Mark, getHTMLFromFragment, Node as Node$1, extensions } from \"@tiptap/core\";\nimport { MarkdownSerializerState as MarkdownSerializerState$1, defaultMarkdownSerializer } from \"prosemirror-markdown\";\nimport markdownit from \"markdown-it\";\nimport { Fragment, DOMParser } from \"@tiptap/pm/model\";\nimport taskListPlugin from \"markdown-it-task-lists\";\nimport { Plugin, PluginKey } from \"@tiptap/pm/state\";\nconst MarkdownTightLists = Extension.create({\n name: \"markdownTightLists\",\n addOptions: () => ({\n tight: true,\n tightClass: \"tight\",\n listTypes: [\"bulletList\", \"orderedList\"]\n }),\n addGlobalAttributes() {\n return [{\n types: this.options.listTypes,\n attributes: {\n tight: {\n default: this.options.tight,\n parseHTML: (element) => element.getAttribute(\"data-tight\") === \"true\" || !element.querySelector(\"p\"),\n renderHTML: (attributes) => ({\n class: attributes.tight ? this.options.tightClass : null,\n \"data-tight\": attributes.tight ? \"true\" : null\n })\n }\n }\n }];\n },\n addCommands() {\n var _this = this;\n return {\n toggleTight: function() {\n let tight = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;\n return (_ref) => {\n let {\n editor,\n commands\n } = _ref;\n function toggleTight(name) {\n if (!editor.isActive(name)) {\n return false;\n }\n const attrs = editor.getAttributes(name);\n return commands.updateAttributes(name, {\n tight: tight !== null && tight !== void 0 ? tight : !(attrs !== null && attrs !== void 0 && attrs.tight)\n });\n }\n return _this.options.listTypes.some((name) => toggleTight(name));\n };\n }\n };\n }\n});\nconst md = markdownit();\nfunction scanDelims(text, pos) {\n md.inline.State.prototype.scanDelims.call({\n src: text,\n posMax: text.length\n });\n const state = new md.inline.State(text, null, null, []);\n return state.scanDelims(pos, true);\n}\nfunction shiftDelim(text, delim, start, offset) {\n let res = text.substring(0, start) + text.substring(start + delim.length);\n res = res.substring(0, start + offset) + delim + res.substring(start + offset);\n return res;\n}\nfunction trimStart(text, delim, from, to) {\n let pos = from, res = text;\n while (pos < to) {\n if (scanDelims(res, pos).can_open) {\n break;\n }\n res = shiftDelim(res, delim, pos, 1);\n pos++;\n }\n return {\n text: res,\n from: pos,\n to\n };\n}\nfunction trimEnd(text, delim, from, to) {\n let pos = to, res = text;\n while (pos > from) {\n if (scanDelims(res, pos).can_close) {\n break;\n }\n res = shiftDelim(res, delim, pos, -1);\n pos--;\n }\n return {\n text: res,\n from,\n to: pos\n };\n}\nfunction trimInline(text, delim, from, to) {\n let state = {\n text,\n from,\n to\n };\n state = trimStart(state.text, delim, state.from, state.to);\n state = trimEnd(state.text, delim, state.from, state.to);\n if (state.to - state.from < delim.length + 1) {\n state.text = state.text.substring(0, state.from) + state.text.substring(state.to + delim.length);\n }\n return state.text;\n}\nclass MarkdownSerializerState extends MarkdownSerializerState$1 {\n constructor(nodes, marks, options) {\n super(nodes, marks, options !== null && options !== void 0 ? options : {});\n __publicField(this, \"inTable\", false);\n this.inlines = [];\n }\n render(node, parent, index) {\n super.render(node, parent, index);\n const top = this.inlines[this.inlines.length - 1];\n if (top !== null && top !== void 0 && top.start && top !== null && top !== void 0 && top.end) {\n const {\n delimiter,\n start,\n end\n } = this.normalizeInline(top);\n this.out = trimInline(this.out, delimiter, start, end);\n this.inlines.pop();\n }\n }\n markString(mark, open, parent, index) {\n const info = this.marks[mark.type.name];\n if (info.expelEnclosingWhitespace) {\n if (open) {\n this.inlines.push({\n start: this.out.length,\n delimiter: info.open\n });\n } else {\n const top = this.inlines.pop();\n this.inlines.push({\n ...top,\n end: this.out.length\n });\n }\n }\n return super.markString(mark, open, parent, index);\n }\n normalizeInline(inline) {\n let {\n start,\n end\n } = inline;\n while (this.out.charAt(start).match(/\\s/)) {\n start++;\n }\n return {\n ...inline,\n start\n };\n }\n}\nconst HTMLMark = Mark.create({\n name: \"markdownHTMLMark\",\n /**\n * @return {{markdown: MarkdownMarkSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: {\n open(state, mark) {\n var _getMarkTags$, _getMarkTags;\n if (!this.editor.storage.markdown.options.html) {\n console.warn(`Tiptap Markdown: \"${mark.type.name}\" mark is only available in html mode`);\n return \"\";\n }\n return (_getMarkTags$ = (_getMarkTags = getMarkTags(mark)) === null || _getMarkTags === void 0 ? void 0 : _getMarkTags[0]) !== null && _getMarkTags$ !== void 0 ? _getMarkTags$ : \"\";\n },\n close(state, mark) {\n var _getMarkTags$2, _getMarkTags2;\n if (!this.editor.storage.markdown.options.html) {\n return \"\";\n }\n return (_getMarkTags$2 = (_getMarkTags2 = getMarkTags(mark)) === null || _getMarkTags2 === void 0 ? void 0 : _getMarkTags2[1]) !== null && _getMarkTags$2 !== void 0 ? _getMarkTags$2 : \"\";\n }\n },\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nfunction getMarkTags(mark) {\n const schema = mark.type.schema;\n const node = schema.text(\" \", [mark]);\n const html = getHTMLFromFragment(Fragment.from(node), schema);\n const match = html.match(/^(<.*?>) (<\\/.*?>)$/);\n return match ? [match[1], match[2]] : null;\n}\nfunction elementFromString(value) {\n const wrappedValue = `
${value}`;\n return new window.DOMParser().parseFromString(wrappedValue, \"text/html\").body;\n}\nfunction escapeHTML(value) {\n return value === null || value === void 0 ? void 0 : value.replace(//g, \">\");\n}\nfunction extractElement(node) {\n const parent = node.parentElement;\n const prepend = parent.cloneNode();\n while (parent.firstChild && parent.firstChild !== node) {\n prepend.appendChild(parent.firstChild);\n }\n if (prepend.childNodes.length > 0) {\n parent.parentElement.insertBefore(prepend, parent);\n }\n parent.parentElement.insertBefore(node, parent);\n if (parent.childNodes.length === 0) {\n parent.remove();\n }\n}\nfunction unwrapElement(node) {\n const parent = node.parentNode;\n while (node.firstChild)\n parent.insertBefore(node.firstChild, node);\n parent.removeChild(node);\n}\nconst HTMLNode = Node$1.create({\n name: \"markdownHTMLNode\",\n addStorage() {\n return {\n markdown: {\n serialize(state, node, parent) {\n if (this.editor.storage.markdown.options.html) {\n state.write(serializeHTML(node, parent));\n } else {\n console.warn(`Tiptap Markdown: \"${node.type.name}\" node is only available in html mode`);\n state.write(`[${node.type.name}]`);\n }\n if (node.isBlock) {\n state.closeBlock(node);\n }\n },\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nfunction serializeHTML(node, parent) {\n const schema = node.type.schema;\n const html = getHTMLFromFragment(Fragment.from(node), schema);\n if (node.isBlock && (parent instanceof Fragment || parent.type.name === schema.topNodeType.name)) {\n return formatBlock(html);\n }\n return html;\n}\nfunction formatBlock(html) {\n const dom = elementFromString(html);\n const element = dom.firstElementChild;\n element.innerHTML = element.innerHTML.trim() ? `\n${element.innerHTML}\n` : `\n`;\n return element.outerHTML;\n}\nconst Blockquote = Node$1.create({\n name: \"blockquote\"\n});\nconst Blockquote$1 = Blockquote.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.nodes.blockquote,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst BulletList = Node$1.create({\n name: \"bulletList\"\n});\nconst BulletList$1 = BulletList.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize(state, node) {\n return state.renderList(node, \" \", () => (this.editor.storage.markdown.options.bulletListMarker || \"-\") + \" \");\n },\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst CodeBlock = Node$1.create({\n name: \"codeBlock\"\n});\nconst CodeBlock$1 = CodeBlock.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize(state, node) {\n state.write(\"```\" + (node.attrs.language || \"\") + \"\\n\");\n state.text(node.textContent, false);\n state.ensureNewLine();\n state.write(\"```\");\n state.closeBlock(node);\n },\n parse: {\n setup(markdownit2) {\n var _this$options$languag;\n markdownit2.set({\n langPrefix: (_this$options$languag = this.options.languageClassPrefix) !== null && _this$options$languag !== void 0 ? _this$options$languag : \"language-\"\n });\n },\n updateDOM(element) {\n element.innerHTML = element.innerHTML.replace(/\\n<\\/code><\\/pre>/g, \"\");\n }\n }\n }\n };\n }\n});\nconst HardBreak = Node$1.create({\n name: \"hardBreak\"\n});\nconst HardBreak$1 = HardBreak.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize(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(state.inTable ? HTMLNode.storage.markdown.serialize.call(this, state, node, parent) : \"\\\\\\n\");\n return;\n }\n },\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst Heading = Node$1.create({\n name: \"heading\"\n});\nconst Heading$1 = Heading.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.nodes.heading,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst HorizontalRule = Node$1.create({\n name: \"horizontalRule\"\n});\nconst HorizontalRule$1 = HorizontalRule.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.nodes.horizontal_rule,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst Image = Node$1.create({\n name: \"image\"\n});\nconst Image$1 = Image.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.nodes.image,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst ListItem = Node$1.create({\n name: \"listItem\"\n});\nconst ListItem$1 = ListItem.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.nodes.list_item,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst OrderedList = Node$1.create({\n name: \"orderedList\"\n});\nfunction findIndexOfAdjacentNode(node, parent, index) {\n let i = 0;\n for (; index - i > 0; i++) {\n if (parent.child(index - i - 1).type.name !== node.type.name) {\n break;\n }\n }\n return i;\n}\nconst OrderedList$1 = OrderedList.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize(state, node, parent, index) {\n const start = node.attrs.start || 1;\n const maxW = String(start + node.childCount - 1).length;\n const space = state.repeat(\" \", maxW + 2);\n const adjacentIndex = findIndexOfAdjacentNode(node, parent, index);\n const separator = adjacentIndex % 2 ? \") \" : \". \";\n state.renderList(node, space, (i) => {\n const nStr = String(start + i);\n return state.repeat(\" \", maxW - nStr.length) + nStr + separator;\n });\n },\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst Paragraph = Node$1.create({\n name: \"paragraph\"\n});\nconst Paragraph$1 = Paragraph.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.nodes.paragraph,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nfunction childNodes(node) {\n var _node$content$content, _node$content;\n return (_node$content$content = node === null || node === void 0 || (_node$content = node.content) === null || _node$content === void 0 ? void 0 : _node$content.content) !== null && _node$content$content !== void 0 ? _node$content$content : [];\n}\nconst Table = Node$1.create({\n name: \"table\"\n});\nconst Table$1 = Table.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize(state, node, parent) {\n if (!isMarkdownSerializable(node)) {\n HTMLNode.storage.markdown.serialize.call(this, state, node, parent);\n return;\n }\n state.inTable = true;\n node.forEach((row, p, i) => {\n state.write(\"| \");\n row.forEach((col, p2, j) => {\n if (j) {\n state.write(\" | \");\n }\n const cellContent = col.firstChild;\n if (cellContent.textContent.trim()) {\n state.renderInline(cellContent);\n }\n });\n state.write(\" |\");\n state.ensureNewLine();\n if (!i) {\n const delimiterRow = Array.from({\n length: row.childCount\n }).map(() => \"---\").join(\" | \");\n state.write(`| ${delimiterRow} |`);\n state.ensureNewLine();\n }\n });\n state.closeBlock(node);\n state.inTable = false;\n },\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nfunction hasSpan(node) {\n return node.attrs.colspan > 1 || node.attrs.rowspan > 1;\n}\nfunction isMarkdownSerializable(node) {\n const rows = childNodes(node);\n const firstRow = rows[0];\n const bodyRows = rows.slice(1);\n if (childNodes(firstRow).some((cell) => cell.type.name !== \"tableHeader\" || hasSpan(cell) || cell.childCount > 1)) {\n return false;\n }\n if (bodyRows.some((row) => childNodes(row).some((cell) => cell.type.name === \"tableHeader\" || hasSpan(cell) || cell.childCount > 1))) {\n return false;\n }\n return true;\n}\nconst TaskItem = Node$1.create({\n name: \"taskItem\"\n});\nconst TaskItem$1 = TaskItem.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize(state, node) {\n const check = node.attrs.checked ? \"[x]\" : \"[ ]\";\n state.write(`${check} `);\n state.renderContent(node);\n },\n parse: {\n updateDOM(element) {\n [...element.querySelectorAll(\".task-list-item\")].forEach((item) => {\n const input = item.querySelector(\"input\");\n item.setAttribute(\"data-type\", \"taskItem\");\n if (input) {\n item.setAttribute(\"data-checked\", input.checked);\n input.remove();\n }\n });\n }\n }\n }\n };\n }\n});\nconst TaskList = Node$1.create({\n name: \"taskList\"\n});\nconst TaskList$1 = TaskList.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: BulletList$1.storage.markdown.serialize,\n parse: {\n setup(markdownit2) {\n markdownit2.use(taskListPlugin);\n },\n updateDOM(element) {\n [...element.querySelectorAll(\".contains-task-list\")].forEach((list) => {\n list.setAttribute(\"data-type\", \"taskList\");\n });\n }\n }\n }\n };\n }\n});\nconst Text = Node$1.create({\n name: \"text\"\n});\nconst Text$1 = Text.extend({\n /**\n * @return {{markdown: MarkdownNodeSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize(state, node) {\n state.text(escapeHTML(node.text));\n },\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst Bold = Mark.create({\n name: \"bold\"\n});\nconst Bold$1 = Bold.extend({\n /**\n * @return {{markdown: MarkdownMarkSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.marks.strong,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst Code = Mark.create({\n name: \"code\"\n});\nconst Code$1 = Code.extend({\n /**\n * @return {{markdown: MarkdownMarkSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.marks.code,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst Italic = Mark.create({\n name: \"italic\"\n});\nconst Italic$1 = Italic.extend({\n /**\n * @return {{markdown: MarkdownMarkSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.marks.em,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst Link = Mark.create({\n name: \"link\"\n});\nconst Link$1 = Link.extend({\n /**\n * @return {{markdown: MarkdownMarkSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: defaultMarkdownSerializer.marks.link,\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst Strike = Mark.create({\n name: \"strike\"\n});\nconst Strike$1 = Strike.extend({\n /**\n * @return {{markdown: MarkdownMarkSpec}}\n */\n addStorage() {\n return {\n markdown: {\n serialize: {\n open: \"~~\",\n close: \"~~\",\n expelEnclosingWhitespace: true\n },\n parse: {\n // handled by markdown-it\n }\n }\n };\n }\n});\nconst markdownExtensions = [Blockquote$1, BulletList$1, CodeBlock$1, HardBreak$1, Heading$1, HorizontalRule$1, HTMLNode, Image$1, ListItem$1, OrderedList$1, Paragraph$1, Table$1, TaskItem$1, TaskList$1, Text$1, Bold$1, Code$1, HTMLMark, Italic$1, Link$1, Strike$1];\nfunction getMarkdownSpec(extension) {\n var _extension$storage, _markdownExtensions$f;\n const markdownSpec = (_extension$storage = extension.storage) === null || _extension$storage === void 0 ? void 0 : _extension$storage.markdown;\n const defaultMarkdownSpec = (_markdownExtensions$f = markdownExtensions.find((e) => e.name === extension.name)) === null || _markdownExtensions$f === void 0 ? void 0 : _markdownExtensions$f.storage.markdown;\n if (markdownSpec || defaultMarkdownSpec) {\n return {\n ...defaultMarkdownSpec,\n ...markdownSpec\n };\n }\n return null;\n}\nclass MarkdownSerializer {\n constructor(editor) {\n /**\n * @type {import('@tiptap/core').Editor}\n */\n __publicField(this, \"editor\", null);\n this.editor = editor;\n }\n serialize(content) {\n const state = new MarkdownSerializerState(this.nodes, this.marks, {\n hardBreakNodeName: HardBreak$1.name\n });\n state.renderContent(content);\n return state.out;\n }\n get nodes() {\n var _this$editor$extensio;\n return {\n ...Object.fromEntries(Object.keys(this.editor.schema.nodes).map((name) => [name, this.serializeNode(HTMLNode)])),\n ...Object.fromEntries((_this$editor$extensio = this.editor.extensionManager.extensions.filter((extension) => extension.type === \"node\" && this.serializeNode(extension)).map((extension) => [extension.name, this.serializeNode(extension)])) !== null && _this$editor$extensio !== void 0 ? _this$editor$extensio : [])\n };\n }\n get marks() {\n var _this$editor$extensio2;\n return {\n ...Object.fromEntries(Object.keys(this.editor.schema.marks).map((name) => [name, this.serializeMark(HTMLMark)])),\n ...Object.fromEntries((_this$editor$extensio2 = this.editor.extensionManager.extensions.filter((extension) => extension.type === \"mark\" && this.serializeMark(extension)).map((extension) => [extension.name, this.serializeMark(extension)])) !== null && _this$editor$extensio2 !== void 0 ? _this$editor$extensio2 : [])\n };\n }\n serializeNode(node) {\n var _getMarkdownSpec;\n return (_getMarkdownSpec = getMarkdownSpec(node)) === null || _getMarkdownSpec === void 0 || (_getMarkdownSpec = _getMarkdownSpec.serialize) === null || _getMarkdownSpec === void 0 ? void 0 : _getMarkdownSpec.bind({\n editor: this.editor,\n options: node.options\n });\n }\n serializeMark(mark) {\n var _getMarkdownSpec2;\n const serialize = (_getMarkdownSpec2 = getMarkdownSpec(mark)) === null || _getMarkdownSpec2 === void 0 ? void 0 : _getMarkdownSpec2.serialize;\n return serialize ? {\n ...serialize,\n open: typeof serialize.open === \"function\" ? serialize.open.bind({\n editor: this.editor,\n options: mark.options\n }) : serialize.open,\n close: typeof serialize.close === \"function\" ? serialize.close.bind({\n editor: this.editor,\n options: mark.options\n }) : serialize.close\n } : null;\n }\n}\nclass MarkdownParser {\n constructor(editor, _ref) {\n /**\n * @type {import('@tiptap/core').Editor}\n */\n __publicField(this, \"editor\", null);\n /**\n * @type {markdownit}\n */\n __publicField(this, \"md\", null);\n let {\n html,\n linkify,\n breaks\n } = _ref;\n this.editor = editor;\n this.md = this.withPatchedRenderer(markdownit({\n html,\n linkify,\n breaks\n }));\n }\n parse(content) {\n let {\n inline\n } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};\n if (typeof content === \"string\") {\n this.editor.extensionManager.extensions.forEach((extension) => {\n var _getMarkdownSpec;\n return (_getMarkdownSpec = getMarkdownSpec(extension)) === null || _getMarkdownSpec === void 0 || (_getMarkdownSpec = _getMarkdownSpec.parse) === null || _getMarkdownSpec === void 0 || (_getMarkdownSpec = _getMarkdownSpec.setup) === null || _getMarkdownSpec === void 0 ? void 0 : _getMarkdownSpec.call({\n editor: this.editor,\n options: extension.options\n }, this.md);\n });\n const renderedHTML = this.md.render(content);\n const element = elementFromString(renderedHTML);\n this.editor.extensionManager.extensions.forEach((extension) => {\n var _getMarkdownSpec2;\n return (_getMarkdownSpec2 = getMarkdownSpec(extension)) === null || _getMarkdownSpec2 === void 0 || (_getMarkdownSpec2 = _getMarkdownSpec2.parse) === null || _getMarkdownSpec2 === void 0 || (_getMarkdownSpec2 = _getMarkdownSpec2.updateDOM) === null || _getMarkdownSpec2 === void 0 ? void 0 : _getMarkdownSpec2.call({\n editor: this.editor,\n options: extension.options\n }, element);\n });\n this.normalizeDOM(element, {\n inline,\n content\n });\n return element.innerHTML;\n }\n return content;\n }\n normalizeDOM(node, _ref2) {\n let {\n inline,\n content\n } = _ref2;\n this.normalizeBlocks(node);\n node.querySelectorAll(\"*\").forEach((el) => {\n var _el$nextSibling;\n if (((_el$nextSibling = el.nextSibling) === null || _el$nextSibling === void 0 ? void 0 : _el$nextSibling.nodeType) === Node.TEXT_NODE && !el.closest(\"pre\")) {\n el.nextSibling.textContent = el.nextSibling.textContent.replace(/^\\n/, \"\");\n }\n });\n if (inline) {\n this.normalizeInline(node, content);\n }\n return node;\n }\n normalizeBlocks(node) {\n const blocks = Object.values(this.editor.schema.nodes).filter((node2) => node2.isBlock);\n const selector = blocks.map((block) => {\n var _block$spec$parseDOM;\n return (_block$spec$parseDOM = block.spec.parseDOM) === null || _block$spec$parseDOM === void 0 ? void 0 : _block$spec$parseDOM.map((spec) => spec.tag);\n }).flat().filter(Boolean).join(\",\");\n if (!selector) {\n return;\n }\n [...node.querySelectorAll(selector)].forEach((el) => {\n if (el.parentElement.matches(\"p\")) {\n extractElement(el);\n }\n });\n }\n normalizeInline(node, content) {\n var _node$firstElementChi;\n if ((_node$firstElementChi = node.firstElementChild) !== null && _node$firstElementChi !== void 0 && _node$firstElementChi.matches(\"p\")) {\n var _content$match$, _content$match, _content$match$2, _content$match2;\n const firstParagraph = node.firstElementChild;\n const {\n nextElementSibling\n } = firstParagraph;\n const startSpaces = (_content$match$ = (_content$match = content.match(/^\\s+/)) === null || _content$match === void 0 ? void 0 : _content$match[0]) !== null && _content$match$ !== void 0 ? _content$match$ : \"\";\n const endSpaces = !nextElementSibling ? (_content$match$2 = (_content$match2 = content.match(/\\s+$/)) === null || _content$match2 === void 0 ? void 0 : _content$match2[0]) !== null && _content$match$2 !== void 0 ? _content$match$2 : \"\" : \"\";\n if (content.match(/^\\n\\n/)) {\n firstParagraph.innerHTML = `${firstParagraph.innerHTML}${endSpaces}`;\n return;\n }\n unwrapElement(firstParagraph);\n node.innerHTML = `${startSpaces}${node.innerHTML}${endSpaces}`;\n }\n }\n /**\n * @param {markdownit} md\n */\n withPatchedRenderer(md2) {\n const withoutNewLine = (renderer) => function() {\n const rendered = renderer(...arguments);\n if (rendered === \"\\n\") {\n return rendered;\n }\n if (rendered[rendered.length - 1] === \"\\n\") {\n return rendered.slice(0, -1);\n }\n return rendered;\n };\n md2.renderer.rules.hardbreak = withoutNewLine(md2.renderer.rules.hardbreak);\n md2.renderer.rules.softbreak = withoutNewLine(md2.renderer.rules.softbreak);\n md2.renderer.rules.fence = withoutNewLine(md2.renderer.rules.fence);\n md2.renderer.rules.code_block = withoutNewLine(md2.renderer.rules.code_block);\n md2.renderer.renderToken = withoutNewLine(md2.renderer.renderToken.bind(md2.renderer));\n return md2;\n }\n}\nconst MarkdownClipboard = Extension.create({\n name: \"markdownClipboard\",\n addOptions() {\n return {\n transformPastedText: false,\n transformCopiedText: false\n };\n },\n addProseMirrorPlugins() {\n return [new Plugin({\n key: new PluginKey(\"markdownClipboard\"),\n props: {\n clipboardTextParser: (text, context, plainText) => {\n if (plainText || !this.options.transformPastedText) {\n return null;\n }\n const parsed = this.editor.storage.markdown.parser.parse(text, {\n inline: true\n });\n return DOMParser.fromSchema(this.editor.schema).parseSlice(elementFromString(parsed), {\n preserveWhitespace: true,\n context\n });\n },\n /**\n * @param {import('prosemirror-model').Slice} slice\n */\n clipboardTextSerializer: (slice) => {\n if (!this.options.transformCopiedText) {\n return null;\n }\n return this.editor.storage.markdown.serializer.serialize(slice.content);\n }\n }\n })];\n }\n});\nconst Markdown = Extension.create({\n name: \"markdown\",\n priority: 50,\n addOptions() {\n return {\n html: true,\n tightLists: true,\n tightListClass: \"tight\",\n bulletListMarker: \"-\",\n linkify: false,\n breaks: false,\n transformPastedText: false,\n transformCopiedText: false\n };\n },\n addCommands() {\n const commands = extensions.Commands.config.addCommands();\n return {\n setContent: (content, emitUpdate, parseOptions) => (props) => {\n return commands.setContent(props.editor.storage.markdown.parser.parse(content), emitUpdate, parseOptions)(props);\n },\n insertContentAt: (range, content, options) => (props) => {\n return commands.insertContentAt(range, props.editor.storage.markdown.parser.parse(content, {\n inline: true\n }), options)(props);\n }\n };\n },\n onBeforeCreate() {\n this.editor.storage.markdown = {\n options: {\n ...this.options\n },\n parser: new MarkdownParser(this.editor, this.options),\n serializer: new MarkdownSerializer(this.editor),\n getMarkdown: () => {\n return this.editor.storage.markdown.serializer.serialize(this.editor.state.doc);\n }\n };\n this.editor.options.initialContent = this.editor.options.content;\n this.editor.options.content = this.editor.storage.markdown.parser.parse(this.editor.options.content);\n },\n onCreate() {\n this.editor.options.content = this.editor.options.initialContent;\n delete this.editor.options.initialContent;\n },\n addStorage() {\n return {\n /// storage will be defined in onBeforeCreate() to prevent initial object overriding\n };\n },\n addExtensions() {\n return [MarkdownTightLists.configure({\n tight: this.options.tightLists,\n tightClass: this.options.tightListClass\n }), MarkdownClipboard.configure({\n transformPastedText: this.options.transformPastedText,\n transformCopiedText: this.options.transformCopiedText\n })];\n }\n});\nexport {\n Markdown\n};\n//# sourceMappingURL=tiptap-markdown.es.js.map\n"],"names":["disableCheckboxes","useLabelWrapper","useLabelAfter","attrSet","token","name","value","index","attrIndex","attr","attrPush","attrs","module","exports","md","options","enabled","label","labelAfter","core","ruler","after","state","tokens","i","length","isTodoItem","isInline","type","content","indexOf","todoify","TokenConstructor","children","unshift","makeCheckbox","checkbox","disabledAttr","slice","pop","id","Math","ceil","random","push","afterLabel","for","beginLabel","endLabel","Token","parentToken","targetLevel","level","DEFAULT_LABELS","linkControlLabel","colorPickerControlLabel","highlightControlLabel","colorControlLabel","concat","color","boldControlLabel","italicControlLabel","underlineControlLabel","strikeControlLabel","clearFormattingControlLabel","unlinkControlLabel","bulletListControlLabel","orderedListControlLabel","h1ControlLabel","h2ControlLabel","h3ControlLabel","h4ControlLabel","h5ControlLabel","h6ControlLabel","blockquoteControlLabel","alignLeftControlLabel","alignCenterControlLabel","alignRightControlLabel","alignJustifyControlLabel","codeControlLabel","codeBlockControlLabel","subscriptControlLabel","superscriptControlLabel","unsetColorControlLabel","hrControlLabel","undoControlLabel","redoControlLabel","tasksControlLabel","tasksSinkLabel","tasksLiftLabel","linkEditorInputLabel","linkEditorInputPlaceholder","linkEditorExternalLink","linkEditorInternalLink","linkEditorSave","colorPickerCancel","colorPickerClear","colorPickerColorPicker","colorPickerPalette","colorPickerSave","colorPickerColorLabel","RichTextEditorProvider","useRichTextEditorContext","createSafeContext","defaultProps","RichTextEditorContent","factory","_props","ref","classNames","className","style","styles","vars","others","useProps","ctx","withTypographyStyles","jsx","TypographyStylesProvider","getStyles","unstyled","Box","component","EditorContent","editor","IconBase","props","xmlns","viewBox","strokeWidth","stroke","fill","strokeLinecap","strokeLinejoin","IconBold","jsxs","d","IconItalic","IconUnderline","IconStrikethrough","IconClearFormatting","IconH1","IconH2","IconH3","IconH4","IconH5","IconH6","IconList","IconListNumbers","IconUnlink","IconBlockquote","IconAlignLeft","IconAlignRight","IconAlignCenter","IconAlignJustified","IconSubscript","IconSuperscript","IconCode","IconHighlight","IconLineDashed","IconCircleOff","IconColorPicker","IconX","IconPalette","IconCheck","IconLink","IconExternalLink","IconArrowBackUp","IconArrowForwardUp","IconListCheck","IconIndentIncrease","IconIndentDecrease","classes","displayName","interactive","RichTextEditorControl","active","onMouseDown","disabled","UnstyledButton","tabIndex","variant","event","preventDefault","RichTextEditorControlBase","forwardRef","param","icon","Icon","createControl","isActive","operation","isDisabled","Control","labels","_label","title","attributes","onClick","chain","focus","run","BoldControl","ItalicControl","UnderlineControl","StrikeThroughControl","ClearFormattingControl","UnlinkControl","BulletListControl","OrderedListControl","H1Control","H2Control","H3Control","H4Control","H5Control","H6Control","BlockquoteControl","AlignLeftControl","AlignRightControl","AlignCenterControl","AlignJustifyControl","SubscriptControl","SuperscriptControl","CodeControl","CodeBlockControl","HighlightControl","HrControl","UnsetColorControl","UndoControl","can","undo","RedoControl","redo","TaskListControl","TaskListSinkControl","sinkListItem","TaskListLiftControl","liftListItem","LinkIcon","RichTextEditorLinkControl","popoverProps","disableTooltips","initialExternal","stylesApiProps","url","setUrl","useInputState","external","setExternal","useState","opened","open","close","useDisclosure","handleOpen","linkData","getAttributes","href","target","handleClose","setLink","extendMarkRange","unsetLink","useWindowEvent","resolvedClassNames","resolvedStyles","useResolvedStylesApi","Popover","trapFocus","shadow","withinPortal","onChange","_opened","offset","zIndex","Target","Dropdown","TextInput","placeholder","input","onKeyDown","key","rightSection","Tooltip","events","hover","touch","withArrow","e","width","rem","height","Button","RichTextEditorColorPickerControl","colors","colorPickerProps","toggle","setState","currentColor","handleChange","shouldClose","setColor","controls","map","ColorSwatch","size","radius","cursor","SimpleGrid","cols","spacing","ColorPicker","defaultValue","Group","closeDelay","justify","gap","mt","ActionIcon","unsetColor","RichTextEditorColorControl","RichTextEditorControlsGroup","RichTextEditorToolbar","sticky","stickyOffset","mod","__vars","withCodeHighlightStyles","RichTextEditor","useStyles","mergedLabels","useMemo","Content","Toolbar","ControlsGroup","Bold","controls.BoldControl","Italic","controls.ItalicControl","Strikethrough","controls.StrikeThroughControl","Underline","controls.UnderlineControl","ClearFormatting","controls.ClearFormattingControl","H1","controls.H1Control","H2","controls.H2Control","H3","controls.H3Control","H4","controls.H4Control","H5","controls.H5Control","H6","controls.H6Control","BulletList","controls.BulletListControl","OrderedList","controls.OrderedListControl","Link","controls.RichTextEditorLinkControl","Unlink","controls.UnlinkControl","Blockquote","controls.BlockquoteControl","AlignLeft","controls.AlignLeftControl","AlignRight","controls.AlignRightControl","AlignCenter","controls.AlignCenterControl","AlignJustify","controls.AlignJustifyControl","Superscript","controls.SuperscriptControl","Subscript","controls.SubscriptControl","Code","controls.CodeControl","CodeBlock","controls.CodeBlockControl","controls.RichTextEditorColorPickerControl","Color","controls.RichTextEditorColorControl","Highlight","controls.HighlightControl","Hr","controls.HrControl","UnsetColor","controls.UnsetColorControl","Undo","controls.UndoControl","Redo","controls.RedoControl","TaskList","controls.TaskListControl","TaskListSink","controls.TaskListSinkControl","TaskListLift","controls.TaskListLiftControl","TextStyleName","inputRegex","_tiptap_core__WEBPACK_IMPORTED_MODULE_0__","NB","create","addOptions","itemTypeName","HTMLAttributes","keepMarks","keepAttributes","group","parseHTML","tag","renderHTML","P1","addCommands","toggleBulletList","commands","toggleList","updateAttributes","addKeyboardShortcuts","addInputRules","inputRule","S0","find","HardBreak","inline","selectable","linebreakReplacement","renderText","setHardBreak","first","exitCode","command","selection","storedMarks","$from","parent","spec","isolating","splittableMarks","extensionManager","marks","$to","parentOffset","insertContent","tr","dispatch","filteredMarks","filter","mark","includes","ensureMarks","linkify_es_assign","properties","numeric","ascii","alpha","asciinumeric","alphanumeric","domain","emoji","whitespace","addToGroups","t","flags","groups","k","State","j","jr","jd","prototype","accepts","go","nextState","regex","test","has","exactOnly","ta","inputs","next","tt","regexp","ts","len","templateState","apply","flagsForToken","result","c","WORD","UWORD","ASCIINUMERICAL","ALPHANUMERICAL","LOCALHOST","UTLD","SCHEME","SLASH_SCHEME","OPENBRACE","CLOSEBRACE","OPENBRACKET","CLOSEBRACKET","OPENPAREN","CLOSEPAREN","OPENANGLEBRACKET","CLOSEANGLEBRACKET","FULLWIDTHLEFTPAREN","FULLWIDTHRIGHTPAREN","LEFTCORNERBRACKET","RIGHTCORNERBRACKET","LEFTWHITECORNERBRACKET","RIGHTWHITECORNERBRACKET","FULLWIDTHLESSTHAN","FULLWIDTHGREATERTHAN","AMPERSAND","APOSTROPHE","ASTERISK","BACKSLASH","BACKTICK","CARET","COLON","COMMA","DOLLAR","EQUALS","EXCLAMATION","HYPHEN","PERCENT","PIPE","PLUS","POUND","QUERY","QUOTE","FULLWIDTHMIDDLEDOT","SEMI","SLASH","TILDE","UNDERSCORE","EMOJI$1","tk","Object","freeze","__proto__","TLD","NUM","WS","NL","AT","DOT","EMOJI","SYM","ASCII_LETTER","LETTER","DIGIT","SPACE","tlds","utlds","run$1","start","str","iterable","stringToArray","second","charCodeAt","char","replace","toLowerCase","charCount","charCursor","tokenLength","latestAccepting","sinceAccepts","charsSinceAccepts","v","s","fastts","defaultt","decodeTlds","encoded","words","stack","popDigitCount","digits","join","popCount","parseInt","substring","defaults","defaultProtocol","format","noop","formatHref","nl2br","tagName","rel","validate","truncate","Infinity","ignoreTags","render","Options","opts","defaultRender","o","ignoredTags","uppercaseIgnoredTags","toUpperCase","val","MultiToken","createTokenClass","constructor","p","ir","check","get","toString","operator","isCallable","option","getObj","obj","renderFn","isLink","toHref","scheme","toFormattedString","formatted","toFormattedHref","startIndex","endIndex","toObject","protocol","end","toFormattedObject","formattedHref","eventListeners","class","Email","Text","Nl","Url","hasProtocol","makeState","arg","initMultiToken","Multi","startIdx","endIdx","warn","console","INIT","scanner","parser","tokenQueue","pluginQueue","customSchemes","initialized","registerCustomProtocol","optionalSlashSlash","tokenize","init","init$2","Start","Num","Asciinumeric","Alphanumeric","Word","UWord","Cr","Ws","Emoji","EmojiJoiner","wordjr","uwordjr","tld","utld","slashscheme","sort","a","b","sch","init$1","qsAccepting","qsNonAccepting","localpartAccepting","Localpart","Domain","Scheme","SlashScheme","LocalpartAt","LocalpartDot","EmailDomain","EmailDomainDot","Email$1","EmailDomainHyphen","DomainHyphen","DomainDot","DomainDotTld","DomainDotTldColon","DomainDotTldColonPort","Url$1","UrlNonaccept","SchemeColon","SlashSchemeColon","SlashSchemeColonSlash","UriPrefix","bracketPairs","OPEN","CLOSE","UrlOpen","UrlOpenQ","UrlOpenSyms","multis","textTokens","secondState","multiLength","subtokens","Error","filtered","scan","ATTR_WHITESPACE","isAllowedUri","uri","protocols","allowedProtocols","forEach","nextProtocol","match","dist","vc","priority","keepOnSplit","exitable","onCreate","shouldAutoLink","optionalSlashes","onDestroy","inclusive","autolink","openOnClick","linkOnPaste","addAttributes","default","element","getAttribute","getAttrs","dom","defaultValidate","setMark","setMeta","toggleLink","toggleMark","extendEmptyMarkRange","unsetMark","addPasteRules","K9","text","foundLinks","links","item","link","data","_a","addProseMirrorPlugins","plugins","prosemirror_state_dist","Sy","H$","appendTransaction","transactions","oldState","newState","docChanges","some","transaction","docChanged","doc","eq","preventAutolink","getMeta","transform","XP","changes","QC","newRange","textBlock","textBeforeWhitespace","nodesInChangedRanges","b5","node","isTextblock","textBetween","pos","nodeSize","undefined","from","to","endsWith","wordsBeforeWhitespace","split","lastWordBeforeSpace","lastWordAndBlockOffset","lastIndexOf","linksBeforeSpace","schema","code","rangeHasMark","tI","addMark","steps","handleClick","view","_b","button","editable","els","nodeName","parentNode","u9","window","handlePaste","empty","textContent","ListItem","bulletListTypeName","orderedListTypeName","defining","Enter","splitListItem","Tab","hasAttribute","attributesWithoutStart","toggleOrderedList","joinPredicate","childCount","setSubscript","toggleSubscript","unsetSubscript","setSuperscript","toggleSuperscript","unsetSuperscript","TextAlign","hj","types","alignments","defaultAlignment","addGlobalAttributes","textAlign","alignment","setTextAlign","every","response","unsetTextAlign","resetAttributes","consuming","setUnderline","toggleUnderline","unsetUnderline","x","hasRequiredUseSyncExternalStoreShim_production_min","hasRequiredWithSelector_production_min","shim","useSyncExternalStoreShim_production_min","requireUseSyncExternalStoreShim_production_min","is","l","m","useEffect","n","useLayoutEffect","useDebugValue","r","getSnapshot","f","u","document","createElement","inst","g","useSyncExternalStore","shimExports","mergeRefs","refs","current","Portals","contentComponent","renderers","subscribe","getServerSnapshot","react__WEBPACK_IMPORTED_MODULE_0__","Fragment","values","PureEditorContent","Component","editorContentRef","createRef","hasContentComponentInitialized","Boolean","componentDidMount","componentDidUpdate","isDestroyed","append","childNodes","setOptions","getInstance","subscribers","Set","add","callback","delete","setRenderer","renderer","react_dom__WEBPACK_IMPORTED_MODULE_1__","createPortal","reactElement","subscriber","removeRenderer","nextRenderers","unsubscribeToContentComponent","prevState","createNodeViews","componentWillUnmount","setProps","nodeViews","firstChild","newElement","innerRef","rest","EditorContentWithKey","floor","memo","deepEqual","equal","Array","isArray","Map","entries","ArrayBuffer","isView","RegExp","source","valueOf","keys","hasOwnProperty","call","$$typeof","__esModule","withSelector","withSelector_production_min","requireWithSelector_production_min","q","h","useRef","w","useSyncExternalStoreWithSelector","hasValue","withSelectorExports","useIsomorphicLayoutEffect","EditorStateManager","initialEditor","transactionNumber","lastTransactionNumber","lastSnapshot","bind","watch","nextEditor","fn","currentEditor","on","off","isSSR","isNext","EditorInstanceManager","subscriptions","isComponentMounted","previousDeps","instanceId","setEditor","getInitialEditor","scheduleDestroy","getEditor","refreshEditorInstance","onRender","createEditor","cb","immediatelyRender","optionsToApply","onBeforeCreate","args","onBlur","onFocus","onSelectionUpdate","onTransaction","onUpdate","onContentError","onDrop","onPaste","_tiptap_core__WEBPACK_IMPORTED_MODULE_2__","ML","onStoreChange","deps","clearTimeout","scheduledDestructionTimeout","isEditable","dep","destroy","currentInstanceId","setTimeout","useEditor","mostRecentOptions","instanceManager","useEditorState","editorStateManager","selectedState","selector","equalityFn","shouldRerenderOnTransaction","EditorContext","createContext","Consumer","ReactNodeViewContext","onDragStart","useReactNodeView","useContext","Tag","as","whiteSpace","setBlockquote","wrapIn","toggleBlockquote","toggleWrap","unsetBlockquote","lift","starInputRegex","starPasteRegex","underscoreInputRegex","underscorePasteRegex","fontWeight","clearMark","setBold","toggleBold","unsetBold","Cf","dist_inputRegex","pasteRegex","excludes","setCode","toggleCode","unsetCode","backtickInputRegex","tildeInputRegex","languageClassPrefix","exitOnTripleEnter","exitOnArrowDown","defaultLanguage","language","firstElementChild","classList","startsWith","rendered","preserveWhitespace","setCodeBlock","setNode","toggleCodeBlock","toggleNode","Backspace","$anchor","isAtStart","clearNodes","isAtEnd","endsWithDoubleNewline","ArrowDown","nodeAt","setSelection","Y1","near","resolve","zK","clipboardData","getData","vscode","vscodeData","JSON","parse","mode","textNode","replaceSelectionWith","Bs","max","Document","topNode","DropCursorView","editorView","cursorPos","timeout","handlers","handler","addEventListener","removeEventListener","update","setCursor","updateOverlay","removeChild","parentLeft","parentTop","$pos","isBlock","inlineContent","rect","before","nodeBefore","nodeAfter","nodeDOM","nodeRect","getBoundingClientRect","top","bottom","left","right","coords","coordsAtPos","offsetParent","appendChild","cssText","backgroundColor","body","getComputedStyle","position","scrollLeft","scrollTop","pageXOffset","pageYOffset","scheduleRemoval","dragover","posAtCoords","clientX","clientY","inside","disableDropCursor","dragging","point","prosemirror_transform_dist","nj","dragend","drop","dragleave","contains","relatedTarget","Dropcursor","dropCursor","GapCursor","mapping","head","valid","prosemirror_model_dist","p2","other","toJSON","fromJSON","json","getBookmark","GapBookmark","anchor","closedBefore","depth","child","lastChild","isAtom","closedAfter","indexAfter","override","allowGapCursor","deflt","contentMatchAt","defaultType","findGapCursorFrom","dir","mustMove","search","$cur","isText","qv","isSelectable","visible","findFrom","jsonID","handleKeyDown","prosemirror_keymap_dist","$","arrow","axis","dirStr","sel","$start","endOfTextblock","$found","clickPos","beforeinput","inputType","insert","findWrapping","nodes","frag","HY","createAndFill","drawGapCursor","prosemirror_view_dist","EH","widget","Gapcursor","decorations","createSelectionBetween","_view","$head","handleDOMEvents","extendNodeSchema","extension","context","storage","nU","Heading","levels","hasLevel","setHeading","toggleHeading","reduce","items","RopeSequence","leafAppend","leafPrepend","appendInner","prepend","Append","sliceInner","min","getInner","forEachInner","forEachInvertedInner","elt","Leaf","prototypeAccessors","configurable","flatten","defineProperties","leftLen","inner","Branch","eventCount","popEvent","preserveItems","remap","mapFrom","remaining","remapping","maps","addAfter","addBefore","step","Item","maybeStep","appendMap","reverse","addTransform","histOptions","cutPoint","newItems","oldItems","lastItem","invert","docs","merged","merge","overflow","DEPTH_OVERFLOW","vs","mirrorPos","mirrorOffset","addMaps","array","rebased","rebasedTransform","rebasedCount","rebasedItems","newUntil","iRebased","getMirror","newMaps","branch","emptyItemCount","compress","count","upto","getMap","newItem","last","rope_sequence_dist","HistoryState","done","undone","prevRanges","prevTime","prevComposition","rangesFor","_from","_to","mapRanges","ranges","cachedPreserveItems","cachedPreserveItemsPlugins","mustPreserveItems","historyPreserveItems","historyKey","closeHistoryKey","buildCommand","scroll","hist","getState","histTransaction","history","config","added","newHist","historyState","scrollIntoView","History","newGroupDelay","dist_history","applyTransaction","historyTr","appended","composition","newGroup","time","isAdjacentTo","adjacent","HorizontalRule","setHorizontalRule","$originFrom","$originTo","currentChain","insertContentAt","EG","posAfter","contentMatch","x2","dist_starInputRegex","dist_starPasteRegex","dist_underscoreInputRegex","dist_underscorePasteRegex","fontStyle","setItalic","toggleItalic","unsetItalic","Paragraph","setParagraph","extension_strike_dist_inputRegex","dist_pasteRegex","Strike","setStrike","toggleStrike","unsetStrike","StarterKit","addExtensions","_c","_d","_e","_f","_g","_h","_j","_k","_l","_m","_o","_p","_q","_r","_s","_t","extensions","bold","configure","blockquote","bulletList","extension_bullet_list_dist","DY","codeBlock","dropcursor","gapcursor","hardBreak","extension_hard_break_dist","U","heading","horizontalRule","italic","listItem","extension_list_item_dist","H","orderedList","extension_ordered_list_dist","GS","paragraph","strike","deleteSelection","atBlockStart","$cursor","joinBackward","$cut","findCutBefore","range","blockRange","prosemirror_transform__WEBPACK_IMPORTED_MODULE_0__","k9","deleteBarrier","textblockAt","prosemirror_state__WEBPACK_IMPORTED_MODULE_1__","delStep","dR","prosemirror_model__WEBPACK_IMPORTED_MODULE_2__","joinTextblockBackward","joinTextblocksAround","joinTextblockForward","atBlockEnd","findCutAfter","beforeText","beforePos","afterText","afterPos","Pu","side","only","selectNodeBackward","joinForward","selectNodeForward","joinUp","nodeSel","Mn","GJ","joinDown","newlineInCode","sameParent","insertText","defaultBlockAt","edgeCount","edge","hasRequiredAttrs","above","canReplaceWith","replaceWith","createParagraphNear","C1","liftEmptyBlock","Ax","selectParentNode","same","sharedDepth","conn","isolated","compatibleContent","canReplace","canDelAfter","matchType","validEnd","wrap","copy","FC","$joinAt","selAfter","at","afterDepth","selectTextblockSide","selectTextblockStart","selectTextblockEnd","nodeType","wrapping","nd","setBlockType","applicable","nodesBetween","hasMarkup","chainCommands","backspace","del","pcBaseKeymap","splitDepth","atEnd","atStart","splitType","splitPos","$first","setNodeMarkup","macBaseKeymap","navigator","platform","os","base","shift","mac","ie","exec","userAgent","String","fromCharCode","dist_mac","modifiers","altKey","ctrlKey","metaKey","shiftKey","keymap","bindings","keydownHandler","normalize","prop","normalizeKeyName","alt","ctrl","meta","parts","keyCode","baseName","direct","noShift","fromCode","OrderedMap","found","newKey","self","remove","splice","addToStart","addToEnd","place","without","subtract","nodeStart","descendants","blockSeparator","leafText","nodeText","isLeaf","sameMarkup","withText","cut","cutByIndex","replaceChild","maybeChild","findDiffStart","childA","childB","findDiffEnd","otherPos","posA","posB","iA","iB","minSize","findIndex","round","retIndex","curPos","cur","toStringInner","nodeFromJSON","fromArray","joined","compareDeep","Mark","addToSet","set","placed","rank","removeFromSet","isInSet","_","checkAttrs","sameSet","setFrom","none","ReplaceError","Slice","openStart","openEnd","insertAt","fragment","insertInto","removeBetween","removeRange","indexTo","offsetTo","maxOpen","openIsolating","checkJoin","main","sub","joinable","$before","$after","addNode","addRange","$end","textOffset","dist_close","checkContent","replaceTwoWay","ResolvedPos","path","resolveDepth","dOff","posAtIndex","tmp","marksAcross","pred","NodeRange","resolveCached","cache","resolveCache","elts","ResolveCache","resolveCacheSize","WeakMap","emptyAttrs","Node","startPos","defaultAttrs","includeParents","replaceOuter","prepareSliceForReplace","$along","extra","resolveNoCache","replaceThreeWay","childAfter","childBefore","toDebugString","wrapMarks","matchFragment","replacement","one","two","allowsMarks","canAppend","markFromJSON","TextNode","stringify","ContentMatch","wrapCache","string","nodeTypes","nfa","labeled","stream","TokenStream","expr","parseExpr","exprs","parseExprSeq","parseExprSubscript","parseExprAtom","eat","err","resolveName","typeName","isInGroup","parseExprRange","parseNum","connect","compile","out","loop","term","edges","explore","states","nullFrom","cmp","checkForDeadEnds","work","dead","compatible","fillBefore","toEnd","seen","finished","tp","computed","computeWrapping","via","tok","Number","attrName","hasDefault","computeAttrs","built","given","initAttrs","Attribute","NodeType","markSet","atom","isRequired","createChecked","matched","validContent","allowsMarkType","markType","allowedMarks","topType","MarkType","excluded","instance","Schema","cached","instanceSpec","contentExprCache","contentExpr","markExpr","gatherMarks","excl","topNodeType","wrappings","ok","DOMParser","rules","tags","matchedStyles","rule","normalizeLists","ParseContext","addAll","finish","parseSlice","matchTag","matches","msMatchesSelector","webkitMatchesSelector","mozMatchesSelector","namespace","namespaceURI","matchesContext","matchStyle","schemaRules","nextPriority","parseDOM","ignore","fromSchema","domParser","blockTags","address","article","aside","canvas","dd","div","dl","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","hr","li","noscript","ol","output","pre","section","table","tfoot","ul","object","script","listTags","wsOptionsFor","OPT_PRESERVE_WS","NodeContext","solid","activeMarks","inlineContext","isOpen","localPreserveWS","topContext","topOptions","topMatch","findPositions","needsBlock","addDOM","addTextNode","addElement","nodeValue","preserveWS","domNodeBefore","previousSibling","insertNode","findInText","findInside","matchAfter","outerWS","ruleID","normalizeList","prevItem","nextSibling","ruleFromNode","ignoreFallback","skip","closeParent","sync","oldNeedsBlock","leafFallback","innerMarks","readStyles","addElementByRule","ownerDocument","createTextNode","findPlace","getPropertyValue","continueAfter","enter","startIn","getContent","contentDOM","contentElement","querySelector","findAround","findAtPoint","route","cx","enterInner","block","textblockFromContext","closeExtra","nodeMarks","markMayApply","applyMarks","topOpen","currentPos","compareDocumentPosition","useRoot","minDepth","part","$context","DOMSerializer","serializeFragment","createDocumentFragment","keep","spanning","markDOM","serializeMark","serializeNodeInner","renderSpec","serializeNode","toDOM","structure","xmlNS","blockArraysIn","domSerializer","nodesFromSchema","marksFromSchema","gatherToDOM","suspiciousAttributeCache","suspicious","space","createElementNS","setAttributeNS","setAttribute","innerContent","wrapInList","listType","wrapRangeInList","doJoin","outerRange","$insert","prosemirror_model__WEBPACK_IMPORTED_MODULE_0__","Ts","prosemirror_transform__WEBPACK_IMPORTED_MODULE_1__","doWrapInList","wrappers","joinBefore","itemType","liftToOuterList","endOfList","liftOutOfList","list","indexBefore","nestedBefore","classesById","Selection","SelectionRange","lastNode","lastParent","replaceRange","selectionToInsertionEnd","deleteRange","replaceRangeWith","textOnly","TextSelection","findSelectionIn","bias","AllSelection","cls","selectionClass","between","warnedAboutTextSelection","checkTextSelection","TextBookmark","dPos","NodeSelection","deleted","mapResult","NodeBookmark","AllBookmark","startLen","_newFrom","newTo","Transaction","wx","curSelectionFor","updated","Date","now","curSelection","selectionSet","setStoredMarks","addStoredMark","removeStoredMark","storedMarksSet","addStep","setTime","replaceSelection","inheritMarks","isGeneric","scrolledIntoView","FieldDesc","desc","baseFields","_marks","_old","prev","Configuration","pluginsByKey","fields","plugin","EditorState","filterTransaction","rootTr","trs","applyInner","haveNew","newInstance","field","$config","reconfigure","pluginFields","Plugin","bindProps","Function","createKey","PluginKey","MapResult","delInfo","recover","deletedBefore","deletedAfter","deletedAcross","StepMap","inverted","diff","assoc","_map","simple","oldIndex","newIndex","oldSize","newSize","touches","oldStart","newStart","Mapping","mirror","mirrors","setMirror","appendMapping","startSize","mirr","appendMappingInverted","totalSize","inverse","corr","stepsByID","Step","stepType","stepClass","StepResult","failed","fail","message","fromReplace","e4","mapFragment","mapped","AddMarkStep","oldSlice","RemoveMarkStep","AddNodeMarkStep","newSet","RemoveNodeMarkStep","ReplaceStep","contentBetween","ReplaceAroundStep","gapFrom","gapTo","inserted","clearIncompatible","parentType","clearNewlines","replSteps","allowed","newline","liftTarget","innerRange","around","findWrappingOutside","outer","findWrappingInside","innerMatch","lastType","withAttrs","replaceNewlines","replaceLinebreaks","canSplit","typesAfter","innerType","overrideChild","baseType","canJoin","canAppendWithSubstitutedLinebreaks","joinPoint","dropPoint","pass","insertPos","fits","replaceStep","Fitter","fit","fitsTrivially","unplaced","frontier","findFittable","placeNodes","openMore","dropNode","moveInline","mustMoveInline","placedSize","startDepth","sliceDepth","contentAt","frontierDepth","inject","openAtEnd","dropFromFragment","closeFrontierNode","openFrontierNode","taken","openEndCount","closeNodeStart","addToFragment","contentAfterFits","findCloseLevel","dropInner","move","invalidMarks","coveredDepths","AttrStep","DocAttrStep","TransformError","Transform","targetDepths","preferredTarget","definingAsContext","preferredTargetIndex","leftNodes","preferredDepth","leftNode","def","definingForContent","abs","openDepth","targetDepth","expand","closeFragment","oldOpen","newOpen","startSteps","insertPoint","covered","gapStart","gapEnd","splitting","convertNewlines","beforeType","supportLinebreak","$full","attrsHere","startM","endM","newNode","setNodeAttribute","setDocAttribute","addNodeMark","removeNodeMark","typeAfter","removing","adding","removed","removeMark","toRemove","ZU","CharCodes","BinTrieFlags","EntityDecoderState","DecodingMode","EntityLevel","EncodingMode","decode_DecodingMode","decodeCache","decode","exclude","defaultChars","getDecodeCache","ch","seq","b1","b2","chr","b3","b4","componentChars","lib_decode","encodeCache","encode","keepEscaped","getEncodeCache","nextCode","encodeURIComponent","lib_encode","slashes","auth","hostname","port","pathname","hash","protocolPattern","portPattern","simplePathPattern","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","hostlessProtocol","javascript","slashedProtocol","http","https","ftp","gopher","file","slashesDenoteHost","lowerProto","hec","trim","simplePath","proto","substr","atSign","hostEnd","host","parseHost","ipv6Hostname","hostparts","newpart","validParts","notHost","bit","qm","S_regex","Any_regex","Cc_regex","Cf_regex","Z_regex","decode_data_html","Uint16Array","decode_data_xml","decodeMap","fromCodePoint","codePoint","isNumber","ZERO","NINE","EntityDecoder","decodeTree","emitCodePoint","errors","EntityStart","consumed","treeIndex","excess","decodeMode","Strict","startEntity","write","NumericStart","stateNumericStart","NamedEntity","stateNamedEntity","NumericDecimal","stateNumericDecimal","NumericHex","stateNumericHex","LOWER_X","addToNumericResult","digitCount","pow","UPPER_A","UPPER_F","LOWER_A","LOWER_F","emitNumericEntity","lastCp","expectedLength","absenceOfDigitsInNumericCharacterReference","missingSemicolonAfterCharacterReference","validateNumericCharacterReference","valueLength","VALUE_LENGTH","determineBranch","nodeIdx","branchCount","BRANCH_LENGTH","jumpOffset","JUMP_TABLE","lo","hi","mid","midVal","isEntityInAttributeInvalidEnd","UPPER_Z","LOWER_Z","emitNotTerminatedNamedEntity","emitNamedEntityData","getDecoder","ret","decoder","lastIndex","htmlDecoder","decode_decodeHTML","Legacy","xmlCodeMap","getEscaper","lastIdx","isString","_class","codePointAt","_hasOwnProperty","utils_assign","sources","arguments","arrayReplaceAt","src","newElements","isValidEntityCode","utils_fromCodePoint","UNESCAPE_MD_RE","UNESCAPE_ALL_RE","ENTITY_RE","DIGITAL_ENTITY_TEST_RE","unescapeMd","unescapeAll","escaped","entity","replaceEntityPattern","decoded","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","escapeHtml","REGEXP_ESCAPE_RE","escapeRE","isSpace","isWhiteSpace","isPunctChar","isMdAsciiPunct","normalizeReference","lib","mdurl","mdurl_namespaceObject","ucmicro","uc_micro_namespaceObject","parseLinkLabel","disableNested","marker","prevPos","posMax","oldPos","skipToken","labelEnd","parseLinkDestination","parseLinkTitle","prev_state","can_continue","default_rules","Renderer","Ruler","__rules__","__cache__","nesting","markup","info","hidden","StateCore","env","inlineMode","code_inline","idx","slf","renderAttrs","code_block","fence","highlighted","langName","langAttrs","arr","highlight","tmpAttrs","langPrefix","image","renderInlineAsText","renderToken","hardbreak","xhtmlOut","softbreak","breaks","html_block","html_inline","needLf","nextToken","renderInline","__find__","__compile__","chains","altName","opt","beforeName","ruleName","afterName","enable","ignoreInvalid","enableOnly","disable","getRules","chainName","attrData","attrGet","attrJoin","NEWLINES_RE","NULL_RE","RARE_RE","SCOPED_ABBR_TEST_RE","SCOPED_ABBR_RE","SCOPED_ABBR","tm","replaceFn","QUOTE_TEST_RE","QUOTE_RE","replaceAt","_rules","blockTokens","linkify","pretest","htmlLinkLevel","currentToken","isLinkOpen","lastPos","ln","fullUrl","normalizeLink","validateLink","urlText","normalizeLinkText","token_o","token_t","token_c","blkIdx","typographer","replace_scoped","inlineTokens","inside_autolink","replace_rare","process_inlines","thisLevel","OUTER","canOpen","canClose","isSingle","lastChar","nextChar","isLastPunctChar","isNextPunctChar","isLastWhiteSpace","isNextWhiteSpace","single","openQuote","closeQuote","quotes","curr","Core","StateBlock","bMarks","eMarks","tShift","sCount","bsCount","blkIndent","line","lineMax","tight","ddIndent","listIndent","indent","indent_found","getLine","escapedSplit","isEscaped","skipBulletListMarker","startLine","skipOrderedListMarker","process","isEmpty","skipEmptyLines","skipSpaces","skipSpacesBack","skipChars","skipCharsBack","getLines","begin","keepLastLF","queue","lineIndent","lineStart","open_tag","close_tag","HTML_TAG_RE","HTML_OPEN_CLOSE_TAG_RE","HTML_SEQUENCES","parser_block_rules","endLine","silent","tbodyLines","nextLine","firstCh","secondCh","lineText","columns","aligns","columnCount","oldParentType","terminatorRules","token_to","tableLines","token_tho","token_htro","token_ho","token_il","autocompletedCells","terminate","token_tbo","token_tro","token_tdo","mem","params","haveEndMarker","oldLineMax","oldBMarks","oldBSCount","oldSCount","oldTShift","lastLineEmpty","isOutdented","spaceAfterMarker","adjustTab","initial","oldIndent","lines","cnt","isOrdered","markerValue","posAfterMarker","isTerminatingParagraph","markerCharCode","listTokIdx","listLines","prevEmptyEnd","indentAfterMarker","contentStart","itemLines","oldTight","oldListIndent","markTightParagraphs","_endLine","getNextLine","isContinuation","lineContent","destRes","helpers","destEndPos","destEndLineNo","titleRes","references","html","token_i","ParserBlock","StateInline","outTokens","tokens_meta","pending","pendingLevel","delimiters","_prev_delimiters","backticks","backticksScanned","linkLevel","maxNesting","hasEmptyLines","prevLine","pushPending","token_meta","scanDelims","canSplitWord","left_flanking","right_flanking","can_open","can_close","SCHEME_RE","ESCAPED","postProcess","loneMarkers","startDelim","endDelim","emphasis_postProcess","isStrong","EMAIL_RE","AUTOLINK_RE","DIGITAL_RE","NAMED_RE","processDelimiters","openersBottom","headerIdx","lastTokenIdx","jumps","closerIdx","closer","minOpenerIdx","openerIdx","newMinOpenerIdx","opener","isOddMatch","lastJump","parser_inline_rules","isTerminatorChar","matchAtStart","pmax","ws","ch1","escapedStr","ch2","origStr","matchStart","openerLength","matchEnd","closerLength","scanned","res","parseReference","labelStart","isLetter","lc","_rules2","ParserInline","ruler2","linkify_it_assign","linkify_it_class","isFunction","linkify_it_escapeRE","defaultOptions","fuzzyLink","fuzzyEmail","fuzzyIP","defaultSchemas","tail","re","src_auth","src_host_port_strict","src_path","no_http","src_domain","src_domain_root","src_port","src_host_terminator","mailto","src_email_name","src_host_strict","tlds_default","createNormalizer","lib_re","src_Any","src_Cc","src_Z","src_P","src_ZPCc","src_ZCc","text_separators","src_pseudo_letter","src_ip4","src_xn","src_host","tpl_host_fuzzy","tpl_host_no_ip_fuzzy","tpl_host_fuzzy_strict","tpl_host_port_fuzzy_strict","tpl_host_port_no_ip_fuzzy_strict","tpl_host_fuzzy_test","tpl_email_fuzzy","tpl_link_fuzzy","tpl_link_no_ip_fuzzy","__opts__","__tlds__","untpl","tpl","src_tlds","onCompile","__tlds_replaced__","email_fuzzy","link_fuzzy","link_no_ip_fuzzy","host_fuzzy_test","aliases","schemaError","__compiled__","__schemas__","compiled","alias","slist","schema_test","schema_search","schema_at_start","__index__","__text_cache__","Match","__last_index__","__schema__","raw","createMatch","LinkifyIt","schemas","acc","definition","ml","me","tld_pos","testSchemaAt","at_pos","keepOld","el","regexPunycode","regexNonASCII","regexSeparators","stringFromCharCode","error","mapDomain","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","baseMinusTMin","punycode_es6_decode","inputLength","basic","oldi","maxInt","baseMinusT","punycode_es6_encode","ucs2decode","counter","currentValue","basicLength","handledCPCount","handledCPCountPlusOne","qMinusT","punycode_es6","components","zero","rules2","commonmark","BAD_PROTO_RE","GOOD_DATA_RE","RECODE_HOSTNAME_FOR","parsed","toASCII","er","toUnicode","MarkdownIt","presetName","utils","utils_namespaceObject","helpers_namespaceObject","presets","missed","use","parseInline","V_","horizontal_rule","ordered_list","order","bullet_list","list_item","draggable","hard_break","em","strong","MarkdownParseState","tokenHandlers","addText","maybeMerge","openMark","closeMark","parseTokens","toks","openNode","closeNode","noCloseToken","withoutTrailingNewline","noOp","MarkdownParser","tokenizer","markdownEnv","listIsTight","markdown_it_lib","blankMark","mixable","MarkdownSerializer","serialize","assign","dist_MarkdownSerializerState","renderContent","defaultMarkdownSerializer","wrapBlock","closeBlock","repeat","renderList","bullet","maxW","nStr","esc","inAutolink","expelEnclosingWhitespace","isPlainURL","_state","_mark","backticksFor","escape","ticks","delim","closed","inTightList","tightLists","hardBreakNodeName","flushClose","atBlank","delimMin","getMark","strict","firstDelim","old","ensureNewLine","fromBlockStart","trailing","progress","leading","lead","trail","noEsc","markString","isTight","prevTight","startOfLine","escapeExtraCharacters","quote","getEnclosingWhitespace","__defProp","defineProperty","__defNormalProp","enumerable","writable","__publicField","MarkdownTightLists","tightClass","listTypes","_this","toggleTight","_ref","shiftDelim","MarkdownSerializerState","inlines","delimiter","normalizeInline","trimEnd","trimStart","charAt","HTMLMark","addStorage","markdown","_getMarkTags$","_getMarkTags","getMarkTags","_getMarkTags$2","_getMarkTags2","d1","elementFromString","wrappedValue","parseFromString","HTMLNode","serializeHTML","formatBlock","innerHTML","outerHTML","Blockquote$1","extend","BulletList$1","bulletListMarker","CodeBlock$1","setup","markdownit2","_this$options$languag","updateDOM","HardBreak$1","inTable","Heading$1","HorizontalRule$1","Image$1","Image","ListItem$1","OrderedList$1","separator","adjacentIndex","Paragraph$1","_node$content$content","_node$content","Table$1","Table","isMarkdownSerializable","rows","firstRow","bodyRows","cell","hasSpan","row","col","cellContent","delimiterRow","colspan","rowspan","TaskItem$1","TaskItem","checked","querySelectorAll","TaskList$1","markdown_it_task_lists","Text$1","Bold$1","Code$1","markdownExtensions","getMarkdownSpec","_extension$storage","_markdownExtensions$f","markdownSpec","defaultMarkdownSpec","tiptap_markdown_es_MarkdownSerializer","_this$editor$extensio","fromEntries","_this$editor$extensio2","_getMarkdownSpec","_getMarkdownSpec2","tiptap_markdown_es_MarkdownParser","withPatchedRenderer","normalizeDOM","_ref2","normalizeBlocks","_el$nextSibling","TEXT_NODE","closest","blocks","node2","_block$spec$parseDOM","flat","parentElement","extractElement","cloneNode","insertBefore","_node$firstElementChi","_content$match$","_content$match","_content$match$2","_content$match2","firstParagraph","nextElementSibling","startSpaces","endSpaces","unwrapElement","md2","withoutNewLine","MarkdownClipboard","transformPastedText","transformCopiedText","clipboardTextParser","plainText","aw","clipboardTextSerializer","serializer","Markdown","tightListClass","Rw","Commands","setContent","emitUpdate","parseOptions","getMarkdown","initialContent"],"sourceRoot":""}