@siladev/qalam 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,18 +1,1953 @@
-import { validateAST as e } from "./schema/index.js";
-import { Q as s, a as t } from "./QalamEditor-sYrI0Izl.js";
-import { Q as f } from "./QalamRenderer-CQRQmyKZ.js";
-import { resolveAST as d } from "./resolver/index.js";
-import { g as Q, a as p, b as u, i as S, l as g, r as i } from "./lookup-CFbcujyG.js";
+import { validateAST as Kt } from "./schema/index.js";
+import { E as ze, c as C, f as Ce, g as H, b as ve, i as Ee, P as _e, d as Ie, e as Pe, h as Le, j as Be, k as He, B as Oe, l as qe, a as Ne, H as De, m as Fe, n as Qe, I as Ze, o as je, p as We, q as Ge, L as Xe } from "./QalamEditor-BimErEqm.js";
+import { Q as Jt } from "./QalamEditor-BimErEqm.js";
+import { Q as Yt } from "./QalamRenderer-CbbJYMLn.js";
+import { resolveAST as tn } from "./resolver/index.js";
+import { g as rn, a as sn, b as an, i as ln, l as on, r as cn } from "./lookup-CFbcujyG.js";
+function ee() {
+  return { async: !1, breaks: !1, extensions: null, gfm: !0, hooks: null, pedantic: !1, renderer: null, silent: !1, tokenizer: null, walkTokens: null };
+}
+var P = ee();
+function fe(t) {
+  P = t;
+}
+var _ = { exec: () => null };
+function k(t, e = "") {
+  let n = typeof t == "string" ? t : t.source, s = { replace: (r, i) => {
+    let a = typeof i == "string" ? i : i.source;
+    return a = a.replace(S.caret, "$1"), n = n.replace(r, a), s;
+  }, getRegex: () => new RegExp(n, e) };
+  return s;
+}
+var Ke = (() => {
+  try {
+    return !!new RegExp("(?<=1)(?<!1)");
+  } catch {
+    return !1;
+  }
+})(), S = { codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] +\S/, listReplaceTask: /^\[[ xX]\] +/, listTaskCheckbox: /\[[ xX]\]/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^<a /i, endATag: /^<\/a>/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^</, endAngleBracket: />$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (t) => new RegExp(`^( {0,3}${t})((?:[	 ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: (t) => new RegExp(`^ {0,${Math.min(3, t - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`), hrRegex: (t) => new RegExp(`^ {0,${Math.min(3, t - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), fencesBeginRegex: (t) => new RegExp(`^ {0,${Math.min(3, t - 1)}}(?:\`\`\`|~~~)`), headingBeginRegex: (t) => new RegExp(`^ {0,${Math.min(3, t - 1)}}#`), htmlBeginRegex: (t) => new RegExp(`^ {0,${Math.min(3, t - 1)}}<(?:[a-z].*>|!--)`, "i"), blockquoteBeginRegex: (t) => new RegExp(`^ {0,${Math.min(3, t - 1)}}>`) }, Ue = /^(?:[ \t]*(?:\n|$))+/, Je = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/, Ve = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/, D = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/, Ye = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/, te = / {0,3}(?:[*+-]|\d{1,9}[.)])/, xe = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/, me = k(xe).replace(/bull/g, te).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex(), et = k(xe).replace(/bull/g, te).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex(), ne = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/, tt = /^[^\n]+/, re = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/, nt = k(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", re).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(), rt = k(/^(bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, te).getRegex(), G = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul", se = /<!--(?:-?>|[\s\S]*?(?:-->|$))/, st = k("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))", "i").replace("comment", se).replace("tag", G).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(), we = k(ne).replace("hr", D).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", G).getRegex(), it = k(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", we).getRegex(), ie = { blockquote: it, code: Je, def: nt, fences: Ve, heading: Ye, hr: D, html: st, lheading: me, list: rt, newline: Ue, paragraph: we, table: _, text: tt }, ce = k("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", D).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", G).getRegex(), at = { ...ie, lheading: et, table: ce, paragraph: k(ne).replace("hr", D).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", ce).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", G).getRegex() }, lt = { ...ie, html: k(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", se).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: _, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: k(ne).replace("hr", D).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", me).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() }, ot = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/, ct = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/, be = /^( {2,}|\\)\n(?!\s*$)/, ht = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/, L = /[\p{P}\p{S}]/u, X = /[\s\p{P}\p{S}]/u, ae = /[^\s\p{P}\p{S}]/u, pt = k(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, X).getRegex(), ye = /(?!~)[\p{P}\p{S}]/u, ut = /(?!~)[\s\p{P}\p{S}]/u, dt = /(?:[^\s\p{P}\p{S}]|~)/u, gt = k(/link|precode-code|html/, "g").replace("link", /\[(?:[^\[\]`]|(?<a>`+)[^`]+\k<a>(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-", Ke ? "(?<!`)()" : "(^^|[^`])").replace("code", /(?<b>`+)[^`]+\k<b>(?!`)/).replace("html", /<(?! )[^<>]*?>/).getRegex(), Te = /^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/, kt = k(Te, "u").replace(/punct/g, L).getRegex(), ft = k(Te, "u").replace(/punct/g, ye).getRegex(), Re = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)", xt = k(Re, "gu").replace(/notPunctSpace/g, ae).replace(/punctSpace/g, X).replace(/punct/g, L).getRegex(), mt = k(Re, "gu").replace(/notPunctSpace/g, dt).replace(/punctSpace/g, ut).replace(/punct/g, ye).getRegex(), wt = k("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, ae).replace(/punctSpace/g, X).replace(/punct/g, L).getRegex(), bt = k(/^~~?(?:((?!~)punct)|[^\s~])/, "u").replace(/punct/g, L).getRegex(), yt = "^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)", Tt = k(yt, "gu").replace(/notPunctSpace/g, ae).replace(/punctSpace/g, X).replace(/punct/g, L).getRegex(), Rt = k(/\\(punct)/, "gu").replace(/punct/g, L).getRegex(), St = k(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(), $t = k(se).replace("(?:-->|$)", "-->").getRegex(), Mt = k("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", $t).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(), Z = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/, At = k(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label", Z).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(), Se = k(/^!?\[(label)\]\[(ref)\]/).replace("label", Z).replace("ref", re).getRegex(), $e = k(/^!?\[(ref)\](?:\[\])?/).replace("ref", re).getRegex(), zt = k("reflink|nolink(?!\\()", "g").replace("reflink", Se).replace("nolink", $e).getRegex(), he = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/, le = { _backpedal: _, anyPunctuation: Rt, autolink: St, blockSkip: gt, br: be, code: ct, del: _, delLDelim: _, delRDelim: _, emStrongLDelim: kt, emStrongRDelimAst: xt, emStrongRDelimUnd: wt, escape: ot, link: At, nolink: $e, punctuation: pt, reflink: Se, reflinkSearch: zt, tag: Mt, text: ht, url: _ }, Ct = { ...le, link: k(/^!?\[(label)\]\((.*?)\)/).replace("label", Z).getRegex(), reflink: k(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", Z).getRegex() }, J = { ...le, emStrongRDelimAst: mt, emStrongLDelim: ft, delLDelim: bt, delRDelim: Tt, url: k(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol", he).replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: k(/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|protocol:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/).replace("protocol", he).getRegex() }, vt = { ...J, br: k(be).replace("{2,}", "*").getRegex(), text: k(J.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() }, F = { normal: ie, gfm: at, pedantic: lt }, O = { normal: le, gfm: J, breaks: vt, pedantic: Ct }, Et = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }, pe = (t) => Et[t];
+function z(t, e) {
+  if (e) {
+    if (S.escapeTest.test(t)) return t.replace(S.escapeReplace, pe);
+  } else if (S.escapeTestNoEncode.test(t)) return t.replace(S.escapeReplaceNoEncode, pe);
+  return t;
+}
+function ue(t) {
+  try {
+    t = encodeURI(t).replace(S.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return t;
+}
+function de(t, e) {
+  let n = t.replace(S.findPipe, (i, a, o) => {
+    let l = !1, h = a;
+    for (; --h >= 0 && o[h] === "\\"; ) l = !l;
+    return l ? "|" : " |";
+  }), s = n.split(S.splitPipe), r = 0;
+  if (s[0].trim() || s.shift(), s.length > 0 && !s.at(-1)?.trim() && s.pop(), e) if (s.length > e) s.splice(e);
+  else for (; s.length < e; ) s.push("");
+  for (; r < s.length; r++) s[r] = s[r].trim().replace(S.slashPipe, "|");
+  return s;
+}
+function q(t, e, n) {
+  let s = t.length;
+  if (s === 0) return "";
+  let r = 0;
+  for (; r < s && t.charAt(s - r - 1) === e; )
+    r++;
+  return t.slice(0, s - r);
+}
+function _t(t, e) {
+  if (t.indexOf(e[1]) === -1) return -1;
+  let n = 0;
+  for (let s = 0; s < t.length; s++) if (t[s] === "\\") s++;
+  else if (t[s] === e[0]) n++;
+  else if (t[s] === e[1] && (n--, n < 0)) return s;
+  return n > 0 ? -2 : -1;
+}
+function It(t, e = 0) {
+  let n = e, s = "";
+  for (let r of t) if (r === "	") {
+    let i = 4 - n % 4;
+    s += " ".repeat(i), n += i;
+  } else s += r, n++;
+  return s;
+}
+function ge(t, e, n, s, r) {
+  let i = e.href, a = e.title || null, o = t[1].replace(r.other.outputLinkReplace, "$1");
+  s.state.inLink = !0;
+  let l = { type: t[0].charAt(0) === "!" ? "image" : "link", raw: n, href: i, title: a, text: o, tokens: s.inlineTokens(o) };
+  return s.state.inLink = !1, l;
+}
+function Pt(t, e, n) {
+  let s = t.match(n.other.indentCodeCompensation);
+  if (s === null) return e;
+  let r = s[1];
+  return e.split(`
+`).map((i) => {
+    let a = i.match(n.other.beginningSpace);
+    if (a === null) return i;
+    let [o] = a;
+    return o.length >= r.length ? i.slice(r.length) : i;
+  }).join(`
+`);
+}
+var j = class {
+  options;
+  rules;
+  lexer;
+  constructor(t) {
+    this.options = t || P;
+  }
+  space(t) {
+    let e = this.rules.block.newline.exec(t);
+    if (e && e[0].length > 0) return { type: "space", raw: e[0] };
+  }
+  code(t) {
+    let e = this.rules.block.code.exec(t);
+    if (e) {
+      let n = e[0].replace(this.rules.other.codeRemoveIndent, "");
+      return { type: "code", raw: e[0], codeBlockStyle: "indented", text: this.options.pedantic ? n : q(n, `
+`) };
+    }
+  }
+  fences(t) {
+    let e = this.rules.block.fences.exec(t);
+    if (e) {
+      let n = e[0], s = Pt(n, e[3] || "", this.rules);
+      return { type: "code", raw: n, lang: e[2] ? e[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : e[2], text: s };
+    }
+  }
+  heading(t) {
+    let e = this.rules.block.heading.exec(t);
+    if (e) {
+      let n = e[2].trim();
+      if (this.rules.other.endingHash.test(n)) {
+        let s = q(n, "#");
+        (this.options.pedantic || !s || this.rules.other.endingSpaceChar.test(s)) && (n = s.trim());
+      }
+      return { type: "heading", raw: e[0], depth: e[1].length, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  hr(t) {
+    let e = this.rules.block.hr.exec(t);
+    if (e) return { type: "hr", raw: q(e[0], `
+`) };
+  }
+  blockquote(t) {
+    let e = this.rules.block.blockquote.exec(t);
+    if (e) {
+      let n = q(e[0], `
+`).split(`
+`), s = "", r = "", i = [];
+      for (; n.length > 0; ) {
+        let a = !1, o = [], l;
+        for (l = 0; l < n.length; l++) if (this.rules.other.blockquoteStart.test(n[l])) o.push(n[l]), a = !0;
+        else if (!a) o.push(n[l]);
+        else break;
+        n = n.slice(l);
+        let h = o.join(`
+`), c = h.replace(this.rules.other.blockquoteSetextReplace, `
+    $1`).replace(this.rules.other.blockquoteSetextReplace2, "");
+        s = s ? `${s}
+${h}` : h, r = r ? `${r}
+${c}` : c;
+        let p = this.lexer.state.top;
+        if (this.lexer.state.top = !0, this.lexer.blockTokens(c, i, !0), this.lexer.state.top = p, n.length === 0) break;
+        let u = i.at(-1);
+        if (u?.type === "code") break;
+        if (u?.type === "blockquote") {
+          let g = u, f = g.raw + `
+` + n.join(`
+`), w = this.blockquote(f);
+          i[i.length - 1] = w, s = s.substring(0, s.length - g.raw.length) + w.raw, r = r.substring(0, r.length - g.text.length) + w.text;
+          break;
+        } else if (u?.type === "list") {
+          let g = u, f = g.raw + `
+` + n.join(`
+`), w = this.list(f);
+          i[i.length - 1] = w, s = s.substring(0, s.length - u.raw.length) + w.raw, r = r.substring(0, r.length - g.raw.length) + w.raw, n = f.substring(i.at(-1).raw.length).split(`
+`);
+          continue;
+        }
+      }
+      return { type: "blockquote", raw: s, tokens: i, text: r };
+    }
+  }
+  list(t) {
+    let e = this.rules.block.list.exec(t);
+    if (e) {
+      let n = e[1].trim(), s = n.length > 1, r = { type: "list", raw: "", ordered: s, start: s ? +n.slice(0, -1) : "", loose: !1, items: [] };
+      n = s ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = s ? n : "[*+-]");
+      let i = this.rules.other.listItemRegex(n), a = !1;
+      for (; t; ) {
+        let l = !1, h = "", c = "";
+        if (!(e = i.exec(t)) || this.rules.block.hr.test(t)) break;
+        h = e[0], t = t.substring(h.length);
+        let p = It(e[2].split(`
+`, 1)[0], e[1].length), u = t.split(`
+`, 1)[0], g = !p.trim(), f = 0;
+        if (this.options.pedantic ? (f = 2, c = p.trimStart()) : g ? f = e[1].length + 1 : (f = p.search(this.rules.other.nonSpaceChar), f = f > 4 ? 1 : f, c = p.slice(f), f += e[1].length), g && this.rules.other.blankLine.test(u) && (h += u + `
+`, t = t.substring(u.length + 1), l = !0), !l) {
+          let w = this.rules.other.nextBulletRegex(f), y = this.rules.other.hrRegex(f), b = this.rules.other.fencesBeginRegex(f), T = this.rules.other.headingBeginRegex(f), R = this.rules.other.htmlBeginRegex(f), $ = this.rules.other.blockquoteBeginRegex(f);
+          for (; t; ) {
+            let d = t.split(`
+`, 1)[0], m;
+            if (u = d, this.options.pedantic ? (u = u.replace(this.rules.other.listReplaceNesting, "  "), m = u) : m = u.replace(this.rules.other.tabCharGlobal, "    "), b.test(u) || T.test(u) || R.test(u) || $.test(u) || w.test(u) || y.test(u)) break;
+            if (m.search(this.rules.other.nonSpaceChar) >= f || !u.trim()) c += `
+` + m.slice(f);
+            else {
+              if (g || p.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4 || b.test(p) || T.test(p) || y.test(p)) break;
+              c += `
+` + u;
+            }
+            g = !u.trim(), h += d + `
+`, t = t.substring(d.length + 1), p = m.slice(f);
+          }
+        }
+        r.loose || (a ? r.loose = !0 : this.rules.other.doubleBlankLine.test(h) && (a = !0)), r.items.push({ type: "list_item", raw: h, task: !!this.options.gfm && this.rules.other.listIsTask.test(c), loose: !1, text: c, tokens: [] }), r.raw += h;
+      }
+      let o = r.items.at(-1);
+      if (o) o.raw = o.raw.trimEnd(), o.text = o.text.trimEnd();
+      else return;
+      r.raw = r.raw.trimEnd();
+      for (let l of r.items) {
+        if (this.lexer.state.top = !1, l.tokens = this.lexer.blockTokens(l.text, []), l.task) {
+          if (l.text = l.text.replace(this.rules.other.listReplaceTask, ""), l.tokens[0]?.type === "text" || l.tokens[0]?.type === "paragraph") {
+            l.tokens[0].raw = l.tokens[0].raw.replace(this.rules.other.listReplaceTask, ""), l.tokens[0].text = l.tokens[0].text.replace(this.rules.other.listReplaceTask, "");
+            for (let c = this.lexer.inlineQueue.length - 1; c >= 0; c--) if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[c].src)) {
+              this.lexer.inlineQueue[c].src = this.lexer.inlineQueue[c].src.replace(this.rules.other.listReplaceTask, "");
+              break;
+            }
+          }
+          let h = this.rules.other.listTaskCheckbox.exec(l.raw);
+          if (h) {
+            let c = { type: "checkbox", raw: h[0] + " ", checked: h[0] !== "[ ]" };
+            l.checked = c.checked, r.loose ? l.tokens[0] && ["paragraph", "text"].includes(l.tokens[0].type) && "tokens" in l.tokens[0] && l.tokens[0].tokens ? (l.tokens[0].raw = c.raw + l.tokens[0].raw, l.tokens[0].text = c.raw + l.tokens[0].text, l.tokens[0].tokens.unshift(c)) : l.tokens.unshift({ type: "paragraph", raw: c.raw, text: c.raw, tokens: [c] }) : l.tokens.unshift(c);
+          }
+        }
+        if (!r.loose) {
+          let h = l.tokens.filter((p) => p.type === "space"), c = h.length > 0 && h.some((p) => this.rules.other.anyLine.test(p.raw));
+          r.loose = c;
+        }
+      }
+      if (r.loose) for (let l of r.items) {
+        l.loose = !0;
+        for (let h of l.tokens) h.type === "text" && (h.type = "paragraph");
+      }
+      return r;
+    }
+  }
+  html(t) {
+    let e = this.rules.block.html.exec(t);
+    if (e) return { type: "html", block: !0, raw: e[0], pre: e[1] === "pre" || e[1] === "script" || e[1] === "style", text: e[0] };
+  }
+  def(t) {
+    let e = this.rules.block.def.exec(t);
+    if (e) {
+      let n = e[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), s = e[2] ? e[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", r = e[3] ? e[3].substring(1, e[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : e[3];
+      return { type: "def", tag: n, raw: e[0], href: s, title: r };
+    }
+  }
+  table(t) {
+    let e = this.rules.block.table.exec(t);
+    if (!e || !this.rules.other.tableDelimiter.test(e[2])) return;
+    let n = de(e[1]), s = e[2].replace(this.rules.other.tableAlignChars, "").split("|"), r = e[3]?.trim() ? e[3].replace(this.rules.other.tableRowBlankLine, "").split(`
+`) : [], i = { type: "table", raw: e[0], header: [], align: [], rows: [] };
+    if (n.length === s.length) {
+      for (let a of s) this.rules.other.tableAlignRight.test(a) ? i.align.push("right") : this.rules.other.tableAlignCenter.test(a) ? i.align.push("center") : this.rules.other.tableAlignLeft.test(a) ? i.align.push("left") : i.align.push(null);
+      for (let a = 0; a < n.length; a++) i.header.push({ text: n[a], tokens: this.lexer.inline(n[a]), header: !0, align: i.align[a] });
+      for (let a of r) i.rows.push(de(a, i.header.length).map((o, l) => ({ text: o, tokens: this.lexer.inline(o), header: !1, align: i.align[l] })));
+      return i;
+    }
+  }
+  lheading(t) {
+    let e = this.rules.block.lheading.exec(t);
+    if (e) {
+      let n = e[1].trim();
+      return { type: "heading", raw: e[0], depth: e[2].charAt(0) === "=" ? 1 : 2, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  paragraph(t) {
+    let e = this.rules.block.paragraph.exec(t);
+    if (e) {
+      let n = e[1].charAt(e[1].length - 1) === `
+` ? e[1].slice(0, -1) : e[1];
+      return { type: "paragraph", raw: e[0], text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  text(t) {
+    let e = this.rules.block.text.exec(t);
+    if (e) return { type: "text", raw: e[0], text: e[0], tokens: this.lexer.inline(e[0]) };
+  }
+  escape(t) {
+    let e = this.rules.inline.escape.exec(t);
+    if (e) return { type: "escape", raw: e[0], text: e[1] };
+  }
+  tag(t) {
+    let e = this.rules.inline.tag.exec(t);
+    if (e) return !this.lexer.state.inLink && this.rules.other.startATag.test(e[0]) ? this.lexer.state.inLink = !0 : this.lexer.state.inLink && this.rules.other.endATag.test(e[0]) && (this.lexer.state.inLink = !1), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(e[0]) ? this.lexer.state.inRawBlock = !0 : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(e[0]) && (this.lexer.state.inRawBlock = !1), { type: "html", raw: e[0], inLink: this.lexer.state.inLink, inRawBlock: this.lexer.state.inRawBlock, block: !1, text: e[0] };
+  }
+  link(t) {
+    let e = this.rules.inline.link.exec(t);
+    if (e) {
+      let n = e[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(n)) {
+        if (!this.rules.other.endAngleBracket.test(n)) return;
+        let i = q(n.slice(0, -1), "\\");
+        if ((n.length - i.length) % 2 === 0) return;
+      } else {
+        let i = _t(e[2], "()");
+        if (i === -2) return;
+        if (i > -1) {
+          let a = (e[0].indexOf("!") === 0 ? 5 : 4) + e[1].length + i;
+          e[2] = e[2].substring(0, i), e[0] = e[0].substring(0, a).trim(), e[3] = "";
+        }
+      }
+      let s = e[2], r = "";
+      if (this.options.pedantic) {
+        let i = this.rules.other.pedanticHrefTitle.exec(s);
+        i && (s = i[1], r = i[3]);
+      } else r = e[3] ? e[3].slice(1, -1) : "";
+      return s = s.trim(), this.rules.other.startAngleBracket.test(s) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(n) ? s = s.slice(1) : s = s.slice(1, -1)), ge(e, { href: s && s.replace(this.rules.inline.anyPunctuation, "$1"), title: r && r.replace(this.rules.inline.anyPunctuation, "$1") }, e[0], this.lexer, this.rules);
+    }
+  }
+  reflink(t, e) {
+    let n;
+    if ((n = this.rules.inline.reflink.exec(t)) || (n = this.rules.inline.nolink.exec(t))) {
+      let s = (n[2] || n[1]).replace(this.rules.other.multipleSpaceGlobal, " "), r = e[s.toLowerCase()];
+      if (!r) {
+        let i = n[0].charAt(0);
+        return { type: "text", raw: i, text: i };
+      }
+      return ge(n, r, n[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(t, e, n = "") {
+    let s = this.rules.inline.emStrongLDelim.exec(t);
+    if (!(!s || !s[1] && !s[2] && !s[3] && !s[4] || s[4] && n.match(this.rules.other.unicodeAlphaNumeric)) && (!(s[1] || s[3]) || !n || this.rules.inline.punctuation.exec(n))) {
+      let r = [...s[0]].length - 1, i, a, o = r, l = 0, h = s[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      for (h.lastIndex = 0, e = e.slice(-1 * t.length + r); (s = h.exec(e)) != null; ) {
+        if (i = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !i) continue;
+        if (a = [...i].length, s[3] || s[4]) {
+          o += a;
+          continue;
+        } else if ((s[5] || s[6]) && r % 3 && !((r + a) % 3)) {
+          l += a;
+          continue;
+        }
+        if (o -= a, o > 0) continue;
+        a = Math.min(a, a + o + l);
+        let c = [...s[0]][0].length, p = t.slice(0, r + s.index + c + a);
+        if (Math.min(r, a) % 2) {
+          let g = p.slice(1, -1);
+          return { type: "em", raw: p, text: g, tokens: this.lexer.inlineTokens(g) };
+        }
+        let u = p.slice(2, -2);
+        return { type: "strong", raw: p, text: u, tokens: this.lexer.inlineTokens(u) };
+      }
+    }
+  }
+  codespan(t) {
+    let e = this.rules.inline.code.exec(t);
+    if (e) {
+      let n = e[2].replace(this.rules.other.newLineCharGlobal, " "), s = this.rules.other.nonSpaceChar.test(n), r = this.rules.other.startingSpaceChar.test(n) && this.rules.other.endingSpaceChar.test(n);
+      return s && r && (n = n.substring(1, n.length - 1)), { type: "codespan", raw: e[0], text: n };
+    }
+  }
+  br(t) {
+    let e = this.rules.inline.br.exec(t);
+    if (e) return { type: "br", raw: e[0] };
+  }
+  del(t, e, n = "") {
+    let s = this.rules.inline.delLDelim.exec(t);
+    if (s && (!s[1] || !n || this.rules.inline.punctuation.exec(n))) {
+      let r = [...s[0]].length - 1, i, a, o = r, l = this.rules.inline.delRDelim;
+      for (l.lastIndex = 0, e = e.slice(-1 * t.length + r); (s = l.exec(e)) != null; ) {
+        if (i = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !i || (a = [...i].length, a !== r)) continue;
+        if (s[3] || s[4]) {
+          o += a;
+          continue;
+        }
+        if (o -= a, o > 0) continue;
+        a = Math.min(a, a + o);
+        let h = [...s[0]][0].length, c = t.slice(0, r + s.index + h + a), p = c.slice(r, -r);
+        return { type: "del", raw: c, text: p, tokens: this.lexer.inlineTokens(p) };
+      }
+    }
+  }
+  autolink(t) {
+    let e = this.rules.inline.autolink.exec(t);
+    if (e) {
+      let n, s;
+      return e[2] === "@" ? (n = e[1], s = "mailto:" + n) : (n = e[1], s = n), { type: "link", raw: e[0], text: n, href: s, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  url(t) {
+    let e;
+    if (e = this.rules.inline.url.exec(t)) {
+      let n, s;
+      if (e[2] === "@") n = e[0], s = "mailto:" + n;
+      else {
+        let r;
+        do
+          r = e[0], e[0] = this.rules.inline._backpedal.exec(e[0])?.[0] ?? "";
+        while (r !== e[0]);
+        n = e[0], e[1] === "www." ? s = "http://" + e[0] : s = e[0];
+      }
+      return { type: "link", raw: e[0], text: n, href: s, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  inlineText(t) {
+    let e = this.rules.inline.text.exec(t);
+    if (e) {
+      let n = this.lexer.state.inRawBlock;
+      return { type: "text", raw: e[0], text: e[0], escaped: n };
+    }
+  }
+}, M = class V {
+  tokens;
+  options;
+  state;
+  inlineQueue;
+  tokenizer;
+  constructor(e) {
+    this.tokens = [], this.tokens.links = /* @__PURE__ */ Object.create(null), this.options = e || P, this.options.tokenizer = this.options.tokenizer || new j(), this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { inLink: !1, inRawBlock: !1, top: !0 };
+    let n = { other: S, block: F.normal, inline: O.normal };
+    this.options.pedantic ? (n.block = F.pedantic, n.inline = O.pedantic) : this.options.gfm && (n.block = F.gfm, this.options.breaks ? n.inline = O.breaks : n.inline = O.gfm), this.tokenizer.rules = n;
+  }
+  static get rules() {
+    return { block: F, inline: O };
+  }
+  static lex(e, n) {
+    return new V(n).lex(e);
+  }
+  static lexInline(e, n) {
+    return new V(n).inlineTokens(e);
+  }
+  lex(e) {
+    e = e.replace(S.carriageReturn, `
+`), this.blockTokens(e, this.tokens);
+    for (let n = 0; n < this.inlineQueue.length; n++) {
+      let s = this.inlineQueue[n];
+      this.inlineTokens(s.src, s.tokens);
+    }
+    return this.inlineQueue = [], this.tokens;
+  }
+  blockTokens(e, n = [], s = !1) {
+    for (this.tokenizer.lexer = this, this.options.pedantic && (e = e.replace(S.tabCharGlobal, "    ").replace(S.spaceLine, "")); e; ) {
+      let r;
+      if (this.options.extensions?.block?.some((a) => (r = a.call({ lexer: this }, e, n)) ? (e = e.substring(r.raw.length), n.push(r), !0) : !1)) continue;
+      if (r = this.tokenizer.space(e)) {
+        e = e.substring(r.raw.length);
+        let a = n.at(-1);
+        r.raw.length === 1 && a !== void 0 ? a.raw += `
+` : n.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.code(e)) {
+        e = e.substring(r.raw.length);
+        let a = n.at(-1);
+        a?.type === "paragraph" || a?.type === "text" ? (a.raw += (a.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, a.text += `
+` + r.text, this.inlineQueue.at(-1).src = a.text) : n.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.fences(e)) {
+        e = e.substring(r.raw.length), n.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.heading(e)) {
+        e = e.substring(r.raw.length), n.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.hr(e)) {
+        e = e.substring(r.raw.length), n.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.blockquote(e)) {
+        e = e.substring(r.raw.length), n.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.list(e)) {
+        e = e.substring(r.raw.length), n.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.html(e)) {
+        e = e.substring(r.raw.length), n.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.def(e)) {
+        e = e.substring(r.raw.length);
+        let a = n.at(-1);
+        a?.type === "paragraph" || a?.type === "text" ? (a.raw += (a.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, a.text += `
+` + r.raw, this.inlineQueue.at(-1).src = a.text) : this.tokens.links[r.tag] || (this.tokens.links[r.tag] = { href: r.href, title: r.title }, n.push(r));
+        continue;
+      }
+      if (r = this.tokenizer.table(e)) {
+        e = e.substring(r.raw.length), n.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.lheading(e)) {
+        e = e.substring(r.raw.length), n.push(r);
+        continue;
+      }
+      let i = e;
+      if (this.options.extensions?.startBlock) {
+        let a = 1 / 0, o = e.slice(1), l;
+        this.options.extensions.startBlock.forEach((h) => {
+          l = h.call({ lexer: this }, o), typeof l == "number" && l >= 0 && (a = Math.min(a, l));
+        }), a < 1 / 0 && a >= 0 && (i = e.substring(0, a + 1));
+      }
+      if (this.state.top && (r = this.tokenizer.paragraph(i))) {
+        let a = n.at(-1);
+        s && a?.type === "paragraph" ? (a.raw += (a.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, a.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = a.text) : n.push(r), s = i.length !== e.length, e = e.substring(r.raw.length);
+        continue;
+      }
+      if (r = this.tokenizer.text(e)) {
+        e = e.substring(r.raw.length);
+        let a = n.at(-1);
+        a?.type === "text" ? (a.raw += (a.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, a.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = a.text) : n.push(r);
+        continue;
+      }
+      if (e) {
+        let a = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(a);
+          break;
+        } else throw new Error(a);
+      }
+    }
+    return this.state.top = !0, n;
+  }
+  inline(e, n = []) {
+    return this.inlineQueue.push({ src: e, tokens: n }), n;
+  }
+  inlineTokens(e, n = []) {
+    this.tokenizer.lexer = this;
+    let s = e, r = null;
+    if (this.tokens.links) {
+      let l = Object.keys(this.tokens.links);
+      if (l.length > 0) for (; (r = this.tokenizer.rules.inline.reflinkSearch.exec(s)) != null; ) l.includes(r[0].slice(r[0].lastIndexOf("[") + 1, -1)) && (s = s.slice(0, r.index) + "[" + "a".repeat(r[0].length - 2) + "]" + s.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex));
+    }
+    for (; (r = this.tokenizer.rules.inline.anyPunctuation.exec(s)) != null; ) s = s.slice(0, r.index) + "++" + s.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+    let i;
+    for (; (r = this.tokenizer.rules.inline.blockSkip.exec(s)) != null; ) i = r[2] ? r[2].length : 0, s = s.slice(0, r.index + i) + "[" + "a".repeat(r[0].length - i - 2) + "]" + s.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+    s = this.options.hooks?.emStrongMask?.call({ lexer: this }, s) ?? s;
+    let a = !1, o = "";
+    for (; e; ) {
+      a || (o = ""), a = !1;
+      let l;
+      if (this.options.extensions?.inline?.some((c) => (l = c.call({ lexer: this }, e, n)) ? (e = e.substring(l.raw.length), n.push(l), !0) : !1)) continue;
+      if (l = this.tokenizer.escape(e)) {
+        e = e.substring(l.raw.length), n.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.tag(e)) {
+        e = e.substring(l.raw.length), n.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.link(e)) {
+        e = e.substring(l.raw.length), n.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.reflink(e, this.tokens.links)) {
+        e = e.substring(l.raw.length);
+        let c = n.at(-1);
+        l.type === "text" && c?.type === "text" ? (c.raw += l.raw, c.text += l.text) : n.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.emStrong(e, s, o)) {
+        e = e.substring(l.raw.length), n.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.codespan(e)) {
+        e = e.substring(l.raw.length), n.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.br(e)) {
+        e = e.substring(l.raw.length), n.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.del(e, s, o)) {
+        e = e.substring(l.raw.length), n.push(l);
+        continue;
+      }
+      if (l = this.tokenizer.autolink(e)) {
+        e = e.substring(l.raw.length), n.push(l);
+        continue;
+      }
+      if (!this.state.inLink && (l = this.tokenizer.url(e))) {
+        e = e.substring(l.raw.length), n.push(l);
+        continue;
+      }
+      let h = e;
+      if (this.options.extensions?.startInline) {
+        let c = 1 / 0, p = e.slice(1), u;
+        this.options.extensions.startInline.forEach((g) => {
+          u = g.call({ lexer: this }, p), typeof u == "number" && u >= 0 && (c = Math.min(c, u));
+        }), c < 1 / 0 && c >= 0 && (h = e.substring(0, c + 1));
+      }
+      if (l = this.tokenizer.inlineText(h)) {
+        e = e.substring(l.raw.length), l.raw.slice(-1) !== "_" && (o = l.raw.slice(-1)), a = !0;
+        let c = n.at(-1);
+        c?.type === "text" ? (c.raw += l.raw, c.text += l.text) : n.push(l);
+        continue;
+      }
+      if (e) {
+        let c = "Infinite loop on byte: " + e.charCodeAt(0);
+        if (this.options.silent) {
+          console.error(c);
+          break;
+        } else throw new Error(c);
+      }
+    }
+    return n;
+  }
+}, W = class {
+  options;
+  parser;
+  constructor(t) {
+    this.options = t || P;
+  }
+  space(t) {
+    return "";
+  }
+  code({ text: t, lang: e, escaped: n }) {
+    let s = (e || "").match(S.notSpaceStart)?.[0], r = t.replace(S.endingNewline, "") + `
+`;
+    return s ? '<pre><code class="language-' + z(s) + '">' + (n ? r : z(r, !0)) + `</code></pre>
+` : "<pre><code>" + (n ? r : z(r, !0)) + `</code></pre>
+`;
+  }
+  blockquote({ tokens: t }) {
+    return `<blockquote>
+${this.parser.parse(t)}</blockquote>
+`;
+  }
+  html({ text: t }) {
+    return t;
+  }
+  def(t) {
+    return "";
+  }
+  heading({ tokens: t, depth: e }) {
+    return `<h${e}>${this.parser.parseInline(t)}</h${e}>
+`;
+  }
+  hr(t) {
+    return `<hr>
+`;
+  }
+  list(t) {
+    let e = t.ordered, n = t.start, s = "";
+    for (let a = 0; a < t.items.length; a++) {
+      let o = t.items[a];
+      s += this.listitem(o);
+    }
+    let r = e ? "ol" : "ul", i = e && n !== 1 ? ' start="' + n + '"' : "";
+    return "<" + r + i + `>
+` + s + "</" + r + `>
+`;
+  }
+  listitem(t) {
+    return `<li>${this.parser.parse(t.tokens)}</li>
+`;
+  }
+  checkbox({ checked: t }) {
+    return "<input " + (t ? 'checked="" ' : "") + 'disabled="" type="checkbox"> ';
+  }
+  paragraph({ tokens: t }) {
+    return `<p>${this.parser.parseInline(t)}</p>
+`;
+  }
+  table(t) {
+    let e = "", n = "";
+    for (let r = 0; r < t.header.length; r++) n += this.tablecell(t.header[r]);
+    e += this.tablerow({ text: n });
+    let s = "";
+    for (let r = 0; r < t.rows.length; r++) {
+      let i = t.rows[r];
+      n = "";
+      for (let a = 0; a < i.length; a++) n += this.tablecell(i[a]);
+      s += this.tablerow({ text: n });
+    }
+    return s && (s = `<tbody>${s}</tbody>`), `<table>
+<thead>
+` + e + `</thead>
+` + s + `</table>
+`;
+  }
+  tablerow({ text: t }) {
+    return `<tr>
+${t}</tr>
+`;
+  }
+  tablecell(t) {
+    let e = this.parser.parseInline(t.tokens), n = t.header ? "th" : "td";
+    return (t.align ? `<${n} align="${t.align}">` : `<${n}>`) + e + `</${n}>
+`;
+  }
+  strong({ tokens: t }) {
+    return `<strong>${this.parser.parseInline(t)}</strong>`;
+  }
+  em({ tokens: t }) {
+    return `<em>${this.parser.parseInline(t)}</em>`;
+  }
+  codespan({ text: t }) {
+    return `<code>${z(t, !0)}</code>`;
+  }
+  br(t) {
+    return "<br>";
+  }
+  del({ tokens: t }) {
+    return `<del>${this.parser.parseInline(t)}</del>`;
+  }
+  link({ href: t, title: e, tokens: n }) {
+    let s = this.parser.parseInline(n), r = ue(t);
+    if (r === null) return s;
+    t = r;
+    let i = '<a href="' + t + '"';
+    return e && (i += ' title="' + z(e) + '"'), i += ">" + s + "</a>", i;
+  }
+  image({ href: t, title: e, text: n, tokens: s }) {
+    s && (n = this.parser.parseInline(s, this.parser.textRenderer));
+    let r = ue(t);
+    if (r === null) return z(n);
+    t = r;
+    let i = `<img src="${t}" alt="${z(n)}"`;
+    return e && (i += ` title="${z(e)}"`), i += ">", i;
+  }
+  text(t) {
+    return "tokens" in t && t.tokens ? this.parser.parseInline(t.tokens) : "escaped" in t && t.escaped ? t.text : z(t.text);
+  }
+}, oe = class {
+  strong({ text: t }) {
+    return t;
+  }
+  em({ text: t }) {
+    return t;
+  }
+  codespan({ text: t }) {
+    return t;
+  }
+  del({ text: t }) {
+    return t;
+  }
+  html({ text: t }) {
+    return t;
+  }
+  text({ text: t }) {
+    return t;
+  }
+  link({ text: t }) {
+    return "" + t;
+  }
+  image({ text: t }) {
+    return "" + t;
+  }
+  br() {
+    return "";
+  }
+  checkbox({ raw: t }) {
+    return t;
+  }
+}, A = class Y {
+  options;
+  renderer;
+  textRenderer;
+  constructor(e) {
+    this.options = e || P, this.options.renderer = this.options.renderer || new W(), this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new oe();
+  }
+  static parse(e, n) {
+    return new Y(n).parse(e);
+  }
+  static parseInline(e, n) {
+    return new Y(n).parseInline(e);
+  }
+  parse(e) {
+    this.renderer.parser = this;
+    let n = "";
+    for (let s = 0; s < e.length; s++) {
+      let r = e[s];
+      if (this.options.extensions?.renderers?.[r.type]) {
+        let a = r, o = this.options.extensions.renderers[a.type].call({ parser: this }, a);
+        if (o !== !1 || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "def", "paragraph", "text"].includes(a.type)) {
+          n += o || "";
+          continue;
+        }
+      }
+      let i = r;
+      switch (i.type) {
+        case "space": {
+          n += this.renderer.space(i);
+          break;
+        }
+        case "hr": {
+          n += this.renderer.hr(i);
+          break;
+        }
+        case "heading": {
+          n += this.renderer.heading(i);
+          break;
+        }
+        case "code": {
+          n += this.renderer.code(i);
+          break;
+        }
+        case "table": {
+          n += this.renderer.table(i);
+          break;
+        }
+        case "blockquote": {
+          n += this.renderer.blockquote(i);
+          break;
+        }
+        case "list": {
+          n += this.renderer.list(i);
+          break;
+        }
+        case "checkbox": {
+          n += this.renderer.checkbox(i);
+          break;
+        }
+        case "html": {
+          n += this.renderer.html(i);
+          break;
+        }
+        case "def": {
+          n += this.renderer.def(i);
+          break;
+        }
+        case "paragraph": {
+          n += this.renderer.paragraph(i);
+          break;
+        }
+        case "text": {
+          n += this.renderer.text(i);
+          break;
+        }
+        default: {
+          let a = 'Token with "' + i.type + '" type was not found.';
+          if (this.options.silent) return console.error(a), "";
+          throw new Error(a);
+        }
+      }
+    }
+    return n;
+  }
+  parseInline(e, n = this.renderer) {
+    this.renderer.parser = this;
+    let s = "";
+    for (let r = 0; r < e.length; r++) {
+      let i = e[r];
+      if (this.options.extensions?.renderers?.[i.type]) {
+        let o = this.options.extensions.renderers[i.type].call({ parser: this }, i);
+        if (o !== !1 || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(i.type)) {
+          s += o || "";
+          continue;
+        }
+      }
+      let a = i;
+      switch (a.type) {
+        case "escape": {
+          s += n.text(a);
+          break;
+        }
+        case "html": {
+          s += n.html(a);
+          break;
+        }
+        case "link": {
+          s += n.link(a);
+          break;
+        }
+        case "image": {
+          s += n.image(a);
+          break;
+        }
+        case "checkbox": {
+          s += n.checkbox(a);
+          break;
+        }
+        case "strong": {
+          s += n.strong(a);
+          break;
+        }
+        case "em": {
+          s += n.em(a);
+          break;
+        }
+        case "codespan": {
+          s += n.codespan(a);
+          break;
+        }
+        case "br": {
+          s += n.br(a);
+          break;
+        }
+        case "del": {
+          s += n.del(a);
+          break;
+        }
+        case "text": {
+          s += n.text(a);
+          break;
+        }
+        default: {
+          let o = 'Token with "' + a.type + '" type was not found.';
+          if (this.options.silent) return console.error(o), "";
+          throw new Error(o);
+        }
+      }
+    }
+    return s;
+  }
+}, N = class {
+  options;
+  block;
+  constructor(t) {
+    this.options = t || P;
+  }
+  static passThroughHooks = /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens", "emStrongMask"]);
+  static passThroughHooksRespectAsync = /* @__PURE__ */ new Set(["preprocess", "postprocess", "processAllTokens"]);
+  preprocess(t) {
+    return t;
+  }
+  postprocess(t) {
+    return t;
+  }
+  processAllTokens(t) {
+    return t;
+  }
+  emStrongMask(t) {
+    return t;
+  }
+  provideLexer() {
+    return this.block ? M.lex : M.lexInline;
+  }
+  provideParser() {
+    return this.block ? A.parse : A.parseInline;
+  }
+}, Lt = class {
+  defaults = ee();
+  options = this.setOptions;
+  parse = this.parseMarkdown(!0);
+  parseInline = this.parseMarkdown(!1);
+  Parser = A;
+  Renderer = W;
+  TextRenderer = oe;
+  Lexer = M;
+  Tokenizer = j;
+  Hooks = N;
+  constructor(...t) {
+    this.use(...t);
+  }
+  walkTokens(t, e) {
+    let n = [];
+    for (let s of t) switch (n = n.concat(e.call(this, s)), s.type) {
+      case "table": {
+        let r = s;
+        for (let i of r.header) n = n.concat(this.walkTokens(i.tokens, e));
+        for (let i of r.rows) for (let a of i) n = n.concat(this.walkTokens(a.tokens, e));
+        break;
+      }
+      case "list": {
+        let r = s;
+        n = n.concat(this.walkTokens(r.items, e));
+        break;
+      }
+      default: {
+        let r = s;
+        this.defaults.extensions?.childTokens?.[r.type] ? this.defaults.extensions.childTokens[r.type].forEach((i) => {
+          let a = r[i].flat(1 / 0);
+          n = n.concat(this.walkTokens(a, e));
+        }) : r.tokens && (n = n.concat(this.walkTokens(r.tokens, e)));
+      }
+    }
+    return n;
+  }
+  use(...t) {
+    let e = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    return t.forEach((n) => {
+      let s = { ...n };
+      if (s.async = this.defaults.async || s.async || !1, n.extensions && (n.extensions.forEach((r) => {
+        if (!r.name) throw new Error("extension name required");
+        if ("renderer" in r) {
+          let i = e.renderers[r.name];
+          i ? e.renderers[r.name] = function(...a) {
+            let o = r.renderer.apply(this, a);
+            return o === !1 && (o = i.apply(this, a)), o;
+          } : e.renderers[r.name] = r.renderer;
+        }
+        if ("tokenizer" in r) {
+          if (!r.level || r.level !== "block" && r.level !== "inline") throw new Error("extension level must be 'block' or 'inline'");
+          let i = e[r.level];
+          i ? i.unshift(r.tokenizer) : e[r.level] = [r.tokenizer], r.start && (r.level === "block" ? e.startBlock ? e.startBlock.push(r.start) : e.startBlock = [r.start] : r.level === "inline" && (e.startInline ? e.startInline.push(r.start) : e.startInline = [r.start]));
+        }
+        "childTokens" in r && r.childTokens && (e.childTokens[r.name] = r.childTokens);
+      }), s.extensions = e), n.renderer) {
+        let r = this.defaults.renderer || new W(this.defaults);
+        for (let i in n.renderer) {
+          if (!(i in r)) throw new Error(`renderer '${i}' does not exist`);
+          if (["options", "parser"].includes(i)) continue;
+          let a = i, o = n.renderer[a], l = r[a];
+          r[a] = (...h) => {
+            let c = o.apply(r, h);
+            return c === !1 && (c = l.apply(r, h)), c || "";
+          };
+        }
+        s.renderer = r;
+      }
+      if (n.tokenizer) {
+        let r = this.defaults.tokenizer || new j(this.defaults);
+        for (let i in n.tokenizer) {
+          if (!(i in r)) throw new Error(`tokenizer '${i}' does not exist`);
+          if (["options", "rules", "lexer"].includes(i)) continue;
+          let a = i, o = n.tokenizer[a], l = r[a];
+          r[a] = (...h) => {
+            let c = o.apply(r, h);
+            return c === !1 && (c = l.apply(r, h)), c;
+          };
+        }
+        s.tokenizer = r;
+      }
+      if (n.hooks) {
+        let r = this.defaults.hooks || new N();
+        for (let i in n.hooks) {
+          if (!(i in r)) throw new Error(`hook '${i}' does not exist`);
+          if (["options", "block"].includes(i)) continue;
+          let a = i, o = n.hooks[a], l = r[a];
+          N.passThroughHooks.has(i) ? r[a] = (h) => {
+            if (this.defaults.async && N.passThroughHooksRespectAsync.has(i)) return (async () => {
+              let p = await o.call(r, h);
+              return l.call(r, p);
+            })();
+            let c = o.call(r, h);
+            return l.call(r, c);
+          } : r[a] = (...h) => {
+            if (this.defaults.async) return (async () => {
+              let p = await o.apply(r, h);
+              return p === !1 && (p = await l.apply(r, h)), p;
+            })();
+            let c = o.apply(r, h);
+            return c === !1 && (c = l.apply(r, h)), c;
+          };
+        }
+        s.hooks = r;
+      }
+      if (n.walkTokens) {
+        let r = this.defaults.walkTokens, i = n.walkTokens;
+        s.walkTokens = function(a) {
+          let o = [];
+          return o.push(i.call(this, a)), r && (o = o.concat(r.call(this, a))), o;
+        };
+      }
+      this.defaults = { ...this.defaults, ...s };
+    }), this;
+  }
+  setOptions(t) {
+    return this.defaults = { ...this.defaults, ...t }, this;
+  }
+  lexer(t, e) {
+    return M.lex(t, e ?? this.defaults);
+  }
+  parser(t, e) {
+    return A.parse(t, e ?? this.defaults);
+  }
+  parseMarkdown(t) {
+    return (e, n) => {
+      let s = { ...n }, r = { ...this.defaults, ...s }, i = this.onError(!!r.silent, !!r.async);
+      if (this.defaults.async === !0 && s.async === !1) return i(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
+      if (typeof e > "u" || e === null) return i(new Error("marked(): input parameter is undefined or null"));
+      if (typeof e != "string") return i(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(e) + ", string expected"));
+      if (r.hooks && (r.hooks.options = r, r.hooks.block = t), r.async) return (async () => {
+        let a = r.hooks ? await r.hooks.preprocess(e) : e, o = await (r.hooks ? await r.hooks.provideLexer() : t ? M.lex : M.lexInline)(a, r), l = r.hooks ? await r.hooks.processAllTokens(o) : o;
+        r.walkTokens && await Promise.all(this.walkTokens(l, r.walkTokens));
+        let h = await (r.hooks ? await r.hooks.provideParser() : t ? A.parse : A.parseInline)(l, r);
+        return r.hooks ? await r.hooks.postprocess(h) : h;
+      })().catch(i);
+      try {
+        r.hooks && (e = r.hooks.preprocess(e));
+        let a = (r.hooks ? r.hooks.provideLexer() : t ? M.lex : M.lexInline)(e, r);
+        r.hooks && (a = r.hooks.processAllTokens(a)), r.walkTokens && this.walkTokens(a, r.walkTokens);
+        let o = (r.hooks ? r.hooks.provideParser() : t ? A.parse : A.parseInline)(a, r);
+        return r.hooks && (o = r.hooks.postprocess(o)), o;
+      } catch (a) {
+        return i(a);
+      }
+    };
+  }
+  onError(t, e) {
+    return (n) => {
+      if (n.message += `
+Please report this to https://github.com/markedjs/marked.`, t) {
+        let s = "<p>An error occurred:</p><pre>" + z(n.message + "", !0) + "</pre>";
+        return e ? Promise.resolve(s) : s;
+      }
+      if (e) return Promise.reject(n);
+      throw n;
+    };
+  }
+}, I = new Lt();
+function x(t, e) {
+  return I.parse(t, e);
+}
+x.options = x.setOptions = function(t) {
+  return I.setOptions(t), x.defaults = I.defaults, fe(x.defaults), x;
+};
+x.getDefaults = ee;
+x.defaults = P;
+x.use = function(...t) {
+  return I.use(...t), x.defaults = I.defaults, fe(x.defaults), x;
+};
+x.walkTokens = function(t, e) {
+  return I.walkTokens(t, e);
+};
+x.parseInline = I.parseInline;
+x.Parser = A;
+x.parser = A.parse;
+x.Renderer = W;
+x.TextRenderer = oe;
+x.Lexer = M;
+x.lexer = M.lex;
+x.Tokenizer = j;
+x.Hooks = N;
+x.parse = x;
+x.options;
+x.setOptions;
+x.use;
+x.walkTokens;
+x.parseInline;
+A.parse;
+M.lex;
+function Bt(t, e) {
+  const s = e.split(`
+`).flatMap((r) => [r, ""]).map((r) => `${t}${r}`).join(`
+`);
+  return s.slice(0, s.length - 1);
+}
+function Ht(t, e) {
+  const n = [];
+  return Array.from(t.keys()).forEach((s) => {
+    (!e || !e.marks || !e.marks.map((r) => r.type).includes(s)) && n.push(s);
+  }), n;
+}
+function Ot(t, e) {
+  const n = [];
+  return Array.from(e.entries()).forEach(([s, r]) => {
+    t.has(s) || n.push({ type: s, mark: r });
+  }), n;
+}
+function qt(t, e, n, s) {
+  const r = !n, i = n && n.type === "text" && (!n.marks || n.marks.length === 0), a = n && n.type === "text" && n.marks && !s(e, new Map(n.marks.map((l) => [l.type, l]))), o = [];
+  if (r || i || a)
+    if (n && n.type === "text" && n.marks) {
+      const l = new Map(n.marks.map((h) => [h.type, h]));
+      Array.from(t.keys()).reverse().forEach((h) => {
+        l.has(h) || o.push(h);
+      });
+    } else (r || i) && o.push(...Array.from(t.keys()).reverse());
+  return o;
+}
+function Nt(t, e) {
+  let n = "";
+  return Array.from(t.keys()).reverse().forEach((s) => {
+    const r = t.get(s), i = e(s, r);
+    i && (n = i + n);
+  }), t.clear(), n;
+}
+function Dt(t, e, n) {
+  let s = "";
+  return Array.from(t.entries()).forEach(([r, i]) => {
+    const a = n(r, i);
+    a && (s += a), e.set(r, i);
+  }), s;
+}
+function K(t) {
+  const n = (t.raw || t.text || "").match(/^(\s*)[-+*]\s+\[([ xX])\]\s+/);
+  return n ? { isTask: !0, checked: n[2].toLowerCase() === "x", indentLevel: n[1].length } : { isTask: !1, indentLevel: 0 };
+}
+function Q(t, e) {
+  return typeof t != "string" ? "json" : e;
+}
+var Me = class {
+  /**
+   * Create a MarkdownManager.
+   * @param options.marked Optional marked instance to use (injected).
+   * @param options.markedOptions Optional options to pass to marked.setOptions
+   * @param options.indentation Indentation settings (style and size).
+   * @param options.extensions An array of Tiptap extensions to register for markdown parsing and rendering.
+   */
+  constructor(t) {
+    this.baseExtensions = [], this.extensions = [], this.lastParseResult = null;
+    var e, n, s, r, i;
+    this.markedInstance = (e = t?.marked) != null ? e : x, this.lexer = new this.markedInstance.Lexer(), this.indentStyle = (s = (n = t?.indentation) == null ? void 0 : n.style) != null ? s : "space", this.indentSize = (i = (r = t?.indentation) == null ? void 0 : r.size) != null ? i : 2, this.baseExtensions = t?.extensions || [], t?.markedOptions && typeof this.markedInstance.setOptions == "function" && this.markedInstance.setOptions(t.markedOptions), this.registry = /* @__PURE__ */ new Map(), this.nodeTypeRegistry = /* @__PURE__ */ new Map(), t?.extensions && (this.baseExtensions = t.extensions, Ce(t.extensions).forEach((o) => this.registerExtension(o, !1))), this.lexer = new this.markedInstance.Lexer();
+  }
+  /** Returns the underlying marked instance. */
+  get instance() {
+    return this.markedInstance;
+  }
+  /** Returns the correct indentCharacter (space or tab) */
+  get indentCharacter() {
+    return this.indentStyle === "space" ? " " : "	";
+  }
+  /** Returns the correct indentString repeated X times */
+  get indentString() {
+    return this.indentCharacter.repeat(this.indentSize);
+  }
+  /** Helper to quickly check whether a marked instance is available. */
+  hasMarked() {
+    return !!this.markedInstance;
+  }
+  /**
+   * Register a Tiptap extension (Node/Mark/Extension). This will read
+   * `markdownName`, `parseMarkdown`, `renderMarkdown` and `priority` from the
+   * extension config (using the same resolution used across the codebase).
+   */
+  registerExtension(t, e = !0) {
+    var n, s;
+    this.extensions.push(t);
+    const r = t.name, i = H(t, "markdownTokenName") || r, a = H(t, "parseMarkdown"), o = H(t, "renderMarkdown"), l = H(t, "markdownTokenizer"), h = (n = H(t, "markdownOptions")) != null ? n : null, c = (s = h?.indentsContent) != null ? s : !1, p = h?.htmlReopen, u = {
+      tokenName: i,
+      nodeName: r,
+      parseMarkdown: a,
+      renderMarkdown: o,
+      isIndenting: c,
+      htmlReopen: p,
+      tokenizer: l
+    };
+    if (i && a) {
+      const g = this.registry.get(i) || [];
+      g.push(u), this.registry.set(i, g);
+    }
+    if (o) {
+      const g = this.nodeTypeRegistry.get(r) || [];
+      g.push(u), this.nodeTypeRegistry.set(r, g);
+    }
+    l && this.hasMarked() && (this.registerTokenizer(l), e && (this.lexer = new this.markedInstance.Lexer()));
+  }
+  /**
+   * Register a custom tokenizer with marked.js for parsing non-standard markdown syntax.
+   */
+  registerTokenizer(t) {
+    if (!this.hasMarked())
+      return;
+    const { name: e, start: n, level: s = "inline", tokenize: r } = t, o = {
+      inlineTokens: (c) => this.lexer.inlineTokens(c),
+      blockTokens: (c) => this.lexer.blockTokens(c)
+    };
+    let l;
+    n ? l = typeof n == "function" ? n : (c) => c.indexOf(n) : l = (c) => {
+      const p = r(c, [], o);
+      return p && p.raw ? c.indexOf(p.raw) : -1;
+    };
+    const h = {
+      name: e,
+      level: s,
+      start: l,
+      tokenizer: (c, p) => {
+        const u = r(c, p, o);
+        if (u && u.type)
+          return {
+            ...u,
+            type: u.type || e,
+            raw: u.raw || "",
+            tokens: u.tokens || []
+          };
+      },
+      childTokens: []
+    };
+    this.markedInstance.use({
+      extensions: [h]
+    });
+  }
+  /** Get registered handlers for a token type and try each until one succeeds. */
+  getHandlersForToken(t) {
+    try {
+      return this.registry.get(t) || [];
+    } catch {
+      return [];
+    }
+  }
+  /** Get the first handler for a token type (for backwards compatibility). */
+  getHandlerForToken(t) {
+    const e = this.getHandlersForToken(t);
+    if (e.length > 0)
+      return e[0];
+    const n = this.getHandlersForNodeType(t);
+    return n.length > 0 ? n[0] : void 0;
+  }
+  /** Get registered handlers for a node type (for rendering). */
+  getHandlersForNodeType(t) {
+    try {
+      return this.nodeTypeRegistry.get(t) || [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Serialize a ProseMirror-like JSON document (or node array) to a Markdown string
+   * using registered renderers and fallback renderers.
+   */
+  serialize(t) {
+    if (!t)
+      return "";
+    const e = this.renderNodes(t, t);
+    return this.isEmptyOutput(e) ? "" : e;
+  }
+  /**
+   * Check if the markdown output represents an empty document.
+   * Empty documents may contain only &nbsp; entities or non-breaking space characters
+   * which are used by the Paragraph extension to preserve blank lines.
+   */
+  isEmptyOutput(t) {
+    return !t || t.trim() === "" ? !0 : t.replace(/&nbsp;/g, "").replace(/\u00A0/g, "").trim() === "";
+  }
+  /**
+   * Parse markdown string into Tiptap JSON document using registered extension handlers.
+   */
+  parse(t) {
+    if (!this.hasMarked())
+      throw new Error("No marked instance available for parsing");
+    const e = this.markedInstance.lexer(t);
+    return {
+      type: "doc",
+      content: this.parseTokens(e, !0)
+    };
+  }
+  /**
+   * Convert an array of marked tokens into Tiptap JSON nodes using registered extension handlers.
+   */
+  parseTokens(t, e = !1) {
+    const n = t.reduce((i, a, o) => (a.type !== "space" && i.push(o), i), []);
+    let s = -1, r = 0;
+    return t.flatMap((i, a) => {
+      for (var o; r < n.length && n[r] < a; )
+        s = n[r], r += 1;
+      if (e && i.type === "space") {
+        const h = (o = n[r]) != null ? o : -1;
+        return this.createImplicitEmptyParagraphsFromSpace(i, s, h);
+      }
+      const l = this.parseToken(i, e);
+      return l === null ? [] : Array.isArray(l) ? l : [l];
+    });
+  }
+  createImplicitEmptyParagraphsFromSpace(t, e, n) {
+    const s = this.countParagraphSeparators(t.raw || "");
+    if (s === 0)
+      return [];
+    const i = Math.max(s - (e === -1 || n === -1 ? 0 : 1), 0);
+    return Array.from({ length: i }, () => ({ type: "paragraph", content: [] }));
+  }
+  countParagraphSeparators(t) {
+    return (t.replace(/\r\n/g, `
+`).match(/\n\n/g) || []).length;
+  }
+  /**
+   * Parse a single token into Tiptap JSON using the appropriate registered handler.
+   */
+  parseToken(t, e = !1) {
+    if (!t.type)
+      return null;
+    if (t.type === "list")
+      return this.parseListToken(t);
+    const n = this.getHandlersForToken(t.type), s = this.createParseHelpers();
+    if (n.find((i) => {
+      if (!i.parseMarkdown)
+        return !1;
+      const a = i.parseMarkdown(t, s), o = this.normalizeParseResult(a);
+      return o && (!Array.isArray(o) || o.length > 0) ? (this.lastParseResult = o, !0) : !1;
+    }) && this.lastParseResult) {
+      const i = this.lastParseResult;
+      return this.lastParseResult = null, i;
+    }
+    return this.parseFallbackToken(t, e);
+  }
+  /**
+   * Parse a list token, handling mixed bullet and task list items by splitting them into separate lists.
+   * This ensures that consecutive task items and bullet items are grouped and parsed as separate list nodes.
+   *
+   * @param token The list token to parse
+   * @returns Array of parsed list nodes, or null if parsing fails
+   */
+  parseListToken(t) {
+    if (!t.items || t.items.length === 0)
+      return this.parseTokenWithHandlers(t);
+    const e = t.items.some((o) => K(o).isTask), n = t.items.some((o) => !K(o).isTask);
+    if (!e || !n || this.getHandlersForToken("taskList").length === 0)
+      return this.parseTokenWithHandlers(t);
+    const s = [];
+    let r = [], i = null;
+    for (let o = 0; o < t.items.length; o += 1) {
+      const l = t.items[o], { isTask: h, checked: c, indentLevel: p } = K(l);
+      let u = l;
+      if (h) {
+        const w = (l.raw || l.text || "").split(`
+`), y = w[0].match(/^\s*[-+*]\s+\[([ xX])\]\s+(.*)$/), b = y ? y[2] : "";
+        let T = [];
+        if (w.length > 1 && w.slice(1).join(`
+`).trim()) {
+          const $ = w.slice(1), d = $.filter((m) => m.trim());
+          if (d.length > 0) {
+            const m = Math.min(...d.map((B) => B.length - B.trimStart().length)), E = $.map((B) => B.trim() ? B.slice(m) : "").join(`
+`).trim();
+            E && (T = this.markedInstance.lexer(`${E}
+`));
+          }
+        }
+        u = {
+          type: "taskItem",
+          raw: "",
+          mainContent: b,
+          indentLevel: p,
+          checked: c ?? !1,
+          text: b,
+          tokens: this.lexer.inlineTokens(b),
+          nestedTokens: T
+        };
+      }
+      const g = h ? "taskList" : "list";
+      i !== g ? (r.length > 0 && s.push({ type: i, items: r }), r = [u], i = g) : r.push(u);
+    }
+    r.length > 0 && s.push({ type: i, items: r });
+    const a = [];
+    for (let o = 0; o < s.length; o += 1) {
+      const l = s[o], h = { ...t, type: l.type, items: l.items }, c = this.parseToken(h);
+      c && (Array.isArray(c) ? a.push(...c) : a.push(c));
+    }
+    return a.length > 0 ? a : null;
+  }
+  /**
+   * Parse a token using registered handlers (extracted for reuse).
+   */
+  parseTokenWithHandlers(t) {
+    if (!t.type)
+      return null;
+    const e = this.getHandlersForToken(t.type), n = this.createParseHelpers();
+    if (e.find((r) => {
+      if (!r.parseMarkdown)
+        return !1;
+      const i = r.parseMarkdown(t, n), a = this.normalizeParseResult(i);
+      return a && (!Array.isArray(a) || a.length > 0) ? (this.lastParseResult = a, !0) : !1;
+    }) && this.lastParseResult) {
+      const r = this.lastParseResult;
+      return this.lastParseResult = null, r;
+    }
+    return this.parseFallbackToken(t);
+  }
+  /**
+   * Creates helper functions for parsing markdown tokens.
+   * @returns An object containing helper functions for parsing.
+   */
+  createParseHelpers() {
+    return {
+      parseInline: (t) => this.parseInlineTokens(t),
+      parseChildren: (t) => this.parseTokens(t),
+      parseBlockChildren: (t) => this.parseTokens(t, !0),
+      createTextNode: (t, e) => ({
+        type: "text",
+        text: t,
+        marks: e || void 0
+      }),
+      createNode: (t, e, n) => {
+        const s = {
+          type: t,
+          attrs: e || void 0,
+          content: n || void 0
+        };
+        return (!e || Object.keys(e).length === 0) && delete s.attrs, s;
+      },
+      applyMark: (t, e, n) => ({
+        mark: t,
+        content: e,
+        attrs: n && Object.keys(n).length > 0 ? n : void 0
+      })
+    };
+  }
+  /**
+   * Escape special regex characters in a string.
+   */
+  escapeRegex(t) {
+    return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Parse inline tokens (bold, italic, links, etc.) into text nodes with marks.
+   * This is the complex part that handles mark nesting and boundaries.
+   */
+  parseInlineTokens(t) {
+    var e, n, s, r;
+    const i = [];
+    for (let a = 0; a < t.length; a += 1) {
+      const o = t[a];
+      if (o.type === "text")
+        i.push({
+          type: "text",
+          text: o.text || ""
+        });
+      else if (o.type === "html") {
+        const l = ((n = (e = o.raw) != null ? e : o.text) != null ? n : "").toString(), h = /^<\/[\s]*[\w-]+/i.test(l), c = l.match(/^<[\s]*([\w-]+)(\s|>|\/|$)/i);
+        if (!h && c && !/\/>$/.test(l)) {
+          const u = c[1], g = this.escapeRegex(u), f = new RegExp(`^<\\/\\s*${g}\\b`, "i");
+          let w = -1;
+          const y = [l];
+          for (let b = a + 1; b < t.length; b += 1) {
+            const T = t[b], R = ((r = (s = T.raw) != null ? s : T.text) != null ? r : "").toString();
+            if (y.push(R), T.type === "html" && f.test(R)) {
+              w = b;
+              break;
+            }
+          }
+          if (w !== -1) {
+            const b = y.join(""), T = {
+              type: "html",
+              raw: b,
+              text: b,
+              block: !1
+            }, R = this.parseHTMLToken(T);
+            if (R) {
+              const $ = this.normalizeParseResult(R);
+              Array.isArray($) ? i.push(...$) : $ && i.push($);
+            }
+            a = w;
+            continue;
+          }
+        }
+        const p = this.parseHTMLToken(o);
+        if (p) {
+          const u = this.normalizeParseResult(p);
+          Array.isArray(u) ? i.push(...u) : u && i.push(u);
+        }
+      } else if (o.type) {
+        const l = this.getHandlerForToken(o.type);
+        if (l && l.parseMarkdown) {
+          const h = this.createParseHelpers(), c = l.parseMarkdown(o, h);
+          if (this.isMarkResult(c)) {
+            const p = this.applyMarkToContent(c.mark, c.content, c.attrs);
+            i.push(...p);
+          } else {
+            const p = this.normalizeParseResult(c);
+            Array.isArray(p) ? i.push(...p) : p && i.push(p);
+          }
+        } else o.tokens && i.push(...this.parseInlineTokens(o.tokens));
+      }
+    }
+    return i;
+  }
+  /**
+   * Apply a mark to content nodes.
+   */
+  applyMarkToContent(t, e, n) {
+    return e.map((s) => {
+      if (s.type === "text") {
+        const r = s.marks || [], i = n ? { type: t, attrs: n } : { type: t };
+        return {
+          ...s,
+          marks: [...r, i]
+        };
+      }
+      return {
+        ...s,
+        content: s.content ? this.applyMarkToContent(t, s.content, n) : void 0
+      };
+    });
+  }
+  /**
+  * Check if a parse result represents a mark to be applied.
+  */
+  isMarkResult(t) {
+    return t && typeof t == "object" && "mark" in t;
+  }
+  /**
+   * Normalize parse results to ensure they're valid JSONContent.
+   */
+  normalizeParseResult(t) {
+    return t ? this.isMarkResult(t) ? t.content : t : null;
+  }
+  /**
+   * Fallback parsing for common tokens when no specific handler is registered.
+   */
+  parseFallbackToken(t, e = !1) {
+    switch (t.type) {
+      case "paragraph":
+        return {
+          type: "paragraph",
+          content: t.tokens ? this.parseInlineTokens(t.tokens) : []
+        };
+      case "heading":
+        return {
+          type: "heading",
+          attrs: { level: t.depth || 1 },
+          content: t.tokens ? this.parseInlineTokens(t.tokens) : []
+        };
+      case "text":
+        return {
+          type: "text",
+          text: t.text || ""
+        };
+      case "html":
+        return this.parseHTMLToken(t);
+      case "space":
+        return null;
+      default:
+        return t.tokens ? this.parseTokens(t.tokens, e) : null;
+    }
+  }
+  /**
+   * Parse HTML tokens using extensions' parseHTML methods.
+   * This allows HTML within markdown to be parsed according to extension rules.
+   */
+  parseHTMLToken(t) {
+    const e = t.text || t.raw || "";
+    if (!e.trim())
+      return null;
+    if (typeof window > "u")
+      return t.block ? {
+        type: "paragraph",
+        content: [
+          {
+            type: "text",
+            text: e
+          }
+        ]
+      } : {
+        type: "text",
+        text: e
+      };
+    try {
+      const n = ve(e, this.baseExtensions);
+      return n.type === "doc" && n.content ? t.block ? n.content : n.content.length === 1 && n.content[0].type === "paragraph" && n.content[0].content ? n.content[0].content : n.content : n;
+    } catch (n) {
+      throw new Error(`Failed to parse HTML in markdown: ${n}`);
+    }
+  }
+  renderNodeToMarkdown(t, e, n = 0, s = 0, r = {}) {
+    var i;
+    if (t.type === "text")
+      return t.text || "";
+    if (!t.type)
+      return "";
+    const a = this.getHandlerForToken(t.type);
+    if (!a)
+      return "";
+    const o = Array.isArray(e?.content) && n > 0 ? e.content[n - 1] : void 0, l = {
+      renderChildren: (p, u) => {
+        const g = a.isIndenting ? s + 1 : s;
+        return !Array.isArray(p) && p.content ? this.renderNodes(p.content, t, u || "", n, g) : this.renderNodes(p, t, u || "", n, g);
+      },
+      renderChild: (p, u) => {
+        const g = a.isIndenting ? s + 1 : s;
+        return this.renderNodeToMarkdown(p, t, u, g);
+      },
+      indent: (p) => this.indentString + p,
+      wrapInBlock: Bt
+    }, h = {
+      index: n,
+      level: s,
+      parentType: e?.type,
+      previousNode: o,
+      meta: {
+        parentAttrs: e?.attrs,
+        ...r
+      }
+    };
+    return ((i = a.renderMarkdown) == null ? void 0 : i.call(a, t, l, h)) || "";
+  }
+  /**
+   * Render a node or an array of nodes. Parent type controls how children
+   * are joined (which determines newline insertion between children).
+   */
+  renderNodes(t, e, n = "", s = 0, r = 0) {
+    return Array.isArray(t) ? this.renderNodesWithMarkBoundaries(t, e, n, r) : t.type ? this.renderNodeToMarkdown(t, e, s, r) : "";
+  }
+  /**
+   * Render an array of nodes while properly tracking mark boundaries.
+   * This handles cases where marks span across multiple text nodes.
+   */
+  renderNodesWithMarkBoundaries(t, e, n = "", s = 0) {
+    const r = [], i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Map();
+    return t.forEach((l, h) => {
+      const c = h < t.length - 1 ? t[h + 1] : null;
+      if (l.type)
+        if (l.type === "text") {
+          let p = l.text || "";
+          const u = new Map((l.marks || []).map((d) => [d.type, d])), g = Ot(i, u), f = Ht(u, c), w = f.filter((d) => i.has(d)), y = w.length > 0 && g.length > 0;
+          let b = "";
+          if (f.length > 0 && !y) {
+            const d = p.match(/(\s+)$/);
+            d && (b = d[1], p = p.slice(0, -b.length));
+          }
+          y || f.forEach((d) => {
+            if (!i.has(d))
+              return;
+            const m = u.get(d), v = this.getMarkClosing(d, m, o.get(d));
+            v && (p += v), i.has(d) && (i.delete(d), o.delete(d));
+          });
+          let T = "";
+          if (g.length > 0) {
+            const d = p.match(/^(\s+)/);
+            d && (T = d[1], p = p.slice(T.length));
+          }
+          g.forEach(({ type: d, mark: m }) => {
+            const v = a.has(d) ? "html" : "markdown", E = this.getMarkOpening(d, m, v);
+            E && (p = E + p), o.set(d, v), a.delete(d);
+          }), y || g.slice().reverse().forEach(({ type: d, mark: m }) => {
+            i.set(d, m);
+          }), p = T + p;
+          let R;
+          if (y) {
+            const d = new Set((c?.marks || []).map((m) => m.type));
+            g.forEach(({ type: m }) => {
+              d.has(m) && this.getHtmlReopenTags(m) && a.add(m);
+            }), R = [
+              ...g.map((m) => m.type),
+              // inner (opened here) — close first
+              ...w
+              // outer (were active before) — close last
+            ];
+          } else
+            R = qt(i, u, c, this.markSetsEqual.bind(this));
+          let $ = "";
+          if (R.length > 0) {
+            const d = p.match(/(\s+)$/);
+            d && ($ = d[1], p = p.slice(0, -$.length));
+          }
+          R.forEach((d) => {
+            var m;
+            const v = (m = i.get(d)) != null ? m : u.get(d), E = this.getMarkClosing(d, v, o.get(d));
+            E && (p += E), i.delete(d), o.delete(d);
+          }), p += $, p += b, r.push(p);
+        } else {
+          const p = new Map(i), u = new Map(o), g = Nt(i, (y, b) => this.getMarkClosing(y, b, o.get(y)));
+          o.clear();
+          const f = this.renderNodeToMarkdown(l, e, h, s), w = l.type === "hardBreak" ? "" : Dt(p, i, (y, b) => {
+            var T;
+            const R = (T = u.get(y)) != null ? T : "markdown";
+            return o.set(y, R), this.getMarkOpening(y, b, R);
+          });
+          r.push(g + f + w);
+        }
+    }), r.join(n);
+  }
+  /**
+   * Get the opening markdown syntax for a mark type.
+   */
+  getMarkOpening(t, e, n = "markdown") {
+    var s;
+    if (n === "html")
+      return ((s = this.getHtmlReopenTags(t)) == null ? void 0 : s.open) || "";
+    const r = this.getHandlersForNodeType(t), i = r.length > 0 ? r[0] : void 0;
+    if (!i || !i.renderMarkdown)
+      return "";
+    const a = "__TIPTAP_MARKDOWN_PLACEHOLDER__", o = {
+      type: t,
+      attrs: e.attrs || {},
+      content: [{ type: "text", text: a }]
+    };
+    try {
+      const l = i.renderMarkdown(
+        o,
+        {
+          renderChildren: () => a,
+          renderChild: () => a,
+          indent: (c) => c,
+          wrapInBlock: (c, p) => c + p
+        },
+        { index: 0, level: 0, parentType: "text", meta: {} }
+      ), h = l.indexOf(a);
+      return h >= 0 ? l.substring(0, h) : "";
+    } catch (l) {
+      throw new Error(`Failed to get mark opening for ${t}: ${l}`);
+    }
+  }
+  /**
+   * Get the closing markdown syntax for a mark type.
+   */
+  getMarkClosing(t, e, n = "markdown") {
+    var s;
+    if (n === "html")
+      return ((s = this.getHtmlReopenTags(t)) == null ? void 0 : s.close) || "";
+    const r = this.getHandlersForNodeType(t), i = r.length > 0 ? r[0] : void 0;
+    if (!i || !i.renderMarkdown)
+      return "";
+    const a = "__TIPTAP_MARKDOWN_PLACEHOLDER__", o = {
+      type: t,
+      attrs: e.attrs || {},
+      content: [{ type: "text", text: a }]
+    };
+    try {
+      const l = i.renderMarkdown(
+        o,
+        {
+          renderChildren: () => a,
+          renderChild: () => a,
+          indent: (p) => p,
+          wrapInBlock: (p, u) => p + u
+        },
+        { index: 0, level: 0, parentType: "text", meta: {} }
+      ), h = l.indexOf(a), c = h + a.length;
+      return h >= 0 ? l.substring(c) : "";
+    } catch (l) {
+      throw new Error(`Failed to get mark closing for ${t}: ${l}`);
+    }
+  }
+  /**
+   * Returns the inline HTML tags an extension exposes for overlap-boundary
+   * reopen handling, if that mark explicitly opted into HTML reopen mode.
+   */
+  getHtmlReopenTags(t) {
+    const e = this.getHandlersForNodeType(t), n = e.length > 0 ? e[0] : void 0;
+    return n?.htmlReopen;
+  }
+  /**
+   * Check if two mark sets are equal.
+   */
+  markSetsEqual(t, e) {
+    return t.size !== e.size ? !1 : Array.from(t.keys()).every((n) => e.has(n));
+  }
+}, ke = Me;
+ze.create({
+  name: "markdown",
+  addOptions() {
+    return {
+      indentation: { style: "space", size: 2 },
+      marked: void 0,
+      markedOptions: {}
+    };
+  },
+  addCommands() {
+    return {
+      setContent: (t, e) => {
+        if (!e?.contentType)
+          return C.setContent(t, e);
+        if (Q(t, e?.contentType) !== "markdown" || !this.editor.markdown)
+          return C.setContent(t, e);
+        const s = this.editor.markdown.parse(t);
+        return C.setContent(s, e);
+      },
+      insertContent: (t, e) => {
+        if (!e?.contentType)
+          return C.insertContent(t, e);
+        if (Q(t, e?.contentType) !== "markdown" || !this.editor.markdown)
+          return C.insertContent(t, e);
+        const s = this.editor.markdown.parse(t);
+        return C.insertContent(s, e);
+      },
+      insertContentAt: (t, e, n) => {
+        if (!n?.contentType)
+          return C.insertContentAt(t, e, n);
+        if (Q(e, n?.contentType) !== "markdown" || !this.editor.markdown)
+          return C.insertContentAt(t, e, n);
+        const r = this.editor.markdown.parse(e);
+        return C.insertContentAt(t, r, n);
+      }
+    };
+  },
+  addStorage() {
+    return {
+      manager: new ke({
+        indentation: this.options.indentation,
+        marked: this.options.marked,
+        markedOptions: this.options.markedOptions,
+        extensions: []
+      })
+    };
+  },
+  onBeforeCreate() {
+    if (this.editor.markdown) {
+      console.error(
+        "[tiptap][markdown]: There is already a `markdown` property on the editor instance. This might lead to unexpected behavior."
+      );
+      return;
+    }
+    if (this.storage.manager = new ke({
+      indentation: this.options.indentation,
+      marked: this.options.marked,
+      markedOptions: this.options.markedOptions,
+      extensions: this.editor.extensionManager.baseExtensions
+    }), this.editor.markdown = this.storage.manager, this.editor.getMarkdown = () => this.storage.manager.serialize(this.editor.getJSON()), !this.editor.options.contentType || Q(this.editor.options.content, this.editor.options.contentType) !== "markdown")
+      return;
+    if (!this.editor.markdown)
+      throw new Error(
+        '[tiptap][markdown]: The `contentType` option is set to "markdown", but the Markdown extension is not added to the editor. Please add the Markdown extension to use this feature.'
+      );
+    if (this.editor.options.content === void 0 || typeof this.editor.options.content != "string")
+      throw new Error(
+        '[tiptap][markdown]: The `contentType` option is set to "markdown", but the initial content is not a string. Please provide the initial content as a markdown string.'
+      );
+    const e = this.editor.markdown.parse(this.editor.options.content);
+    this.editor.options.content = e;
+  }
+});
+const Ft = [
+  Ee,
+  _e,
+  Ie,
+  Ge.configure({ levels: [1, 2, 3] }),
+  Pe,
+  Le,
+  Be,
+  Xe.configure({ taskList: !1, taskItem: !1, orderedList: !1 }),
+  He,
+  Oe,
+  qe,
+  Ne,
+  De,
+  Fe,
+  Qe,
+  Ze,
+  je,
+  We
+];
+function Qt() {
+  const t = new Me();
+  for (const e of Ft)
+    t.registerExtension(e);
+  return t;
+}
+let U = null;
+function Ae() {
+  return U || (U = Qt()), U;
+}
+function jt(t) {
+  return Ae().serialize(t);
+}
+function Wt(t) {
+  const e = Ae().parse(t);
+  for (; e.content.length > 1; ) {
+    const n = e.content[e.content.length - 1];
+    if (n.type === "paragraph" && (!("content" in n) || !n.content?.length))
+      e.content.pop();
+    else break;
+  }
+  return e;
+}
 export {
-  s as QalamEditor,
-  f as QalamRenderer,
-  t as QuranRef,
-  Q as getAllSurahs,
-  p as getSurahInfo,
-  u as getVerseText,
-  S as isDataLoaded,
-  g as loadQuranData,
-  d as resolveAST,
-  i as resolveSurah,
-  e as validateAST
+  Me as MarkdownManager,
+  Jt as QalamEditor,
+  Yt as QalamRenderer,
+  Ne as QuranRef,
+  Qt as createMarkdownManager,
+  jt as docToMarkdown,
+  rn as getAllSurahs,
+  sn as getSurahInfo,
+  an as getVerseText,
+  ln as isDataLoaded,
+  on as loadQuranData,
+  Wt as markdownToDoc,
+  tn as resolveAST,
+  cn as resolveSurah,
+  Kt as validateAST
 };