stream-markdown-parser 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,1726 +1,2258 @@
-import re from "markdown-it";
-import oe from "markdown-it-container";
-function R() {
-  return [
-    {
-      type: "table_open",
-      tag: "table",
-      attrs: void 0,
-      map: void 0,
-      children: void 0,
-      content: "",
-      markup: "",
-      info: "",
-      level: 0,
-      loading: !0,
-      meta: void 0
-    },
-    {
-      type: "thead_open",
-      tag: "thead",
-      attrs: void 0,
-      block: !0,
-      level: 1,
-      children: void 0
-    },
-    {
-      type: "tr_open",
-      tag: "tr",
-      attrs: void 0,
-      block: !0,
-      level: 2,
-      children: void 0
-    }
-  ];
+import MarkdownIt from "markdown-it";
+import { full } from "markdown-it-emoji";
+import markdownItFootnote from "markdown-it-footnote";
+import markdownItIns from "markdown-it-ins";
+import markdownItMark from "markdown-it-mark";
+import markdownItSub from "markdown-it-sub";
+import markdownItSup from "markdown-it-sup";
+import * as markdownItCheckbox from "markdown-it-task-checkbox";
+import markdownItContainer from "markdown-it-container";
+
+//#region src/config.ts
+let defaultMathOptions;
+function setDefaultMathOptions(opts) {
+	defaultMathOptions = opts;
 }
-function k() {
-  return [
-    {
-      type: "tr_close",
-      tag: "tr",
-      attrs: void 0,
-      block: !0,
-      level: 2,
-      children: void 0
-    },
-    {
-      type: "thead_close",
-      tag: "thead",
-      attrs: void 0,
-      block: !0,
-      level: 1,
-      children: void 0
-    },
-    {
-      type: "table_close",
-      tag: "table",
-      attrs: void 0,
-      map: void 0,
-      children: void 0,
-      content: "",
-      markup: "",
-      info: "",
-      level: 0,
-      meta: void 0
-    }
-  ];
+function getDefaultMathOptions() {
+	return defaultMathOptions;
 }
-function O(e) {
-  return [{
-    type: "th_open",
-    tag: "th",
-    attrs: void 0,
-    block: !0,
-    level: 3,
-    children: void 0
-  }, {
-    type: "inline",
-    tag: "",
-    children: [
-      {
-        tag: "",
-        type: "text",
-        block: !1,
-        content: e,
-        children: void 0
-      }
-    ],
-    content: e,
-    level: 4,
-    attrs: void 0,
-    block: !0
-  }, {
-    type: "th_close",
-    tag: "th",
-    attrs: void 0,
-    block: !0,
-    level: 3,
-    children: void 0
-  }];
+
+//#endregion
+//#region src/plugins/containers.ts
+function applyContainers(md) {
+	[
+		"admonition",
+		"info",
+		"warning",
+		"error",
+		"tip",
+		"danger",
+		"note",
+		"caution"
+	].forEach((name) => {
+		md.use(markdownItContainer, name, { render(tokens, idx) {
+			if (tokens[idx].nesting === 1) return `<div class="vmr-container vmr-container-${name}">`;
+			else return "</div>\n";
+		} });
+	});
+	md.block.ruler.before("fence", "vmr_container_fallback", (state, startLine, endLine, silent) => {
+		const startPos = state.bMarks[startLine] + state.tShift[startLine];
+		const lineMax = state.eMarks[startLine];
+		const markerMatch = state.src.slice(startPos, lineMax).match(/^:::\s*(\w+)/);
+		if (!markerMatch) return false;
+		if (silent) return true;
+		const name = markerMatch[1];
+		let nextLine = startLine + 1;
+		let found = false;
+		while (nextLine <= endLine) {
+			const sPos = state.bMarks[nextLine] + state.tShift[nextLine];
+			const ePos = state.eMarks[nextLine];
+			if (state.src.slice(sPos, ePos).trim() === ":::") {
+				found = true;
+				break;
+			}
+			nextLine++;
+		}
+		if (!found) return false;
+		state.push("vmr_container_open", "div", 1).attrSet("class", `vmr-container vmr-container-${name}`);
+		const contentLines = [];
+		for (let i = startLine + 1; i < nextLine; i++) {
+			const sPos = state.bMarks[i] + state.tShift[i];
+			const ePos = state.eMarks[i];
+			contentLines.push(state.src.slice(sPos, ePos));
+		}
+		state.push("paragraph_open", "p", 1);
+		const inlineToken = state.push("inline", "", 0);
+		inlineToken.content = contentLines.join("\n");
+		inlineToken.map = [startLine + 1, nextLine];
+		inlineToken.children = [];
+		state.md.inline.parse(inlineToken.content, state.md, state.env, inlineToken.children);
+		state.push("paragraph_close", "p", -1);
+		state.push("vmr_container_close", "div", -1);
+		state.line = nextLine + 1;
+		return true;
+	});
 }
-function ce(e) {
-  const c = [...e];
-  if (e.length < 3)
-    return c;
-  const i = e.length - 2, o = e[i];
-  if (o.type === "inline") {
-    const n = typeof o.content == "string" ? o.content : "", r = o.children && o.children[0];
-    if (/^\|(?:[^|\n]+\|?)+/.test(n)) {
-      const t = (r && typeof r.content == "string" ? r.content.slice(1) : "").split("|").map((a) => a.trim()).filter(Boolean).flatMap((a) => O(a)), s = [
-        ...R(),
-        ...t,
-        ...k()
-      ];
-      c.splice(i - 1, 3, ...s);
-    } else if (/^\|(?:[^|\n]+\|)+\n\|:?-/.test(n)) {
-      const t = (r && typeof r.content == "string" ? r.content.slice(1, -1) : "").split("|").map((a) => a.trim()).flatMap((a) => O(a)), s = [
-        ...R(),
-        ...t,
-        ...k()
-      ];
-      c.splice(i - 1, 3, ...s);
-    } else /^\|(?:[^|\n:]+\|)+\n\|:?$/.test(n) && (typeof o.content == "string" && (o.content = o.content.slice(0, -2)), o.children && o.children.splice(2, 1));
-  }
-  return c;
+
+//#endregion
+//#region src/findMatchingClose.ts
+function findMatchingClose(src, startIdx, open, close) {
+	const len = src.length;
+	if (open === "$$" && close === "$$") {
+		let i$1 = startIdx;
+		while (i$1 < len - 1) {
+			if (src[i$1] === "$" && src[i$1 + 1] === "$") {
+				let k = i$1 - 1;
+				let backslashes = 0;
+				while (k >= 0 && src[k] === "\\") {
+					backslashes++;
+					k--;
+				}
+				if (backslashes % 2 === 0) return i$1;
+			}
+			i$1++;
+		}
+		return -1;
+	}
+	const openChar = open[open.length - 1];
+	const closeSeq = close;
+	let depth = 0;
+	let i = startIdx;
+	while (i < len) {
+		if (src.slice(i, i + closeSeq.length) === closeSeq) {
+			let k = i - 1;
+			let backslashes = 0;
+			while (k >= 0 && src[k] === "\\") {
+				backslashes++;
+				k--;
+			}
+			if (backslashes % 2 === 0) {
+				if (depth === 0) return i;
+				depth--;
+				i += closeSeq.length;
+				continue;
+			}
+		}
+		const ch = src[i];
+		if (ch === "\\") {
+			i += 2;
+			continue;
+		}
+		if (ch === openChar) depth++;
+		else if (ch === closeSeq[closeSeq.length - 1]) {
+			if (depth > 0) depth--;
+		}
+		i++;
+	}
+	return -1;
 }
-function ie(e) {
-  return {
-    type: "checkbox",
-    checked: e.meta?.checked === !0,
-    raw: e.meta?.checked ? "[x]" : "[ ]"
-  };
+var findMatchingClose_default = findMatchingClose;
+
+//#endregion
+//#region src/plugins/isMathLike.ts
+const TEX_BRACE_COMMANDS = [
+	"mathbf",
+	"boldsymbol",
+	"mathbb",
+	"mathcal",
+	"mathfrak",
+	"mathrm",
+	"mathit",
+	"mathsf",
+	"vec",
+	"hat",
+	"bar",
+	"tilde",
+	"overline",
+	"underline",
+	"mathscr",
+	"mathnormal",
+	"operatorname",
+	"mathbf*"
+];
+const ESCAPED_TEX_BRACE_COMMANDS = TEX_BRACE_COMMANDS.map((c) => c.replace(/[.*+?^${}()|[\\]"\]/g, "\\$&")).join("|");
+const TEX_CMD_RE = /\\[a-z]+/i;
+const PREFIX_CLASS = "(?:\\\\|\\u0008)";
+const TEX_CMD_WITH_BRACES_RE = new RegExp(`${PREFIX_CLASS}(?:${ESCAPED_TEX_BRACE_COMMANDS})\\s*\\{[^}]+\\}`, "i");
+const TEX_BRACE_CMD_START_RE = new RegExp(`(?:${PREFIX_CLASS})?(?:${ESCAPED_TEX_BRACE_COMMANDS})\s*\{`, "i");
+const TEX_SPECIFIC_RE = /\\(?:text|frac|left|right|times)/;
+const OPS_RE = /* @__PURE__ */ new RegExp("(?<!\\+)\\+(?!\\+)|[=\\-*/^<>]|\\\\times|\\\\pm|\\\\cdot|\\\\le|\\\\ge|\\\\neq");
+const FUNC_CALL_RE = /[A-Z]+\s*\([^)]+\)/i;
+const WORDS_RE = /\b(?:sin|cos|tan|log|ln|exp|sqrt|frac|sum|lim|int|prod)\b/;
+const DATE_TIME_RE = /\b\d{4}\/\d{1,2}\/\d{1,2}(?:[ T]\d{1,2}:\d{2}(?::\d{2})?)?\b/;
+function isMathLike(s) {
+	if (!s) return false;
+	const norm = s.replace(/\u0008/g, "\\b");
+	const stripped = norm.trim();
+	if (DATE_TIME_RE.test(stripped)) return false;
+	if (stripped.length > 2e3) return true;
+	if (/[./]\s*\D|\D\s*[./]/.test(s)) return false;
+	const texCmd = TEX_CMD_RE.test(norm);
+	const texCmdWithBraces = TEX_CMD_WITH_BRACES_RE.test(norm);
+	const texBraceStart = TEX_BRACE_CMD_START_RE.test(norm);
+	const texSpecific = TEX_SPECIFIC_RE.test(norm);
+	const superSub = /(?:^|[^\w\\])(?:[A-Z]|\\[A-Z]+)_(?:\{[^}]+\}|[A-Z0-9\\])/i.test(norm) || /(?:^|[^\w\\])(?:[A-Z]|\\[A-Z]+)\^(?:\{[^}]+\}|[A-Z0-9\\])/i.test(norm);
+	const ops = OPS_RE.test(norm);
+	const funcCall = FUNC_CALL_RE.test(norm);
+	const words = WORDS_RE.test(norm);
+	return texCmd || texCmdWithBraces || texBraceStart || texSpecific || superSub || ops || funcCall || words;
 }
-function le(e) {
-  return {
-    type: "checkbox_input",
-    checked: e.attrGet("checked") === "" || e.attrGet("checked") === "true",
-    raw: e.attrGet("checked") === "" || e.attrGet("checked") === "true" ? "[x]" : "[ ]"
-  };
+
+//#endregion
+//#region src/plugins/math.ts
+const KATEX_COMMANDS = [
+	"ldots",
+	"cdots",
+	"quad",
+	"in",
+	"infty",
+	"perp",
+	"mid",
+	"operatorname",
+	"to",
+	"rightarrow",
+	"leftarrow",
+	"math",
+	"mathrm",
+	"mathbf",
+	"mathit",
+	"mathbb",
+	"mathcal",
+	"mathfrak",
+	"alpha",
+	"beta",
+	"gamma",
+	"delta",
+	"epsilon",
+	"lambda",
+	"sum",
+	"prod",
+	"int",
+	"sqrt",
+	"fbox",
+	"boxed",
+	"color",
+	"rule",
+	"edef",
+	"fcolorbox",
+	"hline",
+	"hdashline",
+	"cdot",
+	"times",
+	"pm",
+	"le",
+	"ge",
+	"neq",
+	"sin",
+	"cos",
+	"tan",
+	"log",
+	"ln",
+	"exp",
+	"lim",
+	"frac",
+	"text",
+	"left",
+	"right",
+	"times"
+];
+const ESCAPED_KATEX_COMMANDS = KATEX_COMMANDS.slice().sort((a, b) => b.length - a.length).map((c) => c.replace(/[.*+?^${}()|[\\]\\\]/g, "\\$&")).join("|");
+const CONTROL_CHARS_CLASS = "[	\r\b\f\v]";
+const CONTROL_MAP = {
+	"	": "t",
+	"\r": "r",
+	"\b": "b",
+	"\f": "f",
+	"\v": "v"
+};
+function countUnescapedStrong(s) {
+	const re = /(^|[^\\])(__|\*\*)/g;
+	let c = 0;
+	while (re.exec(s) !== null) c++;
+	return c;
 }
-function se(e) {
-  return {
-    type: "emoji",
-    name: e.content || "",
-    markup: e.markup || "",
-    raw: `:${e.content || ""}:`
-  };
+function normalizeStandaloneBackslashT(s, opts) {
+	const commands = opts?.commands ?? KATEX_COMMANDS;
+	const escapeExclamation = opts?.escapeExclamation ?? true;
+	const useDefault = opts?.commands == null;
+	let re;
+	if (useDefault) re = new RegExp(`${CONTROL_CHARS_CLASS}|(?<!\\\\|\\w)(${ESCAPED_KATEX_COMMANDS})\\b`, "g");
+	else {
+		const commandPattern = `(?:${commands.slice().sort((a, b) => b.length - a.length).map((c) => c.replace(/[.*+?^${}()|[\\]\\"\]/g, "\\$&")).join("|")})`;
+		re = new RegExp(`${CONTROL_CHARS_CLASS}|(?<!\\\\|\\w)(${commandPattern})\\b`, "g");
+	}
+	let out = s.replace(re, (m, cmd) => {
+		if (CONTROL_MAP[m] !== void 0) return `\\${CONTROL_MAP[m]}`;
+		if (cmd && commands.includes(cmd)) return `\\${cmd}`;
+		return m;
+	});
+	if (escapeExclamation) out = out.replace(/(^|[^\\])!/g, "$1\\!");
+	const braceEscaped = useDefault ? [ESCAPED_TEX_BRACE_COMMANDS, ESCAPED_KATEX_COMMANDS].filter(Boolean).join("|") : [commands.map((c) => c.replace(/[.*+?^${}()|[\\]\\\]/g, "\\$&")).join("|"), ESCAPED_TEX_BRACE_COMMANDS].filter(Boolean).join("|");
+	let result = out;
+	if (braceEscaped) {
+		const braceCmdRe = new RegExp(`(^|[^\\\\])(${braceEscaped})\\s*\\{`, "g");
+		result = result.replace(braceCmdRe, (_m, p1, p2) => `${p1}\\${p2}{`);
+	}
+	result = result.replace(/span\{([^}]+)\}/, "span\\{$1\\}").replace(/\\operatorname\{span\}\{((?:[^{}]|\{[^}]*\})+)\}/, "\\operatorname{span}\\{$1\\}");
+	return result;
 }
-function D(e, c) {
-  const i = [];
-  let o = "", n = c + 1;
-  const r = [];
-  for (; n < e.length && e[n].type !== "em_close"; )
-    o += e[n].content || "", r.push(e[n]), n++;
-  i.push(...b(r));
-  const l = {
-    type: "emphasis",
-    children: i,
-    raw: `*${o}*`
-  }, t = n < e.length ? n + 1 : e.length;
-  return { node: l, nextIndex: t };
+function applyMath(md, mathOpts) {
+	const mathInline = (state, silent) => {
+		if (/^\*[^*]+/.test(state.src)) return false;
+		const delimiters = [
+			["$$", "$$"],
+			["\\(", "\\)"],
+			["(", ")"]
+		];
+		let searchPos = 0;
+		let preMathPos = 0;
+		for (const [open, close] of delimiters) {
+			const src = state.src;
+			let foundAny = false;
+			const pushText = (text) => {
+				if (text === "undefined" || text == null) text = "";
+				if (text === "\\") {
+					state.pos = state.pos + text.length;
+					searchPos = state.pos;
+					return;
+				}
+				if (text === "\\)" || text === "\\(") {
+					const t$1 = state.push("text_special", "", 0);
+					t$1.content = text === "\\)" ? ")" : "(";
+					t$1.markup = text;
+					state.pos = state.pos + text.length;
+					searchPos = state.pos;
+					return;
+				}
+				if (!text) return;
+				const t = state.push("text", "", 0);
+				t.content = text;
+				state.pos = state.pos + text.length;
+				searchPos = state.pos;
+			};
+			while (true) {
+				if (searchPos >= src.length) break;
+				const index = src.indexOf(open, searchPos);
+				if (index === -1) break;
+				if (index > 0) {
+					let i = index - 1;
+					while (i >= 0 && src[i] === " ") i--;
+					if (i >= 0 && src[i] === "]") return false;
+				}
+				const endIdx = findMatchingClose_default(src, index + open.length, open, close);
+				if (endIdx === -1) {
+					const content$1 = src.slice(index + open.length);
+					if (isMathLike(content$1)) {
+						searchPos = index + open.length;
+						foundAny = true;
+						if (!silent) {
+							state.pending = "";
+							const isStrongPrefix = countUnescapedStrong(preMathPos ? src.slice(preMathPos, searchPos) : src.slice(0, searchPos)) % 2 === 1;
+							if (preMathPos) pushText(src.slice(preMathPos, searchPos));
+							else pushText(src.slice(0, searchPos));
+							if (isStrongPrefix) {
+								const strongToken = state.push("strong_open", "", 0);
+								strongToken.markup = src.slice(0, index + 2);
+								const token = state.push("math_inline", "math", 0);
+								token.content = normalizeStandaloneBackslashT(content$1, mathOpts);
+								token.markup = open === "$$" ? "$$" : open === "\\(" ? "\\(\\)" : open === "$" ? "$" : "()";
+								token.raw = `${open}${content$1}${close}`;
+								token.loading = true;
+								strongToken.content = content$1;
+								state.push("strong_close", "", 0);
+							} else {
+								const token = state.push("math_inline", "math", 0);
+								token.content = normalizeStandaloneBackslashT(content$1, mathOpts);
+								token.markup = open === "$$" ? "$$" : open === "\\(" ? "\\(\\)" : open === "$" ? "$" : "()";
+								token.raw = `${open}${content$1}${close}`;
+								token.loading = true;
+							}
+							state.pos = src.length;
+						}
+						searchPos = src.length;
+						preMathPos = searchPos;
+					}
+					break;
+				}
+				const content = src.slice(index + open.length, endIdx);
+				if (!isMathLike(content)) {
+					searchPos = endIdx + close.length;
+					const text = src.slice(state.pos, searchPos);
+					if (!state.pending) pushText(text);
+					continue;
+				}
+				foundAny = true;
+				if (!silent) {
+					const before = src.slice(0, index);
+					let toPushBefore = src.slice(0, searchPos) ? src.slice(preMathPos, index) : before;
+					const isStrongPrefix = countUnescapedStrong(toPushBefore) % 2 === 1;
+					if (index !== state.pos && isStrongPrefix) toPushBefore = state.pending + src.slice(state.pos, index);
+					if (state.pending !== toPushBefore) {
+						state.pending = "";
+						if (isStrongPrefix) {
+							const _match = toPushBefore.match(/(\*+)/);
+							const after = toPushBefore.slice(_match.index + _match[0].length);
+							pushText(toPushBefore.slice(0, _match.index));
+							const strongToken = state.push("strong_open", "", 0);
+							strongToken.markup = _match[0];
+							const textToken = state.push("text", "", 0);
+							textToken.content = after;
+							state.push("strong_close", "", 0);
+						} else pushText(toPushBefore);
+					}
+					if (isStrongPrefix) {
+						const strongToken = state.push("strong_open", "", 0);
+						strongToken.markup = "**";
+						const token = state.push("math_inline", "math", 0);
+						token.content = normalizeStandaloneBackslashT(content, mathOpts);
+						token.markup = open === "$$" ? "$$" : open === "\\(" ? "\\(\\)" : open === "$" ? "$" : "()";
+						token.raw = `${open}${content}${close}`;
+						token.loading = false;
+						const raw = src.slice(endIdx + close.length);
+						const isBeforeClose = raw.startsWith("*");
+						if (isBeforeClose) state.push("strong_close", "", 0);
+						if (raw) {
+							const textContentToken = state.push("text", "", 0);
+							textContentToken.content = (raw == null ? "" : String(raw)).replace(/^\*+/, "");
+						}
+						if (!isBeforeClose) state.push("strong_close", "", 0);
+						state.pos = src.length;
+						searchPos = src.length;
+						preMathPos = searchPos;
+						continue;
+					} else {
+						const token = state.push("math_inline", "math", 0);
+						token.content = normalizeStandaloneBackslashT(content, mathOpts);
+						token.markup = open === "$$" ? "$$" : open === "\\(" ? "\\(\\)" : open === "$" ? "$" : "()";
+						token.raw = `${open}${content}${close}`;
+						token.loading = false;
+					}
+				}
+				searchPos = endIdx + close.length;
+				preMathPos = searchPos;
+				state.pos = searchPos;
+			}
+			if (foundAny) {
+				if (!silent) {
+					if (searchPos < src.length) pushText(src.slice(searchPos));
+					state.pos = src.length;
+				} else state.pos = searchPos;
+				return true;
+			}
+		}
+		return false;
+	};
+	const mathBlock = (state, startLine, endLine, silent) => {
+		const delimiters = [
+			["\\[", "\\]"],
+			["[", "]"],
+			["$$", "$$"]
+		];
+		const startPos = state.bMarks[startLine] + state.tShift[startLine];
+		const lineText = state.src.slice(startPos, state.eMarks[startLine]).trim();
+		let matched = false;
+		let openDelim = "";
+		let closeDelim = "";
+		for (const [open, close] of delimiters) if (lineText === open || lineText.startsWith(open)) if (open.includes("[")) {
+			if (lineText.replace("\\", "") === "[") {
+				if (startLine + 1 < endLine) {
+					matched = true;
+					openDelim = open;
+					closeDelim = close;
+					break;
+				}
+				continue;
+			}
+		} else {
+			matched = true;
+			openDelim = open;
+			closeDelim = close;
+			break;
+		}
+		if (!matched) return false;
+		if (silent) return true;
+		if (lineText.includes(closeDelim) && lineText.indexOf(closeDelim) > openDelim.length) {
+			const startDelimIndex = lineText.indexOf(openDelim);
+			const endDelimIndex = lineText.indexOf(closeDelim, startDelimIndex + openDelim.length);
+			const content$1 = lineText.slice(startDelimIndex + openDelim.length, endDelimIndex);
+			const token$1 = state.push("math_block", "math", 0);
+			token$1.content = normalizeStandaloneBackslashT(content$1);
+			token$1.markup = openDelim === "$$" ? "$$" : openDelim === "[" ? "[]" : "\\[\\]";
+			token$1.map = [startLine, startLine + 1];
+			token$1.raw = `${openDelim}${content$1}${closeDelim}`;
+			token$1.block = true;
+			token$1.loading = false;
+			state.line = startLine + 1;
+			return true;
+		}
+		let nextLine = startLine;
+		let content = "";
+		let found = false;
+		const firstLineContent = lineText === openDelim ? "" : lineText.slice(openDelim.length);
+		if (firstLineContent.includes(closeDelim)) {
+			const endIndex = firstLineContent.indexOf(closeDelim);
+			content = firstLineContent.slice(0, endIndex);
+			found = true;
+			nextLine = startLine;
+		} else {
+			if (firstLineContent) content = firstLineContent;
+			for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
+				const lineStart = state.bMarks[nextLine] + state.tShift[nextLine];
+				const lineEnd = state.eMarks[nextLine];
+				const currentLine = state.src.slice(lineStart - 1, lineEnd);
+				if (currentLine.trim() === closeDelim) {
+					found = true;
+					break;
+				} else if (currentLine.includes(closeDelim)) {
+					found = true;
+					const endIndex = currentLine.indexOf(closeDelim);
+					content += (content ? "\n" : "") + currentLine.slice(0, endIndex);
+					break;
+				}
+				content += (content ? "\n" : "") + currentLine;
+			}
+		}
+		const token = state.push("math_block", "math", 0);
+		token.content = normalizeStandaloneBackslashT(content);
+		token.markup = openDelim === "$$" ? "$$" : openDelim === "[" ? "[]" : "\\[\\]";
+		token.raw = `${openDelim}${content}${content.startsWith("\n") ? "\n" : ""}${closeDelim}`;
+		token.map = [startLine, nextLine + 1];
+		token.block = true;
+		token.loading = !found;
+		state.line = nextLine + 1;
+		return true;
+	};
+	md.inline.ruler.before("escape", "math", mathInline);
+	md.block.ruler.before("paragraph", "math_block", mathBlock, { alt: [
+		"paragraph",
+		"reference",
+		"blockquote",
+		"list"
+	] });
 }
-function ae(e) {
-  const c = [], i = [];
-  for (const o of e.split(/\r?\n/)) {
-    const n = o;
-    /^(?:diff |index |--- |\+\+\+ |@@ )/.test(n) || (n.startsWith("- ") ? c.push(` ${n.slice(1)}`) : n.startsWith("+ ") ? i.push(` ${n.slice(1)}`) : (c.push(n), i.push(n)));
-  }
-  return {
-    original: c.join(`
-`),
-    updated: i.join(`
-`)
-  };
+
+//#endregion
+//#region src/renderers/index.ts
+function applyRenderRules(md) {
+	const defaultImage = md.renderer.rules.image || function(tokens, idx, options, env, self) {
+		return self.renderToken(tokens, idx, options);
+	};
+	md.renderer.rules.image = (tokens, idx, options, env, self) => {
+		tokens[idx].attrSet?.("loading", "lazy");
+		return defaultImage(tokens, idx, options, env, self);
+	};
+	md.renderer.rules.fence = md.renderer.rules.fence || ((tokens, idx) => {
+		const token = tokens[idx];
+		const info = token.info ? token.info.trim() : "";
+		return `<pre class="${info ? `language-${md.utils.escapeHtml(info.split(/\s+/g)[0])}` : ""}"><code>${md.utils.escapeHtml(token.content)}</code></pre>`;
+	});
 }
-function N(e) {
-  const c = Array.isArray(e.map) && e.map.length === 2, i = e.meta, o = typeof i?.closed == "boolean" ? i.closed : void 0, n = e.info?.startsWith("diff") || !1, r = n ? e.info?.split(" ")[1] || "" : e.info || "";
-  let l = e.content || "";
-  const t = /\r?\n[ \t]*`+\s*$/;
-  if (t.test(l) && (l = l.replace(t, "")), n) {
-    const { original: s, updated: a } = ae(l);
-    return {
-      type: "code_block",
-      language: r,
-      code: a || "",
-      raw: l,
-      diff: n,
-      loading: o === !0 ? !1 : o === !1 ? !0 : !c,
-      originalCode: s,
-      updatedCode: a
-    };
-  }
-  return {
-    type: "code_block",
-    language: r,
-    code: l || "",
-    raw: l || "",
-    diff: n,
-    loading: o === !0 ? !1 : o === !1 ? !0 : !c
-  };
+
+//#endregion
+//#region src/factory.ts
+function factory(opts = {}) {
+	const md = new MarkdownIt({
+		html: true,
+		linkify: true,
+		typographer: true,
+		...opts.markdownItOptions ?? {}
+	});
+	if (opts.enableMath ?? true) applyMath(md, {
+		...getDefaultMathOptions() ?? {},
+		...opts.mathOptions ?? {}
+	});
+	if (opts.enableContainers ?? true) applyContainers(md);
+	applyRenderRules(md);
+	return md;
 }
-function pe(e) {
-  if (e.length < 5)
-    return e;
-  const c = e[e.length - 5];
-  if (c.type !== "text" && !c.content.endsWith("[") || e[e.length - 4].tag !== "em")
-    return S(e);
-  const o = e[e.length - 1];
-  if (!o.content.startsWith("]"))
-    return S(e);
-  const n = e[e.length - 3], r = o.content.replace(/^\]\(*/, ""), l = !o.content.includes(")");
-  return c.content = c.content.replace(/\[$/, ""), e.splice(e.length - 3, 1, {
-    type: "link",
-    href: r,
-    text: n.content,
-    children: [
-      {
-        type: "text",
-        content: n.content,
-        raw: n.content
-      }
-    ],
-    loading: l
-  }), e.splice(e.length - 1, 1), e;
+
+//#endregion
+//#region src/parser/fixTableTokens.ts
+function createStart() {
+	return [
+		{
+			type: "table_open",
+			tag: "table",
+			attrs: null,
+			map: null,
+			children: null,
+			content: "",
+			markup: "",
+			info: "",
+			level: 0,
+			loading: true,
+			meta: null
+		},
+		{
+			type: "thead_open",
+			tag: "thead",
+			attrs: null,
+			block: true,
+			level: 1,
+			children: null
+		},
+		{
+			type: "tr_open",
+			tag: "tr",
+			attrs: null,
+			block: true,
+			level: 2,
+			children: null
+		}
+	];
 }
-function S(e) {
-  if (e.length < 8)
-    return e;
-  let c = e.length, i = e[c - 1];
-  if (i.type !== "link_close" && (c--, i = e[c - 1], i.type !== "link_close") || e[c - 7].type !== "em_open")
-    return e;
-  const n = e[c - 6], r = e[c - 8];
-  let l = e[c - 2].content, t = 4;
-  c !== e.length && (l += i.content || "", t++), e.splice(c - 4, t);
-  const s = n.content;
-  return c -= 4, r.content = r.content.replace(/\[$/, ""), e.splice(c - 2, 1, {
-    type: "link",
-    href: l,
-    text: s,
-    children: [
-      {
-        type: "text",
-        content: s,
-        raw: s
-      }
-    ],
-    loading: !0
-  }), e;
+function createEnd() {
+	return [
+		{
+			type: "tr_close",
+			tag: "tr",
+			attrs: null,
+			block: true,
+			level: 2,
+			children: null
+		},
+		{
+			type: "thead_close",
+			tag: "thead",
+			attrs: null,
+			block: true,
+			level: 1,
+			children: null
+		},
+		{
+			type: "table_close",
+			tag: "table",
+			attrs: null,
+			map: null,
+			children: null,
+			content: "",
+			markup: "",
+			info: "",
+			level: 0,
+			meta: null
+		}
+	];
 }
-function ue(e) {
-  const c = e[e.length - 1];
-  return /\d+\.\s*$/.test(c.content || "") && e[e.length - 2]?.tag === "br" && e.splice(e.length - 1, 1), e;
+function createTh(text) {
+	return [
+		{
+			type: "th_open",
+			tag: "th",
+			attrs: null,
+			block: true,
+			level: 3,
+			children: null
+		},
+		{
+			type: "inline",
+			tag: "",
+			children: [{
+				tag: "",
+				type: "text",
+				block: false,
+				content: text,
+				children: null
+			}],
+			content: text,
+			level: 4,
+			attrs: null,
+			block: true
+		},
+		{
+			type: "th_close",
+			tag: "th",
+			attrs: null,
+			block: true,
+			level: 3,
+			children: null
+		}
+	];
 }
-function he(e) {
-  const c = [...e];
-  if (e.length < 4)
-    return c;
-  const i = e.length - 4, o = e[i], n = e[i + 1];
-  if (o.type === "text" && o.content?.endsWith("*") && n.type === "em_open") {
-    const r = e[i + 2], l = r?.type === "text" ? 4 : 3, t = [
-      {
-        type: "strong_open",
-        tag: "strong",
-        attrs: null,
-        map: null,
-        children: null,
-        content: "",
-        markup: "**",
-        info: "",
-        meta: null
-      },
-      {
-        type: "text",
-        content: r?.type === "text" ? r.content : ""
-      },
-      {
-        type: "strong_close",
-        tag: "strong",
-        attrs: null,
-        map: null,
-        children: null,
-        content: "",
-        markup: "**",
-        info: "",
-        meta: null
-      }
-    ], s = o.content?.slice(0, -1);
-    return s && t.unshift({
-      type: "text",
-      content: s,
-      raw: s
-    }), c.splice(i, l, ...t), c;
-  }
-  return c;
+function fixTableTokens(tokens) {
+	const fixedTokens = [...tokens];
+	if (tokens.length < 3) return fixedTokens;
+	const i = tokens.length - 2;
+	const token = tokens[i];
+	if (token.type === "inline") {
+		if (/^\|(?:[^|\n]+\|?)+/.test(token.content)) {
+			const body = token.children[0].content.slice(1).split("|").map((i$1) => i$1.trim()).filter(Boolean).flatMap((i$1) => createTh(i$1));
+			const insert = [
+				...createStart(),
+				...body,
+				...createEnd()
+			];
+			fixedTokens.splice(i - 1, 3, ...insert);
+		} else if (/^\|(?:[^|\n]+\|)+\n\|:?-/.test(token.content)) {
+			const body = token.children[0].content.slice(1, -1).split("|").map((i$1) => i$1.trim()).flatMap((i$1) => createTh(i$1));
+			const insert = [
+				...createStart(),
+				...body,
+				...createEnd()
+			];
+			fixedTokens.splice(i - 1, 3, ...insert);
+		} else if (/^\|(?:[^|\n:]+\|)+\n\|:?$/.test(token.content)) {
+			token.content = token.content.slice(0, -2);
+			token.children.splice(2, 1);
+		}
+	}
+	return fixedTokens;
 }
-function de(e) {
-  return {
-    type: "footnote_reference",
-    id: e.meta?.label || "",
-    raw: `[^${e.meta?.label || ""}]`
-  };
+
+//#endregion
+//#region src/parser/inline-parsers/checkbox-parser.ts
+function parseCheckboxToken(token) {
+	return {
+		type: "checkbox",
+		checked: token.meta?.checked === true,
+		raw: token.meta?.checked ? "[x]" : "[ ]"
+	};
 }
-function fe() {
-  return {
-    type: "hardbreak",
-    raw: `\\
-`
-  };
+function parseCheckboxInputToken(token) {
+	return {
+		type: "checkbox_input",
+		checked: token.attrGet("checked") === "" || token.attrGet("checked") === "true",
+		raw: token.attrGet("checked") === "" || token.attrGet("checked") === "true" ? "[x]" : "[ ]"
+	};
 }
-function ge(e, c) {
-  const i = [];
-  let o = "", n = c + 1;
-  const r = [];
-  for (; n < e.length && e[n].type !== "mark_close"; )
-    o += e[n].content || "", r.push(e[n]), n++;
-  i.push(...b(r));
-  const l = {
-    type: "highlight",
-    children: i,
-    raw: `==${o}==`
-  }, t = n < e.length ? n + 1 : e.length;
-  return { node: l, nextIndex: t };
+
+//#endregion
+//#region src/parser/inline-parsers/emoji-parser.ts
+function parseEmojiToken(token) {
+	return {
+		type: "emoji",
+		name: token.content || "",
+		markup: token.markup || "",
+		raw: `:${token.content || ""}:`
+	};
 }
-function P(e, c = !1) {
-  return {
-    type: "image",
-    src: e.attrs?.find((i) => i[0] === "src")?.[1] || "",
-    alt: e.attrs?.find((i) => i[0] === "alt")?.[1] || "",
-    title: e.attrs?.find((i) => i[0] === "title")?.[1] || null,
-    raw: e.content || "",
-    loading: c
-  };
+
+//#endregion
+//#region src/parser/inline-parsers/emphasis-parser.ts
+function parseEmphasisToken(tokens, startIndex) {
+	const children = [];
+	let emText = "";
+	let i = startIndex + 1;
+	const innerTokens = [];
+	while (i < tokens.length && tokens[i].type !== "em_close") {
+		emText += tokens[i].content || "";
+		innerTokens.push(tokens[i]);
+		i++;
+	}
+	children.push(...parseInlineTokens(innerTokens));
+	return {
+		node: {
+			type: "emphasis",
+			children,
+			raw: `*${emText}*`
+		},
+		nextIndex: i < tokens.length ? i + 1 : tokens.length
+	};
 }
-function me(e) {
-  return {
-    type: "inline_code",
-    code: e.content || "",
-    raw: e.content || ""
-  };
+
+//#endregion
+//#region src/parser/inline-parsers/fence-parser.ts
+function splitUnifiedDiff(content) {
+	const orig = [];
+	const updated = [];
+	for (const rawLine of content.split(/\r?\n/)) {
+		const line = rawLine;
+		if (/^(?:diff |index |--- |\+\+\+ |@@ )/.test(line)) continue;
+		if (line.startsWith("- ")) orig.push(` ${line.slice(1)}`);
+		else if (line.startsWith("+ ")) updated.push(` ${line.slice(1)}`);
+		else {
+			orig.push(line);
+			updated.push(line);
+		}
+	}
+	return {
+		original: orig.join("\n"),
+		updated: updated.join("\n")
+	};
 }
-function _e(e, c) {
-  const i = [];
-  let o = "", n = c + 1;
-  const r = [];
-  for (; n < e.length && e[n].type !== "ins_close"; )
-    o += e[n].content || "", r.push(e[n]), n++;
-  i.push(...b(r));
-  const l = {
-    type: "insert",
-    children: i,
-    raw: `++${o}++`
-  }, t = n < e.length ? n + 1 : e.length;
-  return { node: l, nextIndex: t };
+function parseFenceToken(token) {
+	const hasMap = Array.isArray(token.map) && token.map.length === 2;
+	const meta = token.meta;
+	const closed = typeof meta?.closed === "boolean" ? meta.closed : void 0;
+	const diff = token.info?.startsWith("diff") || false;
+	const language = diff ? token.info?.split(" ")[1] || "" : token.info || "";
+	let content = token.content || "";
+	const trailingFenceLine = /\r?\n[ \t]*`+\s*$/;
+	if (trailingFenceLine.test(content)) content = content.replace(trailingFenceLine, "");
+	if (diff) {
+		const { original, updated } = splitUnifiedDiff(content);
+		return {
+			type: "code_block",
+			language,
+			code: updated || "",
+			raw: content,
+			diff,
+			loading: closed === true ? false : closed === false ? true : !hasMap,
+			originalCode: original,
+			updatedCode: updated
+		};
+	}
+	return {
+		type: "code_block",
+		language,
+		code: content || "",
+		raw: content || "",
+		diff,
+		loading: closed === true ? false : closed === false ? true : !hasMap
+	};
 }
-function ye(e, c) {
-  const i = e[c], o = i.attrs?.find((u) => u[0] === "href")?.[1] || "", n = i.attrs?.find((u) => u[0] === "title")?.[1] || null;
-  let r = c + 1;
-  const l = [], t = !0;
-  for (; r < e.length && e[r].type !== "link_close"; )
-    l.push(e[r]), r++;
-  const s = b(l), a = s.map((u) => "content" in u ? u.content : u.raw).join(""), d = {
-    type: "link",
-    href: o,
-    title: n,
-    text: a,
-    children: s,
-    raw: `[${a}](${o}${n ? ` "${n}"` : ""})`,
-    loading: t
-  }, p = r < e.length ? r + 1 : e.length;
-  return { node: d, nextIndex: p };
+
+//#endregion
+//#region src/parser/inline-parsers/fixLinkToken.ts
+function fixLinkToken(tokens) {
+	if (tokens.length < 5) return tokens;
+	const first = tokens[tokens.length - 5];
+	if (first.type !== "text" && !first.content.endsWith("[")) return fixLinkTokens2(tokens);
+	if (tokens[tokens.length - 4].tag !== "em") return fixLinkTokens2(tokens);
+	const last = tokens[tokens.length - 1];
+	if (!last.content.startsWith("]")) return fixLinkTokens2(tokens);
+	const third = tokens[tokens.length - 3];
+	const href = last.content.replace(/^\]\(*/, "");
+	const loading = !last.content.includes(")");
+	first.content = first.content.replace(/\[$/, "");
+	tokens.splice(tokens.length - 3, 1, {
+		type: "link",
+		href,
+		text: third.content,
+		children: [{
+			type: "text",
+			content: third.content,
+			raw: third.content
+		}],
+		loading
+	});
+	tokens.splice(tokens.length - 1, 1);
+	return tokens;
 }
-function be(e) {
-  return {
-    type: "math_inline",
-    content: e.content || "",
-    loading: !!e.loading,
-    raw: e.raw
-  };
+function fixLinkTokens2(tokens) {
+	if (tokens.length < 8) return tokens;
+	let length = tokens.length;
+	let last = tokens[length - 1];
+	if (last.type !== "link_close") {
+		length--;
+		last = tokens[length - 1];
+		if (last.type !== "link_close") return tokens;
+	}
+	if (tokens[length - 7].type !== "em_open") return tokens;
+	const third = tokens[length - 6];
+	const first = tokens[length - 8];
+	let href = tokens[length - 2].content;
+	let count = 4;
+	if (length !== tokens.length) {
+		href += last.content || "";
+		count++;
+	}
+	tokens.splice(length - 4, count);
+	const content = third.content;
+	length -= 4;
+	first.content = first.content.replace(/\[$/, "");
+	tokens.splice(length - 2, 1, {
+		type: "link",
+		href,
+		text: content,
+		children: [{
+			type: "text",
+			content,
+			raw: content
+		}],
+		loading: true
+	});
+	return tokens;
 }
-function we(e) {
-  return {
-    type: "reference",
-    id: e.content || "",
-    raw: e.markup || `[${e.content}]`
-  };
+
+//#endregion
+//#region src/parser/inline-parsers/fixListItem.ts
+function fixListItem(tokens) {
+	const last = tokens[tokens.length - 1];
+	if (/\d+\.\s*$/.test(last.content || "") && tokens[tokens.length - 2]?.tag === "br") tokens.splice(tokens.length - 1, 1);
+	return tokens;
 }
-function B(e, c) {
-  const i = [];
-  let o = "", n = c + 1;
-  const r = [];
-  for (; n < e.length && e[n].type !== "s_close"; )
-    o += e[n].content || "", r.push(e[n]), n++;
-  i.push(...b(r));
-  const l = {
-    type: "strikethrough",
-    children: i,
-    raw: `~~${o}~~`
-  }, t = n < e.length ? n + 1 : e.length;
-  return { node: l, nextIndex: t };
+
+//#endregion
+//#region src/parser/inline-parsers/fixStrongTokens.ts
+function fixStrongTokens(tokens) {
+	const fixedTokens = [...tokens];
+	if (tokens.length < 4) return fixedTokens;
+	const i = tokens.length - 4;
+	const token = tokens[i];
+	const nextToken = tokens[i + 1];
+	if (token.type === "text" && token.content?.endsWith("*") && nextToken.type === "em_open") {
+		const _nextToken = tokens[i + 2];
+		const count = _nextToken?.type === "text" ? 4 : 3;
+		const insert = [
+			{
+				type: "strong_open",
+				tag: "strong",
+				attrs: null,
+				map: null,
+				children: null,
+				content: "",
+				markup: "**",
+				info: "",
+				meta: null
+			},
+			{
+				type: "text",
+				content: _nextToken?.type === "text" ? _nextToken.content : ""
+			},
+			{
+				type: "strong_close",
+				tag: "strong",
+				attrs: null,
+				map: null,
+				children: null,
+				content: "",
+				markup: "**",
+				info: "",
+				meta: null
+			}
+		];
+		const beforeText = token.content?.slice(0, -1);
+		if (beforeText) insert.unshift({
+			type: "text",
+			content: beforeText,
+			raw: beforeText
+		});
+		fixedTokens.splice(i, count, ...insert);
+		return fixedTokens;
+	}
+	return fixedTokens;
 }
-function W(e, c, i) {
-  const o = [];
-  let n = "", r = c + 1;
-  const l = [];
-  for (; r < e.length && e[r].type !== "strong_close"; )
-    n += e[r].content || "", l.push(e[r]), r++;
-  o.push(...b(l, i));
-  const t = {
-    type: "strong",
-    children: o,
-    raw: `**${n}**`
-  }, s = r < e.length ? r + 1 : e.length;
-  return { node: t, nextIndex: s };
+
+//#endregion
+//#region src/parser/inline-parsers/footnote-ref-parser.ts
+function parseFootnoteRefToken(token) {
+	return {
+		type: "footnote_reference",
+		id: token.meta?.label || "",
+		raw: `[^${token.meta?.label || ""}]`
+	};
 }
-function xe(e, c) {
-  const i = [];
-  let o = "", n = c + 1;
-  const r = [];
-  for (; n < e.length && e[n].type !== "sub_close"; )
-    o += e[n].content || "", r.push(e[n]), n++;
-  i.push(...b(r));
-  const l = {
-    type: "subscript",
-    children: i.length > 0 ? i : [
-      {
-        type: "text",
-        // Fallback to the collected inner text (e.g., "2" in H~2~O)
-        content: o || e[c].content || "",
-        raw: o || e[c].content || ""
-      }
-    ],
-    raw: `~${o || e[c].content || ""}~`
-  }, t = n < e.length ? n + 1 : e.length;
-  return { node: l, nextIndex: t };
+
+//#endregion
+//#region src/parser/inline-parsers/hardbreak-parser.ts
+function parseHardbreakToken() {
+	return {
+		type: "hardbreak",
+		raw: "\\\n"
+	};
 }
-function $e(e, c) {
-  const i = [];
-  let o = "", n = c + 1;
-  const r = [];
-  for (; n < e.length && e[n].type !== "sup_close"; )
-    o += e[n].content || "", r.push(e[n]), n++;
-  i.push(...b(r));
-  const l = {
-    type: "superscript",
-    children: i.length > 0 ? i : [
-      {
-        type: "text",
-        // Fallback to the collected inner text (e.g., "2" in x^2^)
-        content: o || e[c].content || "",
-        raw: o || e[c].content || ""
-      }
-    ],
-    raw: `^${o || e[c].content || ""}^`
-  }, t = n < e.length ? n + 1 : e.length;
-  return { node: l, nextIndex: t };
+
+//#endregion
+//#region src/parser/inline-parsers/highlight-parser.ts
+function parseHighlightToken(tokens, startIndex) {
+	const children = [];
+	let markText = "";
+	let i = startIndex + 1;
+	const innerTokens = [];
+	while (i < tokens.length && tokens[i].type !== "mark_close") {
+		markText += tokens[i].content || "";
+		innerTokens.push(tokens[i]);
+		i++;
+	}
+	children.push(...parseInlineTokens(innerTokens));
+	return {
+		node: {
+			type: "highlight",
+			children,
+			raw: `==${markText}==`
+		},
+		nextIndex: i < tokens.length ? i + 1 : tokens.length
+	};
 }
-function Te(e) {
-  return {
-    type: "text",
-    content: e.content || "",
-    raw: e.content || ""
-  };
+
+//#endregion
+//#region src/parser/inline-parsers/image-parser.ts
+function parseImageToken(token, loading = false) {
+	return {
+		type: "image",
+		src: token.attrs?.find((attr) => attr[0] === "src")?.[1] || "",
+		alt: token.attrs?.find((attr) => attr[0] === "alt")?.[1] || "",
+		title: token.attrs?.find((attr) => attr[0] === "title")?.[1] || null,
+		raw: token.content || "",
+		loading
+	};
 }
-function b(e, c, i) {
-  if (!e || e.length === 0)
-    return [];
-  const o = [];
-  let n = null, r = 0;
-  for (e = he(e), e = ue(e), e = pe(e); r < e.length; ) {
-    const l = e[r];
-    switch (l.type) {
-      case "text": {
-        let t = l.content.replace(/\\/g, "") || "";
-        if (t === "`" || t === "|" || t === "$" || t === "1" || /^\*+$/.test(t) || /^\d$/.test(t)) {
-          r++;
-          break;
-        }
-        if (/[^\]]\s*\(\s*$/.test(t) && (t = t.replace(/\(\s*$/, "")), c?.startsWith("[") && i?.type === "list_item_open") {
-          const f = t.slice(1).match(/[^\s\]]/);
-          if (f === null) {
-            r++;
-            break;
-          }
-          if (f && /x/i.test(f[0]) || !f) {
-            const h = f ? f[0] === "x" || f[0] === "X" : !1;
-            o.push({
-              type: "checkbox_input",
-              checked: h,
-              raw: h ? "[x]" : "[ ]"
-            }), r++;
-            break;
-          }
-        }
-        if (/`[^`]*/.test(t)) {
-          n = null, o.push({
-            type: "inline_code",
-            code: t.replace(/`/g, ""),
-            raw: t || ""
-          }), r++;
-          break;
-        }
-        if (t === "[") {
-          r++;
-          break;
-        }
-        if (/[^~]*~{2,}[^~]+/.test(t)) {
-          const u = t.indexOf("~~") || 0, f = t.slice(0, u);
-          f && (n ? (n.content += f, n.raw += f) : (n = {
-            type: "text",
-            content: f || "",
-            raw: l.content || ""
-          }, o.push(n)));
-          const h = t.slice(u);
-          n = null;
-          const { node: g } = B([
-            {
-              type: "s_open",
-              tag: "s",
-              attrs: [],
-              map: void 0,
-              content: "",
-              markup: "*",
-              info: "",
-              meta: null
-            },
-            {
-              type: "text",
-              tag: "",
-              attrs: [],
-              map: void 0,
-              content: h.replace(/~/g, ""),
-              markup: "",
-              info: "",
-              meta: null
-            },
-            {
-              type: "s_close",
-              tag: "s",
-              attrs: [],
-              map: void 0,
-              content: "",
-              markup: "*",
-              info: "",
-              meta: null
-            }
-          ], 0);
-          o.push(g), r++;
-          break;
-        }
-        if (/[^*]*\*\*[^*]+/.test(t)) {
-          const u = t.indexOf("*") || 0, f = t.slice(0, u);
-          f && (n ? (n.content += f, n.raw += f) : (n = {
-            type: "text",
-            content: f || "",
-            raw: l.content || ""
-          }, o.push(n)));
-          const h = t.slice(u);
-          n = null;
-          const { node: g } = W([
-            {
-              type: "strong_open",
-              tag: "strong",
-              content: "",
-              markup: "*",
-              info: "",
-              meta: null
-            },
-            {
-              type: "text",
-              tag: "",
-              content: h.replace(/\*/g, ""),
-              markup: "",
-              info: "",
-              meta: null
-            },
-            {
-              type: "strong_close",
-              tag: "strong",
-              content: "",
-              markup: "*",
-              info: "",
-              meta: null
-            }
-          ], 0, c);
-          o.push(g), r++;
-          break;
-        } else if (/[^*]*\*[^*]+/.test(t)) {
-          const u = t.indexOf("*") || 0, f = t.slice(0, u);
-          f && (n ? (n.content += f, n.raw += f) : (n = {
-            type: "text",
-            content: f || "",
-            raw: l.content || ""
-          }, o.push(n)));
-          const h = t.slice(u);
-          n = null;
-          const { node: g } = D([
-            {
-              type: "em_open",
-              tag: "em",
-              content: "",
-              markup: "*",
-              info: "",
-              meta: null
-            },
-            {
-              type: "text",
-              tag: "",
-              content: h.replace(/\*/g, ""),
-              markup: "",
-              info: "",
-              meta: null
-            },
-            {
-              type: "em_close",
-              tag: "em",
-              content: "",
-              markup: "*",
-              info: "",
-              meta: null
-            }
-          ], 0);
-          o.push(g), r++;
-          break;
-        }
-        const s = t.indexOf("![");
-        if (s !== -1) {
-          const u = t.slice(0, s);
-          n ? n.content += u : n = {
-            type: "text",
-            content: u,
-            raw: u
-          }, o.push(n), n = null, o.push(P(l, !0)), r++;
-          break;
-        }
-        const a = t.indexOf("[");
-        t.endsWith("undefined") && !c?.endsWith("undefined") && (t = t.slice(0, -9));
-        const d = Te({ ...l, content: t });
-        if (a !== -1) {
-          const u = t.slice(0, a), f = t.indexOf("](", a);
-          if (f !== -1) {
-            o.push({
-              type: "text",
-              content: u,
-              raw: u
-            });
-            const h = t.slice(a + 1, f);
-            o.push({
-              type: "link",
-              href: "",
-              text: h,
-              children: [
-                {
-                  type: "text",
-                  content: h,
-                  raw: h
-                }
-              ],
-              loading: !0
-            }), r++;
-            break;
-          }
-        }
-        const p = e[r - 1];
-        if (n)
-          n.content += d.content.replace(/(\*+|\(|\\)$/, ""), n.raw += d.raw;
-        else {
-          const u = p?.tag === "br" && e[r - 2]?.content === "[";
-          d.content = d.content.replace(/(\*+|\(|\\)$/, ""), n = d, n.center = u, o.push(n);
-        }
-        r++;
-        break;
-      }
-      case "softbreak":
-        n && (n.content += `
-`, n.raw += `
-`), r++;
-        break;
-      case "code_inline":
-        n = null, o.push(me(l)), r++;
-        break;
-      case "link_open": {
-        n = null;
-        const t = l.attrs?.find((d) => d[0] === "href")?.[1];
-        if (c && t) {
-          const d = new RegExp(`\\(\\s*${t}\\s*\\)`), p = o.length > 0 ? o[o.length - 1] : null, u = !d.test(c);
-          if (u && p && new RegExp(`\\[${p.text}\\s*\\]\\(`).test(c)) {
-            const h = p?.text || p?.content?.slice(1, -1) || "";
-            o.splice(o.length - 1, 1, {
-              type: "link",
-              href: "",
-              text: h,
-              loading: u
-            }), r += 3, e[r]?.content === "." && r++;
-            break;
-          }
-        }
-        const { node: s, nextIndex: a } = ye(e, r);
-        r = a, s.loading = !1, o.push(s);
-        break;
-      }
-      case "image":
-        n = null, o.push(P(l)), r++;
-        break;
-      case "strong_open": {
-        n = null;
-        const { node: t, nextIndex: s } = W(e, r, l.content);
-        o.push(t), r = s;
-        break;
-      }
-      case "em_open": {
-        n = null;
-        const { node: t, nextIndex: s } = D(e, r);
-        o.push(t), r = s;
-        break;
-      }
-      case "s_open": {
-        n = null;
-        const { node: t, nextIndex: s } = B(e, r);
-        o.push(t), r = s;
-        break;
-      }
-      case "mark_open": {
-        n = null;
-        const { node: t, nextIndex: s } = ge(e, r);
-        o.push(t), r = s;
-        break;
-      }
-      case "ins_open": {
-        n = null;
-        const { node: t, nextIndex: s } = _e(e, r);
-        o.push(t), r = s;
-        break;
-      }
-      case "sub_open": {
-        n = null;
-        const { node: t, nextIndex: s } = xe(e, r);
-        o.push(t), r = s;
-        break;
-      }
-      case "sup_open": {
-        n = null;
-        const { node: t, nextIndex: s } = $e(e, r);
-        o.push(t), r = s;
-        break;
-      }
-      case "sub":
-        n = null, o.push({
-          type: "subscript",
-          children: [
-            {
-              type: "text",
-              content: l.content || "",
-              raw: l.content || ""
-            }
-          ],
-          raw: `~${l.content || ""}~`
-        }), r++;
-        break;
-      case "sup":
-        n = null, o.push({
-          type: "superscript",
-          children: [
-            {
-              type: "text",
-              content: l.content || "",
-              raw: l.content || ""
-            }
-          ],
-          raw: `^${l.content || ""}^`
-        }), r++;
-        break;
-      case "emoji": {
-        n = null;
-        const t = e[r - 1];
-        t?.type === "text" && /\|:-+/.test(t.content || "") ? o.push({
-          type: "text",
-          content: "",
-          raw: ""
-        }) : o.push(se(l)), r++;
-        break;
-      }
-      case "checkbox":
-        n = null, o.push(ie(l)), r++;
-        break;
-      case "checkbox_input":
-        n = null, o.push(le(l)), r++;
-        break;
-      case "footnote_ref":
-        n = null, o.push(de(l)), r++;
-        break;
-      case "hardbreak":
-        n = null, o.push(fe()), r++;
-        break;
-      case "fence": {
-        n = null, o.push(N(e[r])), r++;
-        break;
-      }
-      case "math_inline": {
-        n = null, o.push(be(l)), r++;
-        break;
-      }
-      case "reference": {
-        n = null, o.push(we(l)), r++;
-        break;
-      }
-      default:
-        o.push(l), n = null, r++;
-        break;
-    }
-  }
-  return o;
+
+//#endregion
+//#region src/parser/inline-parsers/inline-code-parser.ts
+function parseInlineCodeToken(token) {
+	return {
+		type: "inline_code",
+		code: token.content || "",
+		raw: token.content || ""
+	};
 }
-function Z(e, c) {
-  const i = [];
-  let o = c + 1;
-  for (; o < e.length && e[o].type !== "blockquote_close"; )
-    if (e[o].type === "paragraph_open") {
-      const r = e[o + 1];
-      i.push({
-        type: "paragraph",
-        children: b(r.children || []),
-        raw: r.content || ""
-      }), o += 3;
-    } else if (e[o].type === "bullet_list_open" || e[o].type === "ordered_list_open") {
-      const [r, l] = E(e, o);
-      i.push(r), o = l;
-    } else
-      o++;
-  return [{
-    type: "blockquote",
-    children: i,
-    raw: i.map((r) => r.raw).join(`
-`)
-  }, o + 1];
+
+//#endregion
+//#region src/parser/inline-parsers/insert-parser.ts
+function parseInsertToken(tokens, startIndex) {
+	const children = [];
+	let insText = "";
+	let i = startIndex + 1;
+	const innerTokens = [];
+	while (i < tokens.length && tokens[i].type !== "ins_close") {
+		insText += tokens[i].content || "";
+		innerTokens.push(tokens[i]);
+		i++;
+	}
+	children.push(...parseInlineTokens(innerTokens));
+	return {
+		node: {
+			type: "insert",
+			children,
+			raw: `++${insText}++`
+		},
+		nextIndex: i < tokens.length ? i + 1 : tokens.length
+	};
 }
-function A(e) {
-  if (e.info?.startsWith("diff"))
-    return N(e);
-  const c = e.content?.match(/ type="application\/vnd\.ant\.([^"]+)"/);
-  c?.[1] && (e.content = e.content.replace(/<antArtifact[^>]*>/g, "").replace(/<\/antArtifact>/g, ""));
-  const i = Array.isArray(e.map) && e.map.length === 2;
-  return {
-    type: "code_block",
-    language: c ? c[1] : e.info || "",
-    code: e.content || "",
-    raw: e.content || "",
-    loading: !i
-  };
+
+//#endregion
+//#region src/parser/inline-parsers/link-parser.ts
+function parseLinkToken(tokens, startIndex) {
+	const openToken = tokens[startIndex];
+	const href = openToken.attrs?.find((attr) => attr[0] === "href")?.[1] || "";
+	const title = openToken.attrs?.find((attr) => attr[0] === "title")?.[1] || null;
+	let i = startIndex + 1;
+	const linkTokens = [];
+	const loading = true;
+	while (i < tokens.length && tokens[i].type !== "link_close") {
+		linkTokens.push(tokens[i]);
+		i++;
+	}
+	const children = parseInlineTokens(linkTokens);
+	const linkText = children.map((node) => {
+		if ("content" in node) return node.content;
+		return node.raw;
+	}).join("");
+	return {
+		node: {
+			type: "link",
+			href,
+			title,
+			text: linkText,
+			children,
+			raw: `[${linkText}](${href}${title ? ` "${title}"` : ""})`,
+			loading
+		},
+		nextIndex: i < tokens.length ? i + 1 : tokens.length
+	};
 }
-function U(e, c) {
-  const i = [];
-  let o = c + 1, n = [], r = [];
-  for (; o < e.length && e[o].type !== "dl_close"; )
-    if (e[o].type === "dt_open") {
-      const t = e[o + 1];
-      n = b(t.children || []), o += 3;
-    } else if (e[o].type === "dd_open") {
-      let t = o + 1;
-      for (r = []; t < e.length && e[t].type !== "dd_close"; )
-        if (e[t].type === "paragraph_open") {
-          const s = e[t + 1];
-          r.push({
-            type: "paragraph",
-            children: b(s.children || [], s.content || ""),
-            raw: s.content || ""
-          }), t += 3;
-        } else
-          t++;
-      n.length > 0 && (i.push({
-        type: "definition_item",
-        term: n,
-        definition: r,
-        raw: `${n.map((s) => s.raw).join("")}: ${r.map((s) => s.raw).join(`
-`)}`
-      }), n = []), o = t + 1;
-    } else
-      o++;
-  return [{
-    type: "definition_list",
-    items: i,
-    raw: i.map((t) => t.raw).join(`
-`)
-  }, o + 1];
+
+//#endregion
+//#region src/parser/inline-parsers/math-inline-parser.ts
+function parseMathInlineToken(token) {
+	return {
+		type: "math_inline",
+		content: token.content || "",
+		loading: !!token.loading,
+		raw: token.raw
+	};
 }
-function G(e, c) {
-  const o = e[c].meta?.label ?? 0, n = [];
-  let r = c + 1;
-  for (; r < e.length && e[r].type !== "footnote_close"; )
-    if (e[r].type === "paragraph_open") {
-      const t = e[r + 1];
-      n.push({
-        type: "paragraph",
-        children: b(t.children || []),
-        raw: t.content || ""
-      }), r += 3;
-    } else
-      r++;
-  return [{
-    type: "footnote",
-    id: o,
-    children: n,
-    raw: `[^${o}]: ${n.map((t) => t.raw).join(`
-`)}`
-  }, r + 1];
+
+//#endregion
+//#region src/parser/inline-parsers/reference-parser.ts
+function parseReferenceToken(token) {
+	return {
+		type: "reference",
+		id: token.content || "",
+		raw: token.markup || `[${token.content}]`
+	};
 }
-function z(e, c) {
-  const i = e[c], o = Number.parseInt(i.tag?.substring(1) || "1"), n = e[c + 1], r = n.content || "";
-  return {
-    type: "heading",
-    level: o,
-    text: r,
-    children: b(n.children || []),
-    raw: r
-  };
+
+//#endregion
+//#region src/parser/inline-parsers/strikethrough-parser.ts
+function parseStrikethroughToken(tokens, startIndex) {
+	const children = [];
+	let sText = "";
+	let i = startIndex + 1;
+	const innerTokens = [];
+	while (i < tokens.length && tokens[i].type !== "s_close") {
+		sText += tokens[i].content || "";
+		innerTokens.push(tokens[i]);
+		i++;
+	}
+	children.push(...parseInlineTokens(innerTokens));
+	return {
+		node: {
+			type: "strikethrough",
+			children,
+			raw: `~~${sText}~~`
+		},
+		nextIndex: i < tokens.length ? i + 1 : tokens.length
+	};
 }
-function j(e) {
-  return {
-    type: "math_block",
-    content: e.content || "",
-    loading: !!e.loading,
-    raw: e.raw || ""
-  };
+
+//#endregion
+//#region src/parser/inline-parsers/strong-parser.ts
+function parseStrongToken(tokens, startIndex, raw) {
+	const children = [];
+	let strongText = "";
+	let i = startIndex + 1;
+	const innerTokens = [];
+	while (i < tokens.length && tokens[i].type !== "strong_close") {
+		strongText += tokens[i].content || "";
+		innerTokens.push(tokens[i]);
+		i++;
+	}
+	children.push(...parseInlineTokens(innerTokens, raw));
+	return {
+		node: {
+			type: "strong",
+			children,
+			raw: `**${strongText}**`
+		},
+		nextIndex: i < tokens.length ? i + 1 : tokens.length
+	};
 }
-function K(e, c) {
-  let i = c + 1, o = null;
-  const n = [];
-  let r = !1;
-  for (; i < e.length && e[i].type !== "table_close"; )
-    if (e[i].type === "thead_open")
-      r = !0, i++;
-    else if (e[i].type === "thead_close")
-      r = !1, i++;
-    else if (e[i].type === "tbody_open" || e[i].type === "tbody_close")
-      i++;
-    else if (e[i].type === "tr_open") {
-      const t = [];
-      let s = i + 1;
-      for (; s < e.length && e[s].type !== "tr_close"; )
-        if (e[s].type === "th_open" || e[s].type === "td_open") {
-          const d = e[s].type === "th_open", p = e[s + 1], u = p.content || "";
-          t.push({
-            type: "table_cell",
-            header: d || r,
-            children: b(p.children || [], u),
-            raw: u
-          }), s += 3;
-        } else
-          s++;
-      const a = {
-        type: "table_row",
-        cells: t,
-        raw: t.map((d) => d.raw).join("|")
-      };
-      r ? o = a : n.push(a), i = s + 1;
-    } else
-      i++;
-  return o || (o = {
-    type: "table_row",
-    cells: [],
-    raw: ""
-  }), [{
-    type: "table",
-    header: o,
-    rows: n,
-    loading: e[c].loading || !1,
-    raw: [o, ...n].map((t) => t.raw).join(`
-`)
-  }, i + 1];
+
+//#endregion
+//#region src/parser/inline-parsers/subscript-parser.ts
+function parseSubscriptToken(tokens, startIndex) {
+	const children = [];
+	let subText = "";
+	let i = startIndex + 1;
+	const innerTokens = [];
+	while (i < tokens.length && tokens[i].type !== "sub_close") {
+		subText += tokens[i].content || "";
+		innerTokens.push(tokens[i]);
+		i++;
+	}
+	children.push(...parseInlineTokens(innerTokens));
+	return {
+		node: {
+			type: "subscript",
+			children: children.length > 0 ? children : [{
+				type: "text",
+				content: subText || tokens[startIndex].content || "",
+				raw: subText || tokens[startIndex].content || ""
+			}],
+			raw: `~${subText || tokens[startIndex].content || ""}~`
+		},
+		nextIndex: i < tokens.length ? i + 1 : tokens.length
+	};
 }
-function J() {
-  return {
-    type: "thematic_break",
-    raw: "---"
-  };
+
+//#endregion
+//#region src/parser/inline-parsers/superscript-parser.ts
+function parseSuperscriptToken(tokens, startIndex) {
+	const children = [];
+	let supText = "";
+	let i = startIndex + 1;
+	const innerTokens = [];
+	while (i < tokens.length && tokens[i].type !== "sup_close") {
+		supText += tokens[i].content || "";
+		innerTokens.push(tokens[i]);
+		i++;
+	}
+	children.push(...parseInlineTokens(innerTokens));
+	return {
+		node: {
+			type: "superscript",
+			children: children.length > 0 ? children : [{
+				type: "text",
+				content: supText || tokens[startIndex].content || "",
+				raw: supText || tokens[startIndex].content || ""
+			}],
+			raw: `^${supText || tokens[startIndex].content || ""}^`
+		},
+		nextIndex: i < tokens.length ? i + 1 : tokens.length
+	};
 }
-function E(e, c) {
-  const i = e[c], o = [];
-  let n = c + 1;
-  for (; n < e.length && e[n].type !== "bullet_list_close" && e[n].type !== "ordered_list_close"; )
-    if (e[n].type === "list_item_open") {
-      if (e[n].markup === "*") {
-        n++;
-        continue;
-      }
-      const l = [];
-      let t = n + 1;
-      for (; t < e.length && e[t].type !== "list_item_close"; )
-        if (e[t].type === "paragraph_open") {
-          const s = e[t + 1], a = e[t - 1], d = s && typeof s.content == "string" ? s.content : "";
-          /\n\d+$/.test(d) && (s && (s.content = d.replace(/\n\d+$/, "")), s?.children && s.children.splice(-1, 1)), l.push({
-            type: "paragraph",
-            children: b(s?.children || [], s?.content || "", a),
-            raw: s?.content || ""
-          }), t += 3;
-        } else if (e[t].type === "blockquote_open") {
-          const [s, a] = Z(e, t);
-          l.push(s), t = a;
-        } else if (e[t].type === "bullet_list_open" || e[t].type === "ordered_list_open") {
-          if (e[t].markup === "*") {
-            t++;
-            continue;
-          }
-          const [s, a] = Q(e, t);
-          l.push(s), t = a;
-        } else if (e[t].type === "code_block")
-          l.push(A(e[t])), t += 1;
-        else if (e[t].type === "fence")
-          l.push(N(e[t])), t += 1;
-        else if (e[t].type === "math_block")
-          l.push(j(e[t])), t += 1;
-        else if (e[t].type === "table_open") {
-          const [s, a] = K(e, t);
-          l.push(s), t = a;
-        } else if (e[t].type === "dl_open") {
-          const [s, a] = U(e, t);
-          l.push(s), t = a;
-        } else if (e[t].type === "footnote_open") {
-          const [s, a] = G(e, t);
-          l.push(s), t = a;
-        } else if (e[t].type === "heading_open") {
-          const s = z(e, t);
-          l.push(s), t += 3;
-        } else if (e[t].type === "hr")
-          l.push(J()), t += 1;
-        else if (e[t].type === "container_open") {
-          const s = /^::: ?(warning|info|note|tip|danger|caution) ?(.*)$/.exec(
-            e[t].info || ""
-          );
-          if (s) {
-            const [a, d] = V(e, t, s);
-            l.push(a), t = d;
-          } else
-            t += 1;
-        } else
-          t += 1;
-      o.push({
-        type: "list_item",
-        children: l,
-        raw: l.map((s) => s.raw).join("")
-      }), n = t + 1;
-    } else
-      n += 1;
-  return [{
-    type: "list",
-    ordered: i.type === "ordered_list_open",
-    // markdown-it may include attrs like [['start','2']] on ordered_list_open
-    start: (() => {
-      if (i.attrs && i.attrs.length) {
-        const l = i.attrs.find((t) => t[0] === "start");
-        if (l)
-          return Number(l[1]) || 1;
-      }
-    })(),
-    items: o,
-    raw: o.map((l) => l.raw).join(`
-`)
-  }, n + 1];
+
+//#endregion
+//#region src/parser/inline-parsers/text-parser.ts
+function parseTextToken(token) {
+	return {
+		type: "text",
+		content: token.content || "",
+		raw: token.content || ""
+	};
 }
-function Q(e, c) {
-  const i = e[c], o = [];
-  let n = c + 1;
-  for (; n < e.length && e[n].type !== "bullet_list_close" && e[n].type !== "ordered_list_close"; )
-    if (e[n].type === "list_item_open") {
-      if (e[n].markup === "*") {
-        n++;
-        continue;
-      }
-      const l = [];
-      let t = n + 1;
-      for (; t < e.length && e[t].type !== "list_item_close"; )
-        if (e[t].type === "paragraph_open") {
-          const s = e[t + 1], a = e[t - 1];
-          l.push({
-            type: "paragraph",
-            children: b(s.children || [], s.content || "", a),
-            raw: s.content || ""
-          }), t += 3;
-        } else if (e[t].type === "bullet_list_open" || e[t].type === "ordered_list_open") {
-          if (e[t].markup === "*") {
-            t++;
-            continue;
-          }
-          const [s, a] = Q(e, t);
-          l.push(s), t = a;
-        } else e[t].type === "code_block" ? (l.push(A(e[t])), t += 1) : e[t].type === "fence" ? (l.push(N(e[t])), t += 1) : (e[t].type === "math_block" && l.push(j(e[t])), t += 1);
-      o.push({
-        type: "list_item",
-        children: l,
-        raw: l.map((s) => s.raw).join("")
-      }), n = t + 1;
-    } else
-      n += 1;
-  return [{
-    type: "list",
-    ordered: i.type === "ordered_list_open",
-    start: (() => {
-      if (i.attrs && i.attrs.length) {
-        const l = i.attrs.find((t) => t[0] === "start");
-        if (l)
-          return Number(l[1]) || 1;
-      }
-    })(),
-    items: o,
-    raw: o.map((l) => l.raw).join(`
-`)
-  }, n + 1];
+
+//#endregion
+//#region src/parser/inline-parsers/index.ts
+function parseInlineTokens(tokens, raw, pPreToken) {
+	if (!tokens || tokens.length === 0) return [];
+	const result = [];
+	let currentTextNode = null;
+	let i = 0;
+	tokens = fixStrongTokens(tokens);
+	tokens = fixListItem(tokens);
+	tokens = fixLinkToken(tokens);
+	while (i < tokens.length) {
+		const token = tokens[i];
+		switch (token.type) {
+			case "text": {
+				let content = token.content.replace(/\\/g, "") || "";
+				if (content === "`" || content === "|" || content === "$" || content === "1" || /^\*+$/.test(content) || /^\d$/.test(content)) {
+					i++;
+					break;
+				}
+				if (/[^\]]\s*\(\s*$/.test(content)) content = content.replace(/\(\s*$/, "");
+				if (raw?.startsWith("[") && pPreToken?.type === "list_item_open") {
+					const w = content.slice(1).match(/[^\s\]]/);
+					if (w === null) {
+						i++;
+						break;
+					}
+					if (w && /x/i.test(w[0]) || !w) {
+						const checked = w ? w[0] === "x" || w[0] === "X" : false;
+						result.push({
+							type: "checkbox_input",
+							checked,
+							raw: checked ? "[x]" : "[ ]"
+						});
+						i++;
+						break;
+					}
+				}
+				if (/`[^`]*/.test(content)) {
+					currentTextNode = null;
+					result.push({
+						type: "inline_code",
+						code: content.replace(/`/g, ""),
+						raw: content || ""
+					});
+					i++;
+					break;
+				}
+				if (content === "[") {
+					i++;
+					break;
+				}
+				if (/[^~]*~{2,}[^~]+/.test(content)) {
+					const index = content.indexOf("~~") || 0;
+					const _text = content.slice(0, index);
+					if (_text) if (currentTextNode) {
+						currentTextNode.content += _text;
+						currentTextNode.raw += _text;
+					} else {
+						currentTextNode = {
+							type: "text",
+							content: _text || "",
+							raw: token.content || ""
+						};
+						result.push(currentTextNode);
+					}
+					const strikethroughContent = content.slice(index);
+					currentTextNode = null;
+					const { node } = parseStrikethroughToken([
+						{
+							type: "s_open",
+							tag: "s",
+							content: "",
+							markup: "*",
+							info: "",
+							meta: null
+						},
+						{
+							type: "text",
+							tag: "",
+							content: strikethroughContent.replace(/~/g, ""),
+							markup: "",
+							info: "",
+							meta: null
+						},
+						{
+							type: "s_close",
+							tag: "s",
+							content: "",
+							markup: "*",
+							info: "",
+							meta: null
+						}
+					], 0);
+					result.push(node);
+					i++;
+					break;
+				}
+				if (/[^*]*\*\*[^*]+/.test(content)) {
+					const index = content.indexOf("*") || 0;
+					const _text = content.slice(0, index);
+					if (_text) if (currentTextNode) {
+						currentTextNode.content += _text;
+						currentTextNode.raw += _text;
+					} else {
+						currentTextNode = {
+							type: "text",
+							content: _text || "",
+							raw: token.content || ""
+						};
+						result.push(currentTextNode);
+					}
+					const strongContent = content.slice(index);
+					currentTextNode = null;
+					const { node } = parseStrongToken([
+						{
+							type: "strong_open",
+							tag: "strong",
+							content: "",
+							markup: "*",
+							info: "",
+							meta: null
+						},
+						{
+							type: "text",
+							tag: "",
+							content: strongContent.replace(/\*/g, ""),
+							markup: "",
+							info: "",
+							meta: null
+						},
+						{
+							type: "strong_close",
+							tag: "strong",
+							content: "",
+							markup: "*",
+							info: "",
+							meta: null
+						}
+					], 0, raw);
+					result.push(node);
+					i++;
+					break;
+				} else if (/[^*]*\*[^*]+/.test(content)) {
+					const index = content.indexOf("*") || 0;
+					const _text = content.slice(0, index);
+					if (_text) if (currentTextNode) {
+						currentTextNode.content += _text;
+						currentTextNode.raw += _text;
+					} else {
+						currentTextNode = {
+							type: "text",
+							content: _text || "",
+							raw: token.content || ""
+						};
+						result.push(currentTextNode);
+					}
+					const emphasisContent = content.slice(index);
+					currentTextNode = null;
+					const { node } = parseEmphasisToken([
+						{
+							type: "em_open",
+							tag: "em",
+							content: "",
+							markup: "*",
+							info: "",
+							meta: null
+						},
+						{
+							type: "text",
+							tag: "",
+							content: emphasisContent.replace(/\*/g, ""),
+							markup: "",
+							info: "",
+							meta: null
+						},
+						{
+							type: "em_close",
+							tag: "em",
+							content: "",
+							markup: "*",
+							info: "",
+							meta: null
+						}
+					], 0);
+					result.push(node);
+					i++;
+					break;
+				}
+				const imageStart = content.indexOf("![");
+				if (imageStart !== -1) {
+					const textNodeContent = content.slice(0, imageStart);
+					if (!currentTextNode) currentTextNode = {
+						type: "text",
+						content: textNodeContent,
+						raw: textNodeContent
+					};
+					else currentTextNode.content += textNodeContent;
+					result.push(currentTextNode);
+					currentTextNode = null;
+					result.push(parseImageToken(token, true));
+					i++;
+					break;
+				}
+				const linkStart = content.indexOf("[");
+				if (content.endsWith("undefined") && !raw?.endsWith("undefined")) content = content.slice(0, -9);
+				const textNode = parseTextToken({
+					...token,
+					content
+				});
+				if (linkStart !== -1) {
+					const textNodeContent = content.slice(0, linkStart);
+					const linkEnd = content.indexOf("](", linkStart);
+					if (linkEnd !== -1) {
+						const text = content.slice(linkStart + 1, linkEnd);
+						if (!/[[\]()]/.test(text)) {
+							result.push({
+								type: "text",
+								content: textNodeContent,
+								raw: textNodeContent
+							});
+							result.push({
+								type: "link",
+								href: "",
+								text,
+								children: [{
+									type: "text",
+									content: text,
+									raw: text
+								}],
+								loading: true
+							});
+							i++;
+							break;
+						}
+					}
+				}
+				const preToken = tokens[i - 1];
+				if (currentTextNode) {
+					currentTextNode.content += textNode.content.replace(/(\*+|\(|\\)$/, "");
+					currentTextNode.raw += textNode.raw;
+				} else {
+					const maybeMath = preToken?.tag === "br" && tokens[i - 2]?.content === "[";
+					textNode.content = textNode.content.replace(/(\*+|\(|\\)$/, "");
+					currentTextNode = textNode;
+					currentTextNode.center = maybeMath;
+					result.push(currentTextNode);
+				}
+				i++;
+				break;
+			}
+			case "softbreak":
+				if (currentTextNode) {
+					currentTextNode.content += "\n";
+					currentTextNode.raw += "\n";
+				}
+				i++;
+				break;
+			case "code_inline":
+				currentTextNode = null;
+				result.push(parseInlineCodeToken(token));
+				i++;
+				break;
+			case "link_open": {
+				currentTextNode = null;
+				const href = token.attrs?.find((attr) => attr[0] === "href")?.[1];
+				if (raw && href) {
+					const loadingMath = /* @__PURE__ */ new RegExp(`\\(\\s*${href}\\s*\\)`);
+					const pre = result.length > 0 ? result[result.length - 1] : null;
+					const loading = !loadingMath.test(raw);
+					if (loading && pre) {
+						if ((/* @__PURE__ */ new RegExp(`\\[${pre.text}\\s*\\]\\(`)).test(raw)) {
+							const text = pre?.text || pre?.content?.slice(1, -1) || "";
+							result.splice(result.length - 1, 1, {
+								type: "link",
+								href: "",
+								text,
+								loading
+							});
+							i += 3;
+							if (tokens[i]?.content === ".") i++;
+							break;
+						}
+					}
+				}
+				const { node, nextIndex } = parseLinkToken(tokens, i);
+				i = nextIndex;
+				node.loading = false;
+				result.push(node);
+				break;
+			}
+			case "image":
+				currentTextNode = null;
+				result.push(parseImageToken(token));
+				i++;
+				break;
+			case "strong_open": {
+				currentTextNode = null;
+				const { node, nextIndex } = parseStrongToken(tokens, i, token.content);
+				result.push(node);
+				i = nextIndex;
+				break;
+			}
+			case "em_open": {
+				currentTextNode = null;
+				const { node, nextIndex } = parseEmphasisToken(tokens, i);
+				result.push(node);
+				i = nextIndex;
+				break;
+			}
+			case "s_open": {
+				currentTextNode = null;
+				const { node, nextIndex } = parseStrikethroughToken(tokens, i);
+				result.push(node);
+				i = nextIndex;
+				break;
+			}
+			case "mark_open": {
+				currentTextNode = null;
+				const { node, nextIndex } = parseHighlightToken(tokens, i);
+				result.push(node);
+				i = nextIndex;
+				break;
+			}
+			case "ins_open": {
+				currentTextNode = null;
+				const { node, nextIndex } = parseInsertToken(tokens, i);
+				result.push(node);
+				i = nextIndex;
+				break;
+			}
+			case "sub_open": {
+				currentTextNode = null;
+				const { node, nextIndex } = parseSubscriptToken(tokens, i);
+				result.push(node);
+				i = nextIndex;
+				break;
+			}
+			case "sup_open": {
+				currentTextNode = null;
+				const { node, nextIndex } = parseSuperscriptToken(tokens, i);
+				result.push(node);
+				i = nextIndex;
+				break;
+			}
+			case "sub":
+				currentTextNode = null;
+				result.push({
+					type: "subscript",
+					children: [{
+						type: "text",
+						content: token.content || "",
+						raw: token.content || ""
+					}],
+					raw: `~${token.content || ""}~`
+				});
+				i++;
+				break;
+			case "sup":
+				currentTextNode = null;
+				result.push({
+					type: "superscript",
+					children: [{
+						type: "text",
+						content: token.content || "",
+						raw: token.content || ""
+					}],
+					raw: `^${token.content || ""}^`
+				});
+				i++;
+				break;
+			case "emoji": {
+				currentTextNode = null;
+				const preToken = tokens[i - 1];
+				if (preToken?.type === "text" && /\|:-+/.test(preToken.content || "")) result.push({
+					type: "text",
+					content: "",
+					raw: ""
+				});
+				else result.push(parseEmojiToken(token));
+				i++;
+				break;
+			}
+			case "checkbox":
+				currentTextNode = null;
+				result.push(parseCheckboxToken(token));
+				i++;
+				break;
+			case "checkbox_input":
+				currentTextNode = null;
+				result.push(parseCheckboxInputToken(token));
+				i++;
+				break;
+			case "footnote_ref":
+				currentTextNode = null;
+				result.push(parseFootnoteRefToken(token));
+				i++;
+				break;
+			case "hardbreak":
+				currentTextNode = null;
+				result.push(parseHardbreakToken());
+				i++;
+				break;
+			case "fence":
+				currentTextNode = null;
+				result.push(parseFenceToken(tokens[i]));
+				i++;
+				break;
+			case "math_inline":
+				currentTextNode = null;
+				result.push(parseMathInlineToken(token));
+				i++;
+				break;
+			case "reference":
+				currentTextNode = null;
+				result.push(parseReferenceToken(token));
+				i++;
+				break;
+			default:
+				result.push(token);
+				currentTextNode = null;
+				i++;
+				break;
+		}
+	}
+	return result;
 }
-function V(e, c, i) {
-  const o = i[1] || "note", n = i[2] || o.charAt(0).toUpperCase() + o.slice(1), r = [];
-  let l = c + 1;
-  for (; l < e.length && e[l].type !== "container_close"; )
-    if (e[l].type === "paragraph_open") {
-      const s = e[l + 1];
-      s && r.push({
-        type: "paragraph",
-        children: b(s.children || []),
-        raw: s.content || ""
-      }), l += 3;
-    } else if (e[l].type === "bullet_list_open" || e[l].type === "ordered_list_open") {
-      const [s, a] = E(e, l);
-      r.push(s), l = a;
-    } else
-      l++;
-  return [{
-    type: "admonition",
-    kind: o,
-    title: n,
-    children: r,
-    raw: `:::${o} ${n}
-${r.map((s) => s.raw).join(`
-`)}
-:::`
-  }, l + 1];
+
+//#endregion
+//#region src/parser/node-parsers/blockquote-parser.ts
+function parseBlockquote(tokens, index) {
+	const blockquoteChildren = [];
+	let j = index + 1;
+	while (j < tokens.length && tokens[j].type !== "blockquote_close") if (tokens[j].type === "paragraph_open") {
+		const contentToken = tokens[j + 1];
+		blockquoteChildren.push({
+			type: "paragraph",
+			children: parseInlineTokens(contentToken.children || []),
+			raw: contentToken.content || ""
+		});
+		j += 3;
+	} else if (tokens[j].type === "bullet_list_open" || tokens[j].type === "ordered_list_open") {
+		const [listNode, newIndex] = parseList(tokens, j);
+		blockquoteChildren.push(listNode);
+		j = newIndex;
+	} else j++;
+	return [{
+		type: "blockquote",
+		children: blockquoteChildren,
+		raw: blockquoteChildren.map((child) => child.raw).join("\n")
+	}, j + 1];
 }
-function ve(e, c) {
-  const i = e[c];
-  let o = "note", n = "";
-  const r = i.type.match(/^container_(\w+)_open$/);
-  if (r) {
-    o = r[1];
-    const p = (i.info || "").trim();
-    if (p && !p.startsWith(":::")) {
-      const u = p.replace(new RegExp(`^${o}`), "").trim();
-      u && (n = u);
-    }
-  } else {
-    const p = (i.info || "").trim(), u = /^:{1,3}\s*(warning|info|note|tip|danger|caution)\s*(.*)$/i.exec(p);
-    u && (o = u[1], n = u[2] || "");
-  }
-  n || (n = o.charAt(0).toUpperCase() + o.slice(1));
-  const l = [];
-  let t = c + 1;
-  const s = new RegExp(`^container_${o}_close$`);
-  for (; t < e.length && e[t].type !== "container_close" && !s.test(e[t].type); )
-    if (e[t].type === "paragraph_open") {
-      const p = e[t + 1];
-      if (p) {
-        let u = -1;
-        if (p.children)
-          for (let h = p.children.length - 1; h >= 0; h--) {
-            const g = p.children[h];
-            if (g && g.type === "text" && /:+/.test(g.content || "")) {
-              u = h;
-              break;
-            }
-          }
-        const f = u !== -1 && p.children ? p.children.slice(0, u) : p.children;
-        l.push({
-          type: "paragraph",
-          children: b(f || []),
-          raw: p && typeof p.content == "string" ? p.content.replace(/\n:+$/, "").replace(/\n\s*:::\s*$/, "") : ""
-        });
-      }
-      t += 3;
-    } else if (e[t].type === "bullet_list_open" || e[t].type === "ordered_list_open") {
-      const [p, u] = E(e, t);
-      l.push(p), t = u;
-    } else
-      t++;
-  return [{
-    type: "admonition",
-    kind: o,
-    title: n,
-    children: l,
-    raw: `:::${o} ${n}
-${l.map((p) => p.raw).join(`
-`)}
-:::`
-  }, t + 1];
+
+//#endregion
+//#region src/parser/node-parsers/code-block-parser.ts
+function parseCodeBlock(token) {
+	if (token.info?.startsWith("diff")) return parseFenceToken(token);
+	const match = token.content.match(/ type="application\/vnd\.ant\.([^"]+)"/);
+	if (match?.[1]) token.content = token.content.replace(/<antArtifact[^>]*>/g, "").replace(/<\/antArtifact>/g, "");
+	const hasMap = Array.isArray(token.map) && token.map.length === 2;
+	return {
+		type: "code_block",
+		language: match ? match[1] : token.info || "",
+		code: token.content || "",
+		raw: token.content || "",
+		loading: !hasMap
+	};
 }
-function Ce() {
-  return {
-    type: "hardbreak",
-    raw: `\\
-`
-  };
+
+//#endregion
+//#region src/parser/node-parsers/definition-list-parser.ts
+function parseDefinitionList(tokens, index) {
+	const items = [];
+	let j = index + 1;
+	let termNodes = [];
+	let definitionNodes = [];
+	while (j < tokens.length && tokens[j].type !== "dl_close") if (tokens[j].type === "dt_open") {
+		const termToken = tokens[j + 1];
+		termNodes = parseInlineTokens(termToken.children || []);
+		j += 3;
+	} else if (tokens[j].type === "dd_open") {
+		let k = j + 1;
+		definitionNodes = [];
+		while (k < tokens.length && tokens[k].type !== "dd_close") if (tokens[k].type === "paragraph_open") {
+			const contentToken = tokens[k + 1];
+			definitionNodes.push({
+				type: "paragraph",
+				children: parseInlineTokens(contentToken.children || [], contentToken.content || ""),
+				raw: contentToken.content || ""
+			});
+			k += 3;
+		} else k++;
+		if (termNodes.length > 0) {
+			items.push({
+				type: "definition_item",
+				term: termNodes,
+				definition: definitionNodes,
+				raw: `${termNodes.map((term) => term.raw).join("")}: ${definitionNodes.map((def) => def.raw).join("\n")}`
+			});
+			termNodes = [];
+		}
+		j = k + 1;
+	} else j++;
+	return [{
+		type: "definition_list",
+		items,
+		raw: items.map((item) => item.raw).join("\n")
+	}, j + 1];
 }
-function Ne(e, c) {
-  const i = e[c + 1], o = i.content || "";
-  return {
-    type: "paragraph",
-    children: b(i.children || [], o),
-    raw: o
-  };
+
+//#endregion
+//#region src/parser/node-parsers/footnote-parser.ts
+function parseFootnote(tokens, index) {
+	const id = tokens[index].meta?.label ?? 0;
+	const footnoteChildren = [];
+	let j = index + 1;
+	while (j < tokens.length && tokens[j].type !== "footnote_close") if (tokens[j].type === "paragraph_open") {
+		const contentToken = tokens[j + 1];
+		footnoteChildren.push({
+			type: "paragraph",
+			children: parseInlineTokens(contentToken.children || []),
+			raw: contentToken.content || ""
+		});
+		j += 3;
+	} else j++;
+	return [{
+		type: "footnote",
+		id,
+		children: footnoteChildren,
+		raw: `[^${id}]: ${footnoteChildren.map((child) => child.raw).join("\n")}`
+	}, j + 1];
 }
-function Fe(e, c, i = {}) {
-  let o = (e ?? "").toString().replace(/([^\\])\right/g, "$1\\right");
-  o.endsWith("- *") && (o = o.replace(/- \*$/, "- \\*")), /\n\s*-\s*$/.test(o) ? o = o.replace(/\n\s*-\s*$/, `
-`) : /\n[[(]\n*$/.test(o) && (o = o.replace(/(\n\[|\n\()+\n*$/g, `
-`));
-  const n = c.parse(o, {});
-  if (!n || !Array.isArray(n))
-    return [];
-  const r = i.preTransformTokens, l = i.postTransformTokens;
-  let t = n;
-  r && typeof r == "function" && (t = r(n) || n);
-  let s = Ie(t);
-  return l && typeof l == "function" && (s = l(t) || t), s;
+
+//#endregion
+//#region src/parser/node-parsers/heading-parser.ts
+function parseHeading(tokens, index) {
+	const token = tokens[index];
+	const headingLevel = Number.parseInt(token.tag?.substring(1) || "1");
+	const headingContentToken = tokens[index + 1];
+	const headingContent = headingContentToken.content || "";
+	return {
+		type: "heading",
+		level: headingLevel,
+		text: headingContent,
+		children: parseInlineTokens(headingContentToken.children || []),
+		raw: headingContent
+	};
 }
-function Ie(e) {
-  if (!e || !Array.isArray(e))
-    return [];
-  const c = [];
-  let i = 0;
-  for (e = ce(e); i < e.length; ) {
-    const o = e[i];
-    switch (o.type) {
-      case "container_warning_open":
-      case "container_info_open":
-      case "container_note_open":
-      case "container_tip_open":
-      case "container_danger_open":
-      case "container_caution_open":
-      case "container_error_open": {
-        const [n, r] = ve(e, i);
-        c.push(n), i = r;
-        break;
-      }
-      case "heading_open":
-        c.push(z(e, i)), i += 3;
-        break;
-      case "paragraph_open":
-        c.push(Ne(e, i)), i += 3;
-        break;
-      case "html_block":
-      case "code_block":
-        c.push(A(e[i])), i += 1;
-        break;
-      case "fence":
-        c.push(N(e[i])), i += 1;
-        break;
-      case "bullet_list_open":
-      case "ordered_list_open": {
-        const [n, r] = E(e, i);
-        c.push(n), i = r;
-        break;
-      }
-      case "hr":
-        c.push(J()), i += 1;
-        break;
-      case "blockquote_open": {
-        const [n, r] = Z(e, i);
-        c.push(n), i = r;
-        break;
-      }
-      case "table_open": {
-        const [n, r] = K(e, i);
-        c.push(n), i = r;
-        break;
-      }
-      case "dl_open": {
-        const [n, r] = U(e, i);
-        c.push(n), i = r;
-        break;
-      }
-      case "footnote_open": {
-        const [n, r] = G(e, i);
-        c.push(n), i = r;
-        break;
-      }
-      case "container_open": {
-        const n = /^::: ?(warning|info|note|tip|danger|caution|error) ?(.*)$/.exec(
-          o.info || ""
-        );
-        if (n) {
-          const [r, l] = V(e, i, n);
-          c.push(r), i = l;
-        } else
-          i += 1;
-        break;
-      }
-      case "hardbreak":
-        c.push(Ce()), i++;
-        break;
-      case "math_block":
-        c.push(j(e[i])), i += 1;
-        break;
-      default:
-        i += 1;
-        break;
-    }
-  }
-  return c;
+
+//#endregion
+//#region src/parser/node-parsers/math-block-parser.ts
+function parseMathBlock(token) {
+	return {
+		type: "math_block",
+		content: token.content || "",
+		loading: !!token.loading,
+		raw: token.raw || ""
+	};
 }
-let Y;
-function Ze(e) {
-  Y = e;
+
+//#endregion
+//#region src/parser/node-parsers/table-parser.ts
+function parseTable(tokens, index) {
+	let j = index + 1;
+	let headerRow = null;
+	const rows = [];
+	let isHeader = false;
+	while (j < tokens.length && tokens[j].type !== "table_close") if (tokens[j].type === "thead_open") {
+		isHeader = true;
+		j++;
+	} else if (tokens[j].type === "thead_close") {
+		isHeader = false;
+		j++;
+	} else if (tokens[j].type === "tbody_open" || tokens[j].type === "tbody_close") j++;
+	else if (tokens[j].type === "tr_open") {
+		const cells = [];
+		let k = j + 1;
+		while (k < tokens.length && tokens[k].type !== "tr_close") if (tokens[k].type === "th_open" || tokens[k].type === "td_open") {
+			const isHeaderCell = tokens[k].type === "th_open";
+			const contentToken = tokens[k + 1];
+			const content = contentToken.content || "";
+			cells.push({
+				type: "table_cell",
+				header: isHeaderCell || isHeader,
+				children: parseInlineTokens(contentToken.children || [], content),
+				raw: content
+			});
+			k += 3;
+		} else k++;
+		const rowNode = {
+			type: "table_row",
+			cells,
+			raw: cells.map((cell) => cell.raw).join("|")
+		};
+		if (isHeader) headerRow = rowNode;
+		else rows.push(rowNode);
+		j = k + 1;
+	} else j++;
+	if (!headerRow) headerRow = {
+		type: "table_row",
+		cells: [],
+		raw: ""
+	};
+	return [{
+		type: "table",
+		header: headerRow,
+		rows,
+		loading: tokens[index].loading || false,
+		raw: [headerRow, ...rows].map((row) => row.raw).join("\n")
+	}, j + 1];
 }
-function Me() {
-  return Y;
+
+//#endregion
+//#region src/parser/node-parsers/thematic-break-parser.ts
+function parseThematicBreak() {
+	return {
+		type: "thematic_break",
+		raw: "---"
+	};
 }
-function Ee(e, c, i, o) {
-  const n = e.length;
-  if (i === "$$" && o === "$$") {
-    let a = c;
-    for (; a < n - 1; ) {
-      if (e[a] === "$" && e[a + 1] === "$") {
-        let d = a - 1, p = 0;
-        for (; d >= 0 && e[d] === "\\"; )
-          p++, d--;
-        if (p % 2 === 0)
-          return a;
-      }
-      a++;
-    }
-    return -1;
-  }
-  const r = i[i.length - 1], l = o;
-  let t = 0, s = c;
-  for (; s < n; ) {
-    if (e.slice(s, s + l.length) === l) {
-      let d = s - 1, p = 0;
-      for (; d >= 0 && e[d] === "\\"; )
-        p++, d--;
-      if (p % 2 === 0) {
-        if (t === 0)
-          return s;
-        t--, s += l.length;
-        continue;
-      }
-    }
-    const a = e[s];
-    if (a === "\\") {
-      s += 2;
-      continue;
-    }
-    a === r ? t++ : a === l[l.length - 1] && t > 0 && t--, s++;
-  }
-  return -1;
+
+//#endregion
+//#region src/parser/node-parsers/list-parser.ts
+function parseList(tokens, index) {
+	const token = tokens[index];
+	const listItems = [];
+	let j = index + 1;
+	while (j < tokens.length && tokens[j].type !== "bullet_list_close" && tokens[j].type !== "ordered_list_close") if (tokens[j].type === "list_item_open") {
+		if (tokens[j].markup === "*") {
+			j++;
+			continue;
+		}
+		const itemChildren = [];
+		let k = j + 1;
+		while (k < tokens.length && tokens[k].type !== "list_item_close") if (tokens[k].type === "paragraph_open") {
+			const contentToken = tokens[k + 1];
+			const preToken = tokens[k - 1];
+			if (/\n\d+$/.test(contentToken.content || "")) {
+				contentToken.content = contentToken.content?.replace(/\n\d+$/, "");
+				contentToken.children?.splice(-1, 1);
+			}
+			itemChildren.push({
+				type: "paragraph",
+				children: parseInlineTokens(contentToken.children || [], contentToken.content || "", preToken),
+				raw: contentToken.content || ""
+			});
+			k += 3;
+		} else if (tokens[k].type === "blockquote_open") {
+			const [blockquoteNode, newIndex] = parseBlockquote(tokens, k);
+			itemChildren.push(blockquoteNode);
+			k = newIndex;
+		} else if (tokens[k].type === "bullet_list_open" || tokens[k].type === "ordered_list_open") {
+			if (tokens[k].markup === "*") {
+				k++;
+				continue;
+			}
+			const [nestedListNode, newIndex] = parseNestedList(tokens, k);
+			itemChildren.push(nestedListNode);
+			k = newIndex;
+		} else if (tokens[k].type === "code_block") {
+			itemChildren.push(parseCodeBlock(tokens[k]));
+			k += 1;
+		} else if (tokens[k].type === "fence") {
+			itemChildren.push(parseFenceToken(tokens[k]));
+			k += 1;
+		} else if (tokens[k].type === "math_block") {
+			itemChildren.push(parseMathBlock(tokens[k]));
+			k += 1;
+		} else if (tokens[k].type === "table_open") {
+			const [tableNode, newIndex] = parseTable(tokens, k);
+			itemChildren.push(tableNode);
+			k = newIndex;
+		} else if (tokens[k].type === "dl_open") {
+			const [defListNode, newIndex] = parseDefinitionList(tokens, k);
+			itemChildren.push(defListNode);
+			k = newIndex;
+		} else if (tokens[k].type === "footnote_open") {
+			const [footnoteNode, newIndex] = parseFootnote(tokens, k);
+			itemChildren.push(footnoteNode);
+			k = newIndex;
+		} else if (tokens[k].type === "heading_open") {
+			const headingNode = parseHeading(tokens, k);
+			itemChildren.push(headingNode);
+			k += 3;
+		} else if (tokens[k].type === "hr") {
+			itemChildren.push(parseThematicBreak());
+			k += 1;
+		} else if (tokens[k].type === "container_open") {
+			const match = /^::: ?(warning|info|note|tip|danger|caution) ?(.*)$/.exec(tokens[k].info || "");
+			if (match) {
+				const [admonitionNode, newIndex] = parseAdmonition(tokens, k, match);
+				itemChildren.push(admonitionNode);
+				k = newIndex;
+			} else k += 1;
+		} else k += 1;
+		listItems.push({
+			type: "list_item",
+			children: itemChildren,
+			raw: itemChildren.map((child) => child.raw).join("")
+		});
+		j = k + 1;
+	} else j += 1;
+	return [{
+		type: "list",
+		ordered: token.type === "ordered_list_open",
+		start: (() => {
+			if (token.attrs && token.attrs.length) {
+				const found = token.attrs.find((a) => a[0] === "start");
+				if (found) return Number(found[1]) || 1;
+			}
+		})(),
+		items: listItems,
+		raw: listItems.map((item) => item.raw).join("\n")
+	}, j + 1];
 }
-function Se(e) {
-  [
-    "admonition",
-    "info",
-    "warning",
-    "error",
-    "tip",
-    "danger",
-    "note",
-    "caution"
-  ].forEach((c) => {
-    e.use(oe, c, {
-      render(i, o) {
-        return i[o].nesting === 1 ? `<div class="vmr-container vmr-container-${c}">` : `</div>
-`;
-      }
-    });
-  }), e.block.ruler.before(
-    "fence",
-    "vmr_container_fallback",
-    (c, i, o, n) => {
-      const r = c.bMarks[i] + c.tShift[i], l = c.eMarks[i], t = c.src.slice(r, l).match(/^:::\s*(\w+)/);
-      if (!t)
-        return !1;
-      if (n)
-        return !0;
-      const s = t[1];
-      let a = i + 1, d = !1;
-      for (; a <= o; ) {
-        const h = c.bMarks[a] + c.tShift[a], g = c.eMarks[a];
-        if (c.src.slice(h, g).trim() === ":::") {
-          d = !0;
-          break;
-        }
-        a++;
-      }
-      if (!d)
-        return !1;
-      c.push("vmr_container_open", "div", 1).attrSet("class", `vmr-container vmr-container-${s}`);
-      const u = [];
-      for (let h = i + 1; h < a; h++) {
-        const g = c.bMarks[h] + c.tShift[h], x = c.eMarks[h];
-        u.push(c.src.slice(g, x));
-      }
-      c.push("paragraph_open", "p", 1);
-      const f = c.push("inline", "", 0);
-      return f.content = u.join(`
-`), f.map = [i + 1, a], f.children = [], c.md.inline.parse(f.content, c.md, c.env, f.children), c.push("paragraph_close", "p", -1), c.push("vmr_container_close", "div", -1), c.line = a + 1, !0;
-    }
-  );
+function parseNestedList(tokens, index) {
+	const nestedToken = tokens[index];
+	const nestedItems = [];
+	let j = index + 1;
+	while (j < tokens.length && tokens[j].type !== "bullet_list_close" && tokens[j].type !== "ordered_list_close") if (tokens[j].type === "list_item_open") {
+		if (tokens[j].markup === "*") {
+			j++;
+			continue;
+		}
+		const itemChildren = [];
+		let k = j + 1;
+		while (k < tokens.length && tokens[k].type !== "list_item_close") if (tokens[k].type === "paragraph_open") {
+			const contentToken = tokens[k + 1];
+			const preToken = tokens[k - 1];
+			itemChildren.push({
+				type: "paragraph",
+				children: parseInlineTokens(contentToken.children || [], contentToken.content || "", preToken),
+				raw: contentToken.content || ""
+			});
+			k += 3;
+		} else if (tokens[k].type === "bullet_list_open" || tokens[k].type === "ordered_list_open") {
+			if (tokens[k].markup === "*") {
+				k++;
+				continue;
+			}
+			const [deeperNestedListNode, newIndex] = parseNestedList(tokens, k);
+			itemChildren.push(deeperNestedListNode);
+			k = newIndex;
+		} else if (tokens[k].type === "code_block") {
+			itemChildren.push(parseCodeBlock(tokens[k]));
+			k += 1;
+		} else if (tokens[k].type === "fence") {
+			itemChildren.push(parseFenceToken(tokens[k]));
+			k += 1;
+		} else if (tokens[k].type === "math_block") {
+			itemChildren.push(parseMathBlock(tokens[k]));
+			k += 1;
+		} else k += 1;
+		nestedItems.push({
+			type: "list_item",
+			children: itemChildren,
+			raw: itemChildren.map((child) => child.raw).join("")
+		});
+		j = k + 1;
+	} else j += 1;
+	return [{
+		type: "list",
+		ordered: nestedToken.type === "ordered_list_open",
+		start: (() => {
+			if (nestedToken.attrs && nestedToken.attrs.length) {
+				const found = nestedToken.attrs.find((a) => a[0] === "start");
+				if (found) return Number(found[1]) || 1;
+			}
+		})(),
+		items: nestedItems,
+		raw: nestedItems.map((item) => item.raw).join("\n")
+	}, j + 1];
 }
-const Ae = [
-  "mathbf",
-  "boldsymbol",
-  "mathbb",
-  "mathcal",
-  "mathfrak",
-  "mathrm",
-  "mathit",
-  "mathsf",
-  "vec",
-  "hat",
-  "bar",
-  "tilde",
-  "overline",
-  "underline",
-  "mathscr",
-  "mathnormal",
-  "operatorname",
-  "mathbf*"
-], M = Ae.map((e) => e.replace(/[.*+?^${}()|[\\]"\]/g, "\\$&")).join("|"), je = /\\[a-z]+/i, ee = "(?:\\\\|\\u0008)", Re = new RegExp(`${ee}(?:${M})\\s*\\{[^}]+\\}`, "i"), ke = new RegExp(`(?:${ee})?(?:${M})s*{`, "i"), Oe = /\\(?:text|frac|left|right|times)/, De = new RegExp("(?<!\\+)\\+(?!\\+)|[=\\-*/^<>]|\\\\times|\\\\pm|\\\\cdot|\\\\le|\\\\ge|\\\\neq"), Pe = /[A-Z]+\s*\([^)]+\)/i, Be = /\b(?:sin|cos|tan|log|ln|exp|sqrt|frac|sum|lim|int|prod)\b/, We = /\b\d{4}\/\d{1,2}\/\d{1,2}(?:[ T]\d{1,2}:\d{2}(?::\d{2})?)?\b/;
-function q(e) {
-  if (!e)
-    return !1;
-  const c = e.replace(/\u0008/g, "\\b"), i = c.trim();
-  if (We.test(i))
-    return !1;
-  if (i.length > 2e3)
-    return !0;
-  if (/[./]\s*\D|\D\s*[./]/.test(e))
-    return !1;
-  const o = je.test(c), n = Re.test(c), r = ke.test(c), l = Oe.test(c), t = /(?:^|[^\w\\])(?:[A-Z]|\\[A-Z]+)_(?:\{[^}]+\}|[A-Z0-9\\])/i, s = /(?:^|[^\w\\])(?:[A-Z]|\\[A-Z]+)\^(?:\{[^}]+\}|[A-Z0-9\\])/i, a = t.test(c) || s.test(c), d = De.test(c), p = Pe.test(c), u = Be.test(c);
-  return o || n || r || l || a || d || p || u;
+
+//#endregion
+//#region src/parser/node-parsers/admonition-parser.ts
+function parseAdmonition(tokens, index, match) {
+	const kind = match[1] || "note";
+	const title = match[2] || kind.charAt(0).toUpperCase() + kind.slice(1);
+	const admonitionChildren = [];
+	let j = index + 1;
+	while (j < tokens.length && tokens[j].type !== "container_close") if (tokens[j].type === "paragraph_open") {
+		const contentToken = tokens[j + 1];
+		if (contentToken) admonitionChildren.push({
+			type: "paragraph",
+			children: parseInlineTokens(contentToken.children || []),
+			raw: contentToken.content || ""
+		});
+		j += 3;
+	} else if (tokens[j].type === "bullet_list_open" || tokens[j].type === "ordered_list_open") {
+		const [listNode, newIndex] = parseList(tokens, j);
+		admonitionChildren.push(listNode);
+		j = newIndex;
+	} else j++;
+	return [{
+		type: "admonition",
+		kind,
+		title,
+		children: admonitionChildren,
+		raw: `:::${kind} ${title}\n${admonitionChildren.map((child) => child.raw).join("\n")}\n:::`
+	}, j + 1];
 }
-const ne = [
-  "ldots",
-  "cdots",
-  "quad",
-  "in",
-  "infty",
-  "perp",
-  "mid",
-  "operatorname",
-  "to",
-  "rightarrow",
-  "leftarrow",
-  "math",
-  "mathrm",
-  "mathbf",
-  "mathit",
-  "mathbb",
-  "mathcal",
-  "mathfrak",
-  "alpha",
-  "beta",
-  "gamma",
-  "delta",
-  "epsilon",
-  "lambda",
-  "sum",
-  "prod",
-  "int",
-  "sqrt",
-  "fbox",
-  "boxed",
-  "color",
-  "rule",
-  "edef",
-  "fcolorbox",
-  "hline",
-  "hdashline",
-  "cdot",
-  "times",
-  "pm",
-  "le",
-  "ge",
-  "neq",
-  "sin",
-  "cos",
-  "tan",
-  "log",
-  "ln",
-  "exp",
-  "lim",
-  "frac",
-  "text",
-  "left",
-  "right",
-  "times"
-], L = ne.slice().sort((e, c) => c.length - e.length).map((e) => e.replace(/[.*+?^${}()|[\\]\\\]/g, "\\$&")).join("|"), H = "[	\r\b\f\v]", X = {
-  "	": "t",
-  "\r": "r",
-  "\b": "b",
-  "\f": "f",
-  "\v": "v"
-};
-function F(e) {
-  const c = /(^|[^\\])(__|\*\*)/g;
-  let i = 0;
-  for (; c.exec(e) !== null; )
-    i++;
-  return i;
+
+//#endregion
+//#region src/parser/node-parsers/container-parser.ts
+function parseContainer(tokens, index) {
+	const openToken = tokens[index];
+	let kind = "note";
+	let title = "";
+	const typeMatch = openToken.type.match(/^container_(\w+)_open$/);
+	if (typeMatch) {
+		kind = typeMatch[1];
+		const info = (openToken.info || "").trim();
+		if (info && !info.startsWith(":::")) {
+			const maybe = info.replace(/* @__PURE__ */ new RegExp(`^${kind}`), "").trim();
+			if (maybe) title = maybe;
+		}
+	} else {
+		const info = (openToken.info || "").trim();
+		const match = /^:{1,3}\s*(warning|info|note|tip|danger|caution)\s*(.*)$/i.exec(info);
+		if (match) {
+			kind = match[1];
+			title = match[2] || "";
+		}
+	}
+	if (!title) title = kind.charAt(0).toUpperCase() + kind.slice(1);
+	const children = [];
+	let j = index + 1;
+	const closeType = /* @__PURE__ */ new RegExp(`^container_${kind}_close$`);
+	while (j < tokens.length && tokens[j].type !== "container_close" && !closeType.test(tokens[j].type)) if (tokens[j].type === "paragraph_open") {
+		const contentToken = tokens[j + 1];
+		if (contentToken) {
+			const i = contentToken.children.findLastIndex((t) => t.type === "text" && /:+/.test(t.content));
+			const _children = i !== -1 ? contentToken.children?.slice(0, i) : contentToken.children;
+			children.push({
+				type: "paragraph",
+				children: parseInlineTokens(_children || []),
+				raw: contentToken.content?.replace(/\n:+$/, "").replace(/\n\s*:::\s*$/, "") || ""
+			});
+		}
+		j += 3;
+	} else if (tokens[j].type === "bullet_list_open" || tokens[j].type === "ordered_list_open") {
+		const [listNode, newIndex] = parseList(tokens, j);
+		children.push(listNode);
+		j = newIndex;
+	} else j++;
+	return [{
+		type: "admonition",
+		kind,
+		title,
+		children,
+		raw: `:::${kind} ${title}\n${children.map((c) => c.raw).join("\n")}\n:::`
+	}, j + 1];
 }
-function C(e, c) {
-  const i = c?.commands ?? ne, o = c?.escapeExclamation ?? !0, n = c?.commands == null;
-  let r;
-  if (n)
-    r = new RegExp(`${H}|(?<!\\\\|\\w)(${L})\\b`, "g");
-  else {
-    const a = `(?:${i.slice().sort((d, p) => p.length - d.length).map((d) => d.replace(/[.*+?^${}()|[\\]\\"\]/g, "\\$&")).join("|")})`;
-    r = new RegExp(`${H}|(?<!\\\\|\\w)(${a})\\b`, "g");
-  }
-  let l = e.replace(r, (a, d) => X[a] !== void 0 ? `\\${X[a]}` : d && i.includes(d) ? `\\${d}` : a);
-  o && (l = l.replace(/(^|[^\\])!/g, "$1\\!"));
-  const t = n ? [M, L].filter(Boolean).join("|") : [i.map((a) => a.replace(/[.*+?^${}()|[\\]\\\]/g, "\\$&")).join("|"), M].filter(Boolean).join("|");
-  let s = l;
-  if (t) {
-    const a = new RegExp(`(^|[^\\\\])(${t})\\s*\\{`, "g");
-    s = s.replace(a, (d, p, u) => `${p}\\${u}{`);
-  }
-  return s = s.replace(/span\{([^}]+)\}/, "span\\{$1\\}").replace(/\\operatorname\{span\}\{((?:[^{}]|\{[^}]*\})+)\}/, "\\operatorname{span}\\{$1\\}"), s;
+
+//#endregion
+//#region src/parser/node-parsers/hardbreak-parser.ts
+function parseHardBreak() {
+	return {
+		type: "hardbreak",
+		raw: "\\\n"
+	};
 }
-function qe(e, c) {
-  const i = (n, r) => {
-    if (/^\*[^*]+/.test(n.src))
-      return !1;
-    const l = [
-      ["$$", "$$"],
-      ["\\(", "\\)"],
-      ["(", ")"]
-    ];
-    let t = 0, s = 0;
-    for (const [a, d] of l) {
-      const p = n.src;
-      let u = !1;
-      const f = (h) => {
-        if ((h === "undefined" || h == null) && (h = ""), h === "\\") {
-          n.pos = n.pos + h.length, t = n.pos;
-          return;
-        }
-        if (h === "\\)" || h === "\\(") {
-          const x = n.push("text_special", "", 0);
-          x.content = h === "\\)" ? ")" : "(", x.markup = h, n.pos = n.pos + h.length, t = n.pos;
-          return;
-        }
-        if (!h)
-          return;
-        const g = n.push("text", "", 0);
-        g.content = h, n.pos = n.pos + h.length, t = n.pos;
-      };
-      for (; !(t >= p.length); ) {
-        const h = p.indexOf(a, t);
-        if (h === -1)
-          break;
-        if (h > 0) {
-          let _ = h - 1;
-          for (; _ >= 0 && p[_] === " "; )
-            _--;
-          if (_ >= 0 && p[_] === "]")
-            return !1;
-        }
-        const g = Ee(p, h + a.length, a, d);
-        if (g === -1) {
-          const _ = p.slice(h + a.length);
-          if (q(_)) {
-            if (t = h + a.length, u = !0, !r) {
-              n.pending = "";
-              const T = s ? p.slice(s, t) : p.slice(0, t), y = F(T) % 2 === 1;
-              if (f(s ? p.slice(s, t) : p.slice(0, t)), y) {
-                const w = n.push("strong_open", "", 0);
-                w.markup = p.slice(0, h + 2);
-                const m = n.push("math_inline", "math", 0);
-                m.content = C(_, c), m.markup = a === "$$" ? "$$" : a === "\\(" ? "\\(\\)" : a === "$" ? "$" : "()", m.raw = `${a}${_}${d}`, m.loading = !0, w.content = _, n.push("strong_close", "", 0);
-              } else {
-                const w = n.push("math_inline", "math", 0);
-                w.content = C(_, c), w.markup = a === "$$" ? "$$" : a === "\\(" ? "\\(\\)" : a === "$" ? "$" : "()", w.raw = `${a}${_}${d}`, w.loading = !0;
-              }
-              n.pos = p.length;
-            }
-            t = p.length, s = t;
-          }
-          break;
-        }
-        const x = p.slice(h + a.length, g);
-        if (!q(x)) {
-          t = g + d.length;
-          const _ = p.slice(n.pos, t);
-          n.pending || f(_);
-          continue;
-        }
-        if (u = !0, !r) {
-          const _ = p.slice(0, h);
-          let y = p.slice(0, t) ? p.slice(s, h) : _;
-          const w = F(y) % 2 === 1;
-          if (h !== n.pos && w && (y = n.pending + p.slice(n.pos, h)), n.pending !== y)
-            if (n.pending = "", w) {
-              const m = y.match(/(\*+)/), $ = y.slice(m.index + m[0].length);
-              f(y.slice(0, m.index));
-              const v = n.push("strong_open", "", 0);
-              v.markup = m[0];
-              const I = n.push("text", "", 0);
-              I.content = $, n.push("strong_close", "", 0);
-            } else
-              f(y);
-          if (w) {
-            const m = n.push("strong_open", "", 0);
-            m.markup = "**";
-            const $ = n.push("math_inline", "math", 0);
-            $.content = C(x, c), $.markup = a === "$$" ? "$$" : a === "\\(" ? "\\(\\)" : a === "$" ? "$" : "()", $.raw = `${a}${x}${d}`, $.loading = !1;
-            const v = p.slice(g + d.length), I = v.startsWith("*");
-            if (I && n.push("strong_close", "", 0), v) {
-              const te = n.push("text", "", 0);
-              te.content = (v == null ? "" : String(v)).replace(/^\*+/, "");
-            }
-            I || n.push("strong_close", "", 0), n.pos = p.length, t = p.length, s = t;
-            continue;
-          } else {
-            const m = n.push("math_inline", "math", 0);
-            m.content = C(x, c), m.markup = a === "$$" ? "$$" : a === "\\(" ? "\\(\\)" : a === "$" ? "$" : "()", m.raw = `${a}${x}${d}`, m.loading = !1;
-          }
-        }
-        t = g + d.length, s = t, n.pos = t;
-      }
-      if (u)
-        return r ? n.pos = t : (t < p.length && f(p.slice(t)), n.pos = p.length), !0;
-    }
-    return !1;
-  }, o = (n, r, l, t) => {
-    const s = [
-      ["\\[", "\\]"],
-      ["[", "]"],
-      ["$$", "$$"]
-    ], a = n.bMarks[r] + n.tShift[r], d = n.src.slice(a, n.eMarks[r]).trim();
-    let p = !1, u = "", f = "";
-    for (const [y, w] of s)
-      if (d === y || d.startsWith(y))
-        if (y.includes("[")) {
-          if (d.replace("\\", "") === "[") {
-            if (r + 1 < l) {
-              p = !0, u = y, f = w;
-              break;
-            }
-            continue;
-          }
-        } else {
-          p = !0, u = y, f = w;
-          break;
-        }
-    if (!p)
-      return !1;
-    if (t)
-      return !0;
-    if (d.includes(f) && d.indexOf(f) > u.length) {
-      const y = d.indexOf(u), w = d.indexOf(
-        f,
-        y + u.length
-      ), m = d.slice(
-        y + u.length,
-        w
-      ), $ = n.push("math_block", "math", 0);
-      return $.content = C(m), $.markup = u === "$$" ? "$$" : u === "[" ? "[]" : "\\[\\]", $.map = [r, r + 1], $.raw = `${u}${m}${f}`, $.block = !0, $.loading = !1, n.line = r + 1, !0;
-    }
-    let h = r, g = "", x = !1;
-    const _ = d === u ? "" : d.slice(u.length);
-    if (_.includes(f)) {
-      const y = _.indexOf(f);
-      g = _.slice(0, y), x = !0, h = r;
-    } else
-      for (_ && (g = _), h = r + 1; h < l; h++) {
-        const y = n.bMarks[h] + n.tShift[h], w = n.eMarks[h], m = n.src.slice(y - 1, w);
-        if (m.trim() === f) {
-          x = !0;
-          break;
-        } else if (m.includes(f)) {
-          x = !0;
-          const $ = m.indexOf(f);
-          g += (g ? `
-` : "") + m.slice(0, $);
-          break;
-        }
-        g += (g ? `
-` : "") + m;
-      }
-    const T = n.push("math_block", "math", 0);
-    return T.content = C(g), T.markup = u === "$$" ? "$$" : u === "[" ? "[]" : "\\[\\]", T.raw = `${u}${g}${g.startsWith(`
-`) ? `
-` : ""}${f}`, T.map = [r, h + 1], T.block = !0, T.loading = !x, n.line = h + 1, !0;
-  };
-  e.inline.ruler.before("escape", "math", i), e.block.ruler.before("paragraph", "math_block", o, {
-    alt: ["paragraph", "reference", "blockquote", "list"]
-  });
+
+//#endregion
+//#region src/parser/node-parsers/paragraph-parser.ts
+function parseParagraph(tokens, index) {
+	const paragraphContentToken = tokens[index + 1];
+	const paragraphContent = paragraphContentToken.content || "";
+	return {
+		type: "paragraph",
+		children: parseInlineTokens(paragraphContentToken.children || [], paragraphContent),
+		raw: paragraphContent
+	};
 }
-function Le(e) {
-  const c = e.renderer.rules.image || function(i, o, n, r, l) {
-    return l.renderToken(i, o, n);
-  };
-  e.renderer.rules.image = (i, o, n, r, l) => (i[o].attrSet?.("loading", "lazy"), c(i, o, n, r, l)), e.renderer.rules.fence = e.renderer.rules.fence || ((i, o) => {
-    const n = i[o], r = n.info ? n.info.trim() : "", l = r ? `language-${e.utils.escapeHtml(r.split(/\s+/g)[0])}` : "", t = e.utils.escapeHtml(n.content);
-    return `<pre class="${l}"><code>${t}</code></pre>`;
-  });
+
+//#endregion
+//#region src/parser/index.ts
+function parseMarkdownToStructure(markdown, md, options = {}) {
+	let safeMarkdown = (markdown ?? "").toString().replace(/([^\\])\right/g, "$1\\right");
+	if (safeMarkdown.endsWith("- *")) safeMarkdown = safeMarkdown.replace(/- \*$/, "- \\*");
+	if (/\n\s*-\s*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/\n\s*-\s*$/, "\n");
+	else if (/\n[[(]\n*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/(\n\[|\n\()+\n*$/g, "\n");
+	const tokens = md.parse(safeMarkdown, {});
+	if (!tokens || !Array.isArray(tokens)) return [];
+	const pre = options.preTransformTokens;
+	const post = options.postTransformTokens;
+	let transformedTokens = tokens;
+	if (pre && typeof pre === "function") transformedTokens = pre(tokens) || tokens;
+	let result = processTokens(transformedTokens);
+	if (post && typeof post === "function") result = post(transformedTokens) || transformedTokens;
+	return result;
 }
-function Ue(e = {}) {
-  const c = new re({
-    html: !0,
-    linkify: !0,
-    typographer: !0,
-    ...e.markdownItOptions ?? {}
-  });
-  if (e.enableMath ?? !0) {
-    const i = { ...Me() ?? {}, ...e.mathOptions ?? {} };
-    qe(c, i);
-  }
-  return (e.enableContainers ?? !0) && Se(c), Le(c), c;
+function processTokens(tokens) {
+	if (!tokens || !Array.isArray(tokens)) return [];
+	const result = [];
+	let i = 0;
+	tokens = fixTableTokens(tokens);
+	while (i < tokens.length) {
+		const token = tokens[i];
+		switch (token.type) {
+			case "container_warning_open":
+			case "container_info_open":
+			case "container_note_open":
+			case "container_tip_open":
+			case "container_danger_open":
+			case "container_caution_open":
+			case "container_error_open": {
+				const [warningNode, newIndex] = parseContainer(tokens, i);
+				result.push(warningNode);
+				i = newIndex;
+				break;
+			}
+			case "heading_open":
+				result.push(parseHeading(tokens, i));
+				i += 3;
+				break;
+			case "paragraph_open":
+				result.push(parseParagraph(tokens, i));
+				i += 3;
+				break;
+			case "html_block":
+			case "code_block":
+				result.push(parseCodeBlock(tokens[i]));
+				i += 1;
+				break;
+			case "fence":
+				result.push(parseFenceToken(tokens[i]));
+				i += 1;
+				break;
+			case "bullet_list_open":
+			case "ordered_list_open": {
+				const [listNode, newIndex] = parseList(tokens, i);
+				result.push(listNode);
+				i = newIndex;
+				break;
+			}
+			case "hr":
+				result.push(parseThematicBreak());
+				i += 1;
+				break;
+			case "blockquote_open": {
+				const [blockquoteNode, newIndex] = parseBlockquote(tokens, i);
+				result.push(blockquoteNode);
+				i = newIndex;
+				break;
+			}
+			case "table_open": {
+				const [tableNode, newIndex] = parseTable(tokens, i);
+				result.push(tableNode);
+				i = newIndex;
+				break;
+			}
+			case "dl_open": {
+				const [definitionListNode, newIndex] = parseDefinitionList(tokens, i);
+				result.push(definitionListNode);
+				i = newIndex;
+				break;
+			}
+			case "footnote_open": {
+				const [footnoteNode, newIndex] = parseFootnote(tokens, i);
+				result.push(footnoteNode);
+				i = newIndex;
+				break;
+			}
+			case "container_open": {
+				const match = /^::: ?(warning|info|note|tip|danger|caution|error) ?(.*)$/.exec(token.info || "");
+				if (match) {
+					const [admonitionNode, newIndex] = parseAdmonition(tokens, i, match);
+					result.push(admonitionNode);
+					i = newIndex;
+				} else i += 1;
+				break;
+			}
+			case "hardbreak":
+				result.push(parseHardBreak());
+				i++;
+				break;
+			case "math_block":
+				result.push(parseMathBlock(tokens[i]));
+				i += 1;
+				break;
+			default:
+				i += 1;
+				break;
+		}
+	}
+	return result;
 }
-export {
-  ne as KATEX_COMMANDS,
-  Se as applyContainers,
-  qe as applyMath,
-  Ee as findMatchingClose,
-  Me as getDefaultMathOptions,
-  Ue as getMarkdown,
-  C as normalizeStandaloneBackslashT,
-  b as parseInlineTokens,
-  Fe as parseMarkdownToStructure,
-  Ie as processTokens,
-  Ze as setDefaultMathOptions
-};
+
+//#endregion
+//#region src/index.ts
+function getMarkdown(msgId = `editor-${Date.now()}`, options = {}) {
+	const md = factory(options);
+	const defaultTranslations = { "common.copy": "Copy" };
+	let t;
+	if (typeof options.i18n === "function") t = options.i18n;
+	else if (options.i18n && typeof options.i18n === "object") {
+		const i18nMap = options.i18n;
+		t = (key) => i18nMap[key] ?? defaultTranslations[key] ?? key;
+	} else t = (key) => defaultTranslations[key] ?? key;
+	if (Array.isArray(options.plugin)) for (const p of options.plugin) if (Array.isArray(p)) md.use(p[0], p[1]);
+	else md.use(p);
+	if (Array.isArray(options.apply)) for (const fn of options.apply) try {
+		fn(md);
+	} catch (e) {
+		console.error("[getMarkdown] apply function threw an error", e);
+	}
+	md.use(markdownItSub);
+	md.use(markdownItSup);
+	md.use(markdownItMark);
+	md.use(full);
+	const markdownItCheckboxPlugin = markdownItCheckbox.default ?? markdownItCheckbox;
+	md.use(markdownItCheckboxPlugin);
+	md.use(markdownItIns);
+	md.use(markdownItFootnote);
+	md.core.ruler.after("block", "mark_fence_closed", (state) => {
+		const lines = state.src.split(/\r?\n/);
+		for (const token of state.tokens) {
+			if (token.type !== "fence" || !token.map || !token.markup) continue;
+			const openLine = token.map[0];
+			const endLine = token.map[1];
+			const markup = token.markup;
+			const marker = markup[0];
+			const minLen = markup.length;
+			const line = lines[Math.max(0, endLine - 1)] ?? "";
+			let i = 0;
+			while (i < line.length && (line[i] === " " || line[i] === "	")) i++;
+			let count = 0;
+			while (i + count < line.length && line[i + count] === marker) count++;
+			let j = i + count;
+			while (j < line.length && (line[j] === " " || line[j] === "	")) j++;
+			const closed = endLine > openLine + 1 && count >= minLen && j === line.length;
+			token.meta = token.meta || {};
+			token.meta.unclosed = !closed;
+			token.meta.closed = !!closed;
+		}
+	});
+	const waveRule = (state, silent) => {
+		const start = state.pos;
+		if (state.src[start] !== "~") return false;
+		const prevChar = state.src[start - 1];
+		const nextChar = state.src[start + 1];
+		if (/\d/.test(prevChar) && /\d/.test(nextChar)) {
+			if (!silent) {
+				const token = state.push("text", "", 0);
+				token.content = "~";
+			}
+			state.pos += 1;
+			return true;
+		}
+		return false;
+	};
+	md.inline.ruler.before("sub", "wave", waveRule);
+	md.renderer.rules.fence = (tokens, idx) => {
+		const token = tokens[idx];
+		const info = token.info ? token.info.trim() : "";
+		const str = token.content;
+		const encodedCode = btoa(unescape(encodeURIComponent(str)));
+		const language = info || "text";
+		return `<div class="code-block" data-code="${encodedCode}" data-lang="${language}" id="${`editor-${msgId}-${idx}-${language}`}">
+      <div class="code-header">
+        <span class="code-lang">${language.toUpperCase()}</span>
+        <button class="copy-button" data-code="${encodedCode}">${t("common.copy")}</button>
+      </div>
+      <div class="code-editor"></div>
+    </div>`;
+	};
+	const referenceInline = (state, silent) => {
+		if (state.src[state.pos] !== "[") return false;
+		const match = /^\[(\d+)\]/.exec(state.src.slice(state.pos));
+		if (!match) return false;
+		if (!silent) {
+			const id = match[1];
+			const token = state.push("reference", "span", 0);
+			token.content = id;
+			token.markup = match[0];
+		}
+		state.pos += match[0].length;
+		return true;
+	};
+	md.inline.ruler.before("escape", "reference", referenceInline);
+	md.renderer.rules.reference = (tokens, idx) => {
+		const id = tokens[idx].content;
+		return `<span class="reference-link" data-reference-id="${id}" role="button" tabindex="0" title="Click to view reference">${id}</span>`;
+	};
+	return md;
+}
+function getCommonMarkdown() {
+	return new MarkdownIt({
+		html: true,
+		linkify: true,
+		typographer: true,
+		breaks: false
+	});
+}
+function renderMarkdown(md, content) {
+	return md.render(content);
+}
+
+//#endregion
+export { ESCAPED_TEX_BRACE_COMMANDS, KATEX_COMMANDS, TEX_BRACE_COMMANDS, applyContainers, applyMath, findMatchingClose, getCommonMarkdown, getMarkdown, isMathLike, normalizeStandaloneBackslashT, parseFenceToken, parseInlineTokens, parseMarkdownToStructure, processTokens, renderMarkdown, setDefaultMathOptions };
+//# sourceMappingURL=index.js.map