@cardstack/boxel-cli 0.3.2-unstable.58 → 0.3.2-unstable.60

package/bundled-test-harness/assets/marked-sync-DenC7QgC.js

@@ -0,0 +1,2561 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=[(globalThis.__boxelAssetsURL||"/")+"assets/monaco.contribution-DhNsYtZe.js",(globalThis.__boxelAssetsURL||"/")+"assets/monaco.contribution-DvJDImx2.js",(globalThis.__boxelAssetsURL||"/")+"assets/chunk-CGdGNDIi.js",(globalThis.__boxelAssetsURL||"/")+"assets/preload-helper-CsWBX1L7.js",(globalThis.__boxelAssetsURL||"/")+"assets/editor.api-C-6J5J7V.js",(globalThis.__boxelAssetsURL||"/")+"assets/languages-DCTDTjXB.js",(globalThis.__boxelAssetsURL||"/")+"assets/editor-C3U8oQBi.css",(globalThis.__boxelAssetsURL||"/")+"assets/monaco.contribution-B1hOUP3w.js",(globalThis.__boxelAssetsURL||"/")+"assets/monaco.contribution-yXcOyzue.js",(globalThis.__boxelAssetsURL||"/")+"assets/languages-BHLYFSz9.js"])))=>i.map(i=>d[i]);
+import { i as __name } from "./chunk-CGdGNDIi.js";
+import { E as escapeHtml, r as bfmCardReferenceExtensions, t as sanitizeHtml } from "./dompurify-runtime-DnZEeRZb.js";
+import { t as __vitePreload } from "./preload-helper-CsWBX1L7.js";
+//#region ../runtime-common/bfm-math.ts
+var inlineRule = /^(\${1,2})(?!\$)((?:\\.|[^\\\n])*?(?:\\.|[^\\\n$]))\1(?=[\s?!.,:\uFF1F\uFF01\u3002\uFF0C\uFF1A]|$)/;
+var blockRule = /^(\${1,2})\n((?:\\[^]|[^\\])+?)\n\1(?:\n|$)/;
+/**
+* A marked extension that tokenizes LaTeX math (`$...$` inline, `$$...$$`
+* block) and emits lightweight placeholder HTML instead of rendering with
+* KaTeX at parse time. This keeps the heavy KaTeX library (~268 KB min) out
+* of the initial bundle.
+*
+* Placeholders:
+*   Inline:  <span class="math-placeholder" data-math="..." data-display="false">$...$</span>
+*   Block:   <div  class="math-placeholder" data-math="..." data-display="true">$$...$$</div>
+*
+* A client-side modifier should query `.math-placeholder` elements, lazy-load
+* KaTeX via `import('katex')`, and call `katex.render()` on each one.
+*/
+function markedKatexPlaceholder() {
+	return { extensions: [inlineKatex(), blockKatex()] };
+}
+function inlineKatex() {
+	return {
+		name: "inlineKatex",
+		level: "inline",
+		start(src) {
+			let indexSrc = src;
+			while (indexSrc) {
+				let index = indexSrc.indexOf("$");
+				if (index === -1) return void 0;
+				if (index === 0 || indexSrc.charAt(index - 1) === " ") {
+					if (indexSrc.substring(index).match(inlineRule)) return index;
+				}
+				indexSrc = indexSrc.substring(index + 1).replace(/^\$+/, "");
+			}
+		},
+		tokenizer(src) {
+			let match = src.match(inlineRule);
+			if (match) return {
+				type: "inlineKatex",
+				raw: match[0],
+				text: match[2].trim(),
+				displayMode: match[1].length === 2
+			};
+		},
+		renderer(token) {
+			return `<span class="math-placeholder" data-math="${escapeHtml(token.text)}" data-display="false">${escapeHtml(token.raw)}</span>`;
+		}
+	};
+}
+function blockKatex() {
+	return {
+		name: "blockKatex",
+		level: "block",
+		tokenizer(src) {
+			let match = src.match(blockRule);
+			if (match) return {
+				type: "blockKatex",
+				raw: match[0],
+				text: match[2].trim(),
+				displayMode: match[1].length === 2
+			};
+		},
+		renderer(token) {
+			return `<div class="math-placeholder" data-math="${escapeHtml(token.text)}" data-display="true">${escapeHtml(token.raw)}</div>\n`;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/marked@12.0.2/node_modules/marked/lib/marked.esm.js
+/**
+* marked v12.0.2 - a markdown parser
+* Copyright (c) 2011-2024, Christopher Jeffrey. (MIT Licensed)
+* https://github.com/markedjs/marked
+*/
+/**
+* DO NOT EDIT THIS FILE
+* The code in this file is generated from files in ./src/
+*/
+/**
+* Gets the original marked default options.
+*/
+function _getDefaults() {
+	return {
+		async: false,
+		breaks: false,
+		extensions: null,
+		gfm: true,
+		hooks: null,
+		pedantic: false,
+		renderer: null,
+		silent: false,
+		tokenizer: null,
+		walkTokens: null
+	};
+}
+var _defaults = _getDefaults();
+function changeDefaults(newDefaults) {
+	_defaults = newDefaults;
+}
+/**
+* Helpers
+*/
+var escapeTest = /[&<>"']/;
+var escapeReplace = new RegExp(escapeTest.source, "g");
+var escapeTestNoEncode = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
+var escapeReplaceNoEncode = new RegExp(escapeTestNoEncode.source, "g");
+var escapeReplacements = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+var getEscapeReplacement = (ch) => escapeReplacements[ch];
+function escape$1(html, encode) {
+	if (encode) {
+		if (escapeTest.test(html)) return html.replace(escapeReplace, getEscapeReplacement);
+	} else if (escapeTestNoEncode.test(html)) return html.replace(escapeReplaceNoEncode, getEscapeReplacement);
+	return html;
+}
+var unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/gi;
+function unescape(html) {
+	return html.replace(unescapeTest, (_, n) => {
+		n = n.toLowerCase();
+		if (n === "colon") return ":";
+		if (n.charAt(0) === "#") return n.charAt(1) === "x" ? String.fromCharCode(parseInt(n.substring(2), 16)) : String.fromCharCode(+n.substring(1));
+		return "";
+	});
+}
+var caret = /(^|[^\[])\^/g;
+function edit(regex, opt) {
+	let source = typeof regex === "string" ? regex : regex.source;
+	opt = opt || "";
+	const obj = {
+		replace: (name, val) => {
+			let valSource = typeof val === "string" ? val : val.source;
+			valSource = valSource.replace(caret, "$1");
+			source = source.replace(name, valSource);
+			return obj;
+		},
+		getRegex: () => {
+			return new RegExp(source, opt);
+		}
+	};
+	return obj;
+}
+function cleanUrl(href) {
+	try {
+		href = encodeURI(href).replace(/%25/g, "%");
+	} catch (e) {
+		return null;
+	}
+	return href;
+}
+var noopTest = { exec: () => null };
+function splitCells$1(tableRow, count) {
+	const cells = tableRow.replace(/\|/g, (match, offset, str) => {
+		let escaped = false;
+		let curr = offset;
+		while (--curr >= 0 && str[curr] === "\\") escaped = !escaped;
+		if (escaped) return "|";
+		else return " |";
+	}).split(/ \|/);
+	let i = 0;
+	if (!cells[0].trim()) cells.shift();
+	if (cells.length > 0 && !cells[cells.length - 1].trim()) cells.pop();
+	if (count) if (cells.length > count) cells.splice(count);
+	else while (cells.length < count) cells.push("");
+	for (; i < cells.length; i++) cells[i] = cells[i].trim().replace(/\\\|/g, "|");
+	return cells;
+}
+__name(splitCells$1, "splitCells");
+/**
+* Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
+* /c*$/ is vulnerable to REDOS.
+*
+* @param str
+* @param c
+* @param invert Remove suffix of non-c chars instead. Default falsey.
+*/
+function rtrim(str, c, invert) {
+	const l = str.length;
+	if (l === 0) return "";
+	let suffLen = 0;
+	while (suffLen < l) {
+		const currChar = str.charAt(l - suffLen - 1);
+		if (currChar === c && !invert) suffLen++;
+		else if (currChar !== c && invert) suffLen++;
+		else break;
+	}
+	return str.slice(0, l - suffLen);
+}
+function findClosingBracket(str, b) {
+	if (str.indexOf(b[1]) === -1) return -1;
+	let level = 0;
+	for (let i = 0; i < str.length; i++) if (str[i] === "\\") i++;
+	else if (str[i] === b[0]) level++;
+	else if (str[i] === b[1]) {
+		level--;
+		if (level < 0) return i;
+	}
+	return -1;
+}
+function outputLink(cap, link, raw, lexer) {
+	const href = link.href;
+	const title = link.title ? escape$1(link.title) : null;
+	const text = cap[1].replace(/\\([\[\]])/g, "$1");
+	if (cap[0].charAt(0) !== "!") {
+		lexer.state.inLink = true;
+		const token = {
+			type: "link",
+			raw,
+			href,
+			title,
+			text,
+			tokens: lexer.inlineTokens(text)
+		};
+		lexer.state.inLink = false;
+		return token;
+	}
+	return {
+		type: "image",
+		raw,
+		href,
+		title,
+		text: escape$1(text)
+	};
+}
+function indentCodeCompensation(raw, text) {
+	const matchIndentToCode = raw.match(/^(\s+)(?:```)/);
+	if (matchIndentToCode === null) return text;
+	const indentToCode = matchIndentToCode[1];
+	return text.split("\n").map((node) => {
+		const matchIndentInNode = node.match(/^\s+/);
+		if (matchIndentInNode === null) return node;
+		const [indentInNode] = matchIndentInNode;
+		if (indentInNode.length >= indentToCode.length) return node.slice(indentToCode.length);
+		return node;
+	}).join("\n");
+}
+/**
+* Tokenizer
+*/
+var _Tokenizer = class {
+	options;
+	rules;
+	lexer;
+	constructor(options) {
+		this.options = options || _defaults;
+	}
+	space(src) {
+		const cap = this.rules.block.newline.exec(src);
+		if (cap && cap[0].length > 0) return {
+			type: "space",
+			raw: cap[0]
+		};
+	}
+	code(src) {
+		const cap = this.rules.block.code.exec(src);
+		if (cap) {
+			const text = cap[0].replace(/^ {1,4}/gm, "");
+			return {
+				type: "code",
+				raw: cap[0],
+				codeBlockStyle: "indented",
+				text: !this.options.pedantic ? rtrim(text, "\n") : text
+			};
+		}
+	}
+	fences(src) {
+		const cap = this.rules.block.fences.exec(src);
+		if (cap) {
+			const raw = cap[0];
+			const text = indentCodeCompensation(raw, cap[3] || "");
+			return {
+				type: "code",
+				raw,
+				lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : cap[2],
+				text
+			};
+		}
+	}
+	heading(src) {
+		const cap = this.rules.block.heading.exec(src);
+		if (cap) {
+			let text = cap[2].trim();
+			if (/#$/.test(text)) {
+				const trimmed = rtrim(text, "#");
+				if (this.options.pedantic) text = trimmed.trim();
+				else if (!trimmed || / $/.test(trimmed)) text = trimmed.trim();
+			}
+			return {
+				type: "heading",
+				raw: cap[0],
+				depth: cap[1].length,
+				text,
+				tokens: this.lexer.inline(text)
+			};
+		}
+	}
+	hr(src) {
+		const cap = this.rules.block.hr.exec(src);
+		if (cap) return {
+			type: "hr",
+			raw: cap[0]
+		};
+	}
+	blockquote(src) {
+		const cap = this.rules.block.blockquote.exec(src);
+		if (cap) {
+			let text = cap[0].replace(/\n {0,3}((?:=+|-+) *)(?=\n|$)/g, "\n    $1");
+			text = rtrim(text.replace(/^ *>[ \t]?/gm, ""), "\n");
+			const top = this.lexer.state.top;
+			this.lexer.state.top = true;
+			const tokens = this.lexer.blockTokens(text);
+			this.lexer.state.top = top;
+			return {
+				type: "blockquote",
+				raw: cap[0],
+				tokens,
+				text
+			};
+		}
+	}
+	list(src) {
+		let cap = this.rules.block.list.exec(src);
+		if (cap) {
+			let bull = cap[1].trim();
+			const isordered = bull.length > 1;
+			const list = {
+				type: "list",
+				raw: "",
+				ordered: isordered,
+				start: isordered ? +bull.slice(0, -1) : "",
+				loose: false,
+				items: []
+			};
+			bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`;
+			if (this.options.pedantic) bull = isordered ? bull : "[*+-]";
+			const itemRegex = new RegExp(`^( {0,3}${bull})((?:[\t ][^\\n]*)?(?:\\n|$))`);
+			let raw = "";
+			let itemContents = "";
+			let endsWithBlankLine = false;
+			while (src) {
+				let endEarly = false;
+				if (!(cap = itemRegex.exec(src))) break;
+				if (this.rules.block.hr.test(src)) break;
+				raw = cap[0];
+				src = src.substring(raw.length);
+				let line = cap[2].split("\n", 1)[0].replace(/^\t+/, (t) => " ".repeat(3 * t.length));
+				let nextLine = src.split("\n", 1)[0];
+				let indent = 0;
+				if (this.options.pedantic) {
+					indent = 2;
+					itemContents = line.trimStart();
+				} else {
+					indent = cap[2].search(/[^ ]/);
+					indent = indent > 4 ? 1 : indent;
+					itemContents = line.slice(indent);
+					indent += cap[1].length;
+				}
+				let blankLine = false;
+				if (!line && /^ *$/.test(nextLine)) {
+					raw += nextLine + "\n";
+					src = src.substring(nextLine.length + 1);
+					endEarly = true;
+				}
+				if (!endEarly) {
+					const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ \t][^\\n]*)?(?:\\n|$))`);
+					const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`);
+					const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`);
+					const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);
+					while (src) {
+						const rawLine = src.split("\n", 1)[0];
+						nextLine = rawLine;
+						if (this.options.pedantic) nextLine = nextLine.replace(/^ {1,4}(?=( {4})*[^ ])/g, "  ");
+						if (fencesBeginRegex.test(nextLine)) break;
+						if (headingBeginRegex.test(nextLine)) break;
+						if (nextBulletRegex.test(nextLine)) break;
+						if (hrRegex.test(src)) break;
+						if (nextLine.search(/[^ ]/) >= indent || !nextLine.trim()) itemContents += "\n" + nextLine.slice(indent);
+						else {
+							if (blankLine) break;
+							if (line.search(/[^ ]/) >= 4) break;
+							if (fencesBeginRegex.test(line)) break;
+							if (headingBeginRegex.test(line)) break;
+							if (hrRegex.test(line)) break;
+							itemContents += "\n" + nextLine;
+						}
+						if (!blankLine && !nextLine.trim()) blankLine = true;
+						raw += rawLine + "\n";
+						src = src.substring(rawLine.length + 1);
+						line = nextLine.slice(indent);
+					}
+				}
+				if (!list.loose) {
+					if (endsWithBlankLine) list.loose = true;
+					else if (/\n *\n *$/.test(raw)) endsWithBlankLine = true;
+				}
+				let istask = null;
+				let ischecked;
+				if (this.options.gfm) {
+					istask = /^\[[ xX]\] /.exec(itemContents);
+					if (istask) {
+						ischecked = istask[0] !== "[ ] ";
+						itemContents = itemContents.replace(/^\[[ xX]\] +/, "");
+					}
+				}
+				list.items.push({
+					type: "list_item",
+					raw,
+					task: !!istask,
+					checked: ischecked,
+					loose: false,
+					text: itemContents,
+					tokens: []
+				});
+				list.raw += raw;
+			}
+			list.items[list.items.length - 1].raw = raw.trimEnd();
+			list.items[list.items.length - 1].text = itemContents.trimEnd();
+			list.raw = list.raw.trimEnd();
+			for (let i = 0; i < list.items.length; i++) {
+				this.lexer.state.top = false;
+				list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);
+				if (!list.loose) {
+					const spacers = list.items[i].tokens.filter((t) => t.type === "space");
+					list.loose = spacers.length > 0 && spacers.some((t) => /\n.*\n/.test(t.raw));
+				}
+			}
+			if (list.loose) for (let i = 0; i < list.items.length; i++) list.items[i].loose = true;
+			return list;
+		}
+	}
+	html(src) {
+		const cap = this.rules.block.html.exec(src);
+		if (cap) return {
+			type: "html",
+			block: true,
+			raw: cap[0],
+			pre: cap[1] === "pre" || cap[1] === "script" || cap[1] === "style",
+			text: cap[0]
+		};
+	}
+	def(src) {
+		const cap = this.rules.block.def.exec(src);
+		if (cap) {
+			const tag = cap[1].toLowerCase().replace(/\s+/g, " ");
+			const href = cap[2] ? cap[2].replace(/^<(.*)>$/, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "";
+			const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : cap[3];
+			return {
+				type: "def",
+				tag,
+				raw: cap[0],
+				href,
+				title
+			};
+		}
+	}
+	table(src) {
+		const cap = this.rules.block.table.exec(src);
+		if (!cap) return;
+		if (!/[:|]/.test(cap[2])) return;
+		const headers = splitCells$1(cap[1]);
+		const aligns = cap[2].replace(/^\||\| *$/g, "").split("|");
+		const rows = cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, "").split("\n") : [];
+		const item = {
+			type: "table",
+			raw: cap[0],
+			header: [],
+			align: [],
+			rows: []
+		};
+		if (headers.length !== aligns.length) return;
+		for (const align of aligns) if (/^ *-+: *$/.test(align)) item.align.push("right");
+		else if (/^ *:-+: *$/.test(align)) item.align.push("center");
+		else if (/^ *:-+ *$/.test(align)) item.align.push("left");
+		else item.align.push(null);
+		for (const header of headers) item.header.push({
+			text: header,
+			tokens: this.lexer.inline(header)
+		});
+		for (const row of rows) item.rows.push(splitCells$1(row, item.header.length).map((cell) => {
+			return {
+				text: cell,
+				tokens: this.lexer.inline(cell)
+			};
+		}));
+		return item;
+	}
+	lheading(src) {
+		const cap = this.rules.block.lheading.exec(src);
+		if (cap) return {
+			type: "heading",
+			raw: cap[0],
+			depth: cap[2].charAt(0) === "=" ? 1 : 2,
+			text: cap[1],
+			tokens: this.lexer.inline(cap[1])
+		};
+	}
+	paragraph(src) {
+		const cap = this.rules.block.paragraph.exec(src);
+		if (cap) {
+			const text = cap[1].charAt(cap[1].length - 1) === "\n" ? cap[1].slice(0, -1) : cap[1];
+			return {
+				type: "paragraph",
+				raw: cap[0],
+				text,
+				tokens: this.lexer.inline(text)
+			};
+		}
+	}
+	text(src) {
+		const cap = this.rules.block.text.exec(src);
+		if (cap) return {
+			type: "text",
+			raw: cap[0],
+			text: cap[0],
+			tokens: this.lexer.inline(cap[0])
+		};
+	}
+	escape(src) {
+		const cap = this.rules.inline.escape.exec(src);
+		if (cap) return {
+			type: "escape",
+			raw: cap[0],
+			text: escape$1(cap[1])
+		};
+	}
+	tag(src) {
+		const cap = this.rules.inline.tag.exec(src);
+		if (cap) {
+			if (!this.lexer.state.inLink && /^<a /i.test(cap[0])) this.lexer.state.inLink = true;
+			else if (this.lexer.state.inLink && /^<\/a>/i.test(cap[0])) this.lexer.state.inLink = false;
+			if (!this.lexer.state.inRawBlock && /^<(pre|code|kbd|script)(\s|>)/i.test(cap[0])) this.lexer.state.inRawBlock = true;
+			else if (this.lexer.state.inRawBlock && /^<\/(pre|code|kbd|script)(\s|>)/i.test(cap[0])) this.lexer.state.inRawBlock = false;
+			return {
+				type: "html",
+				raw: cap[0],
+				inLink: this.lexer.state.inLink,
+				inRawBlock: this.lexer.state.inRawBlock,
+				block: false,
+				text: cap[0]
+			};
+		}
+	}
+	link(src) {
+		const cap = this.rules.inline.link.exec(src);
+		if (cap) {
+			const trimmedUrl = cap[2].trim();
+			if (!this.options.pedantic && /^</.test(trimmedUrl)) {
+				if (!/>$/.test(trimmedUrl)) return;
+				const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), "\\");
+				if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) return;
+			} else {
+				const lastParenIndex = findClosingBracket(cap[2], "()");
+				if (lastParenIndex > -1) {
+					const linkLen = (cap[0].indexOf("!") === 0 ? 5 : 4) + cap[1].length + lastParenIndex;
+					cap[2] = cap[2].substring(0, lastParenIndex);
+					cap[0] = cap[0].substring(0, linkLen).trim();
+					cap[3] = "";
+				}
+			}
+			let href = cap[2];
+			let title = "";
+			if (this.options.pedantic) {
+				const link = /^([^'"]*[^\s])\s+(['"])(.*)\2/.exec(href);
+				if (link) {
+					href = link[1];
+					title = link[3];
+				}
+			} else title = cap[3] ? cap[3].slice(1, -1) : "";
+			href = href.trim();
+			if (/^</.test(href)) if (this.options.pedantic && !/>$/.test(trimmedUrl)) href = href.slice(1);
+			else href = href.slice(1, -1);
+			return outputLink(cap, {
+				href: href ? href.replace(this.rules.inline.anyPunctuation, "$1") : href,
+				title: title ? title.replace(this.rules.inline.anyPunctuation, "$1") : title
+			}, cap[0], this.lexer);
+		}
+	}
+	reflink(src, links) {
+		let cap;
+		if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
+			const link = links[(cap[2] || cap[1]).replace(/\s+/g, " ").toLowerCase()];
+			if (!link) {
+				const text = cap[0].charAt(0);
+				return {
+					type: "text",
+					raw: text,
+					text
+				};
+			}
+			return outputLink(cap, link, cap[0], this.lexer);
+		}
+	}
+	emStrong(src, maskedSrc, prevChar = "") {
+		let match = this.rules.inline.emStrongLDelim.exec(src);
+		if (!match) return;
+		if (match[3] && prevChar.match(/[\p{L}\p{N}]/u)) return;
+		if (!(match[1] || match[2] || "") || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
+			const lLength = [...match[0]].length - 1;
+			let rDelim;
+			let rLength;
+			let delimTotal = lLength;
+			let midDelimTotal = 0;
+			const endReg = match[0][0] === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+			endReg.lastIndex = 0;
+			maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
+			while ((match = endReg.exec(maskedSrc)) != null) {
+				rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
+				if (!rDelim) continue;
+				rLength = [...rDelim].length;
+				if (match[3] || match[4]) {
+					delimTotal += rLength;
+					continue;
+				} else if (match[5] || match[6]) {
+					if (lLength % 3 && !((lLength + rLength) % 3)) {
+						midDelimTotal += rLength;
+						continue;
+					}
+				}
+				delimTotal -= rLength;
+				if (delimTotal > 0) continue;
+				rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
+				const lastCharLength = [...match[0]][0].length;
+				const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);
+				if (Math.min(lLength, rLength) % 2) {
+					const text = raw.slice(1, -1);
+					return {
+						type: "em",
+						raw,
+						text,
+						tokens: this.lexer.inlineTokens(text)
+					};
+				}
+				const text = raw.slice(2, -2);
+				return {
+					type: "strong",
+					raw,
+					text,
+					tokens: this.lexer.inlineTokens(text)
+				};
+			}
+		}
+	}
+	codespan(src) {
+		const cap = this.rules.inline.code.exec(src);
+		if (cap) {
+			let text = cap[2].replace(/\n/g, " ");
+			const hasNonSpaceChars = /[^ ]/.test(text);
+			const hasSpaceCharsOnBothEnds = /^ /.test(text) && / $/.test(text);
+			if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) text = text.substring(1, text.length - 1);
+			text = escape$1(text, true);
+			return {
+				type: "codespan",
+				raw: cap[0],
+				text
+			};
+		}
+	}
+	br(src) {
+		const cap = this.rules.inline.br.exec(src);
+		if (cap) return {
+			type: "br",
+			raw: cap[0]
+		};
+	}
+	del(src) {
+		const cap = this.rules.inline.del.exec(src);
+		if (cap) return {
+			type: "del",
+			raw: cap[0],
+			text: cap[2],
+			tokens: this.lexer.inlineTokens(cap[2])
+		};
+	}
+	autolink(src) {
+		const cap = this.rules.inline.autolink.exec(src);
+		if (cap) {
+			let text;
+			let href;
+			if (cap[2] === "@") {
+				text = escape$1(cap[1]);
+				href = "mailto:" + text;
+			} else {
+				text = escape$1(cap[1]);
+				href = text;
+			}
+			return {
+				type: "link",
+				raw: cap[0],
+				text,
+				href,
+				tokens: [{
+					type: "text",
+					raw: text,
+					text
+				}]
+			};
+		}
+	}
+	url(src) {
+		let cap;
+		if (cap = this.rules.inline.url.exec(src)) {
+			let text;
+			let href;
+			if (cap[2] === "@") {
+				text = escape$1(cap[0]);
+				href = "mailto:" + text;
+			} else {
+				let prevCapZero;
+				do {
+					prevCapZero = cap[0];
+					cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? "";
+				} while (prevCapZero !== cap[0]);
+				text = escape$1(cap[0]);
+				if (cap[1] === "www.") href = "http://" + cap[0];
+				else href = cap[0];
+			}
+			return {
+				type: "link",
+				raw: cap[0],
+				text,
+				href,
+				tokens: [{
+					type: "text",
+					raw: text,
+					text
+				}]
+			};
+		}
+	}
+	inlineText(src) {
+		const cap = this.rules.inline.text.exec(src);
+		if (cap) {
+			let text;
+			if (this.lexer.state.inRawBlock) text = cap[0];
+			else text = escape$1(cap[0]);
+			return {
+				type: "text",
+				raw: cap[0],
+				text
+			};
+		}
+	}
+};
+/**
+* Block-Level Grammar
+*/
+var newline = /^(?: *(?:\n|$))+/;
+var blockCode = /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/;
+var fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+var hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+var heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+var bullet = /(?:[*+-]|\d{1,9}[.)])/;
+var lheading = edit(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g, bullet).replace(/blockCode/g, / {4}/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).getRegex();
+var _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+var blockText = /^[^\n]+/;
+var _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+var def = edit(/^ {0,3}\[(label)\]: *(?:\n *)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n *)?| *\n *)(title))? *(?:\n+|$)/).replace("label", _blockLabel).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+var list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
+var _tag = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+var _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+var html = edit("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n *)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n *)+\\n|$))", "i").replace("comment", _comment).replace("tag", _tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+var paragraph = edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+/**
+* Normal Block Grammar
+*/
+var blockNormal = {
+	blockquote: edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", paragraph).getRegex(),
+	code: blockCode,
+	def,
+	fences,
+	heading,
+	hr,
+	html,
+	lheading,
+	list,
+	newline,
+	paragraph,
+	table: noopTest,
+	text: blockText
+};
+/**
+* GFM Block Grammar
+*/
+var gfmTable = edit("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", " {4}[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+var blockGfm = {
+	...blockNormal,
+	table: gfmTable,
+	paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", gfmTable).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex()
+};
+/**
+* Pedantic grammar (original John Gruber's loose markdown specification)
+*/
+var blockPedantic = {
+	...blockNormal,
+	html: edit("^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:\"[^\"]*\"|'[^']*'|\\s[^'\"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))").replace("comment", _comment).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
+	def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
+	heading: /^(#{1,6})(.*)(?:\n+|$)/,
+	fences: noopTest,
+	lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+	paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", lheading).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
+};
+/**
+* Inline-Level Grammar
+*/
+var escape = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+var inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+var br = /^( {2,}|\\)\n(?!\s*$)/;
+var inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+var _punctuation = "\\p{P}\\p{S}";
+var punctuation = edit(/^((?![*_])[\spunctuation])/, "u").replace(/punctuation/g, _punctuation).getRegex();
+var blockSkip = /\[[^[\]]*?\]\([^\(\)]*?\)|`[^`]*?`|<[^<>]*?>/g;
+var emStrongLDelim = edit(/^(?:\*+(?:((?!\*)[punct])|[^\s*]))|^_+(?:((?!_)[punct])|([^\s_]))/, "u").replace(/punct/g, _punctuation).getRegex();
+var emStrongRDelimAst = edit("^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)[punct](\\*+)(?=[\\s]|$)|[^punct\\s](\\*+)(?!\\*)(?=[punct\\s]|$)|(?!\\*)[punct\\s](\\*+)(?=[^punct\\s])|[\\s](\\*+)(?!\\*)(?=[punct])|(?!\\*)[punct](\\*+)(?!\\*)(?=[punct])|[^punct\\s](\\*+)(?=[^punct\\s])", "gu").replace(/punct/g, _punctuation).getRegex();
+var emStrongRDelimUnd = edit("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)[punct](_+)(?=[\\s]|$)|[^punct\\s](_+)(?!_)(?=[punct\\s]|$)|(?!_)[punct\\s](_+)(?=[^punct\\s])|[\\s](_+)(?!_)(?=[punct])|(?!_)[punct](_+)(?!_)(?=[punct])", "gu").replace(/punct/g, _punctuation).getRegex();
+var anyPunctuation = edit(/\\([punct])/, "gu").replace(/punct/g, _punctuation).getRegex();
+var autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+var _inlineComment = edit(_comment).replace("(?:-->|$)", "-->").getRegex();
+var tag = edit("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", _inlineComment).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+var _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+var link = edit(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace("label", _inlineLabel).replace("href", /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+var reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace("label", _inlineLabel).replace("ref", _blockLabel).getRegex();
+var nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace("ref", _blockLabel).getRegex();
+/**
+* Normal Inline Grammar
+*/
+var inlineNormal = {
+	_backpedal: noopTest,
+	anyPunctuation,
+	autolink,
+	blockSkip,
+	br,
+	code: inlineCode,
+	del: noopTest,
+	emStrongLDelim,
+	emStrongRDelimAst,
+	emStrongRDelimUnd,
+	escape,
+	link,
+	nolink,
+	punctuation,
+	reflink,
+	reflinkSearch: edit("reflink|nolink(?!\\()", "g").replace("reflink", reflink).replace("nolink", nolink).getRegex(),
+	tag,
+	text: inlineText,
+	url: noopTest
+};
+/**
+* Pedantic Inline Grammar
+*/
+var inlinePedantic = {
+	...inlineNormal,
+	link: edit(/^!?\[(label)\]\((.*?)\)/).replace("label", _inlineLabel).getRegex(),
+	reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", _inlineLabel).getRegex()
+};
+/**
+* GFM Inline Grammar
+*/
+var inlineGfm = {
+	...inlineNormal,
+	escape: edit(escape).replace("])", "~|])").getRegex(),
+	url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, "i").replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
+	_backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
+	del: /^(~~?)(?=[^\s~])([\s\S]*?[^\s~])\1(?=[^~]|$)/,
+	text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
+};
+/**
+* GFM + Line Breaks Inline Grammar
+*/
+var inlineBreaks = {
+	...inlineGfm,
+	br: edit(br).replace("{2,}", "*").getRegex(),
+	text: edit(inlineGfm.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex()
+};
+/**
+* exports
+*/
+var block = {
+	normal: blockNormal,
+	gfm: blockGfm,
+	pedantic: blockPedantic
+};
+var inline = {
+	normal: inlineNormal,
+	gfm: inlineGfm,
+	breaks: inlineBreaks,
+	pedantic: inlinePedantic
+};
+/**
+* Block Lexer
+*/
+var _Lexer = class _Lexer {
+	tokens;
+	options;
+	state;
+	tokenizer;
+	inlineQueue;
+	constructor(options) {
+		this.tokens = [];
+		this.tokens.links = Object.create(null);
+		this.options = options || _defaults;
+		this.options.tokenizer = this.options.tokenizer || new _Tokenizer();
+		this.tokenizer = this.options.tokenizer;
+		this.tokenizer.options = this.options;
+		this.tokenizer.lexer = this;
+		this.inlineQueue = [];
+		this.state = {
+			inLink: false,
+			inRawBlock: false,
+			top: true
+		};
+		const rules = {
+			block: block.normal,
+			inline: inline.normal
+		};
+		if (this.options.pedantic) {
+			rules.block = block.pedantic;
+			rules.inline = inline.pedantic;
+		} else if (this.options.gfm) {
+			rules.block = block.gfm;
+			if (this.options.breaks) rules.inline = inline.breaks;
+			else rules.inline = inline.gfm;
+		}
+		this.tokenizer.rules = rules;
+	}
+	/**
+	* Expose Rules
+	*/
+	static get rules() {
+		return {
+			block,
+			inline
+		};
+	}
+	/**
+	* Static Lex Method
+	*/
+	static lex(src, options) {
+		return new _Lexer(options).lex(src);
+	}
+	/**
+	* Static Lex Inline Method
+	*/
+	static lexInline(src, options) {
+		return new _Lexer(options).inlineTokens(src);
+	}
+	/**
+	* Preprocessing
+	*/
+	lex(src) {
+		src = src.replace(/\r\n|\r/g, "\n");
+		this.blockTokens(src, this.tokens);
+		for (let i = 0; i < this.inlineQueue.length; i++) {
+			const next = this.inlineQueue[i];
+			this.inlineTokens(next.src, next.tokens);
+		}
+		this.inlineQueue = [];
+		return this.tokens;
+	}
+	blockTokens(src, tokens = []) {
+		if (this.options.pedantic) src = src.replace(/\t/g, "    ").replace(/^ +$/gm, "");
+		else src = src.replace(/^( *)(\t+)/gm, (_, leading, tabs) => {
+			return leading + "    ".repeat(tabs.length);
+		});
+		let token;
+		let lastToken;
+		let cutSrc;
+		let lastParagraphClipped;
+		while (src) {
+			if (this.options.extensions && this.options.extensions.block && this.options.extensions.block.some((extTokenizer) => {
+				if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+					src = src.substring(token.raw.length);
+					tokens.push(token);
+					return true;
+				}
+				return false;
+			})) continue;
+			if (token = this.tokenizer.space(src)) {
+				src = src.substring(token.raw.length);
+				if (token.raw.length === 1 && tokens.length > 0) tokens[tokens.length - 1].raw += "\n";
+				else tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.code(src)) {
+				src = src.substring(token.raw.length);
+				lastToken = tokens[tokens.length - 1];
+				if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
+					lastToken.raw += "\n" + token.raw;
+					lastToken.text += "\n" + token.text;
+					this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+				} else tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.fences(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.heading(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.hr(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.blockquote(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.list(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.html(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.def(src)) {
+				src = src.substring(token.raw.length);
+				lastToken = tokens[tokens.length - 1];
+				if (lastToken && (lastToken.type === "paragraph" || lastToken.type === "text")) {
+					lastToken.raw += "\n" + token.raw;
+					lastToken.text += "\n" + token.raw;
+					this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+				} else if (!this.tokens.links[token.tag]) this.tokens.links[token.tag] = {
+					href: token.href,
+					title: token.title
+				};
+				continue;
+			}
+			if (token = this.tokenizer.table(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.lheading(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			cutSrc = src;
+			if (this.options.extensions && this.options.extensions.startBlock) {
+				let startIndex = Infinity;
+				const tempSrc = src.slice(1);
+				let tempStart;
+				this.options.extensions.startBlock.forEach((getStartIndex) => {
+					tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+					if (typeof tempStart === "number" && tempStart >= 0) startIndex = Math.min(startIndex, tempStart);
+				});
+				if (startIndex < Infinity && startIndex >= 0) cutSrc = src.substring(0, startIndex + 1);
+			}
+			if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
+				lastToken = tokens[tokens.length - 1];
+				if (lastParagraphClipped && lastToken.type === "paragraph") {
+					lastToken.raw += "\n" + token.raw;
+					lastToken.text += "\n" + token.text;
+					this.inlineQueue.pop();
+					this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+				} else tokens.push(token);
+				lastParagraphClipped = cutSrc.length !== src.length;
+				src = src.substring(token.raw.length);
+				continue;
+			}
+			if (token = this.tokenizer.text(src)) {
+				src = src.substring(token.raw.length);
+				lastToken = tokens[tokens.length - 1];
+				if (lastToken && lastToken.type === "text") {
+					lastToken.raw += "\n" + token.raw;
+					lastToken.text += "\n" + token.text;
+					this.inlineQueue.pop();
+					this.inlineQueue[this.inlineQueue.length - 1].src = lastToken.text;
+				} else tokens.push(token);
+				continue;
+			}
+			if (src) {
+				const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+				if (this.options.silent) {
+					console.error(errMsg);
+					break;
+				} else throw new Error(errMsg);
+			}
+		}
+		this.state.top = true;
+		return tokens;
+	}
+	inline(src, tokens = []) {
+		this.inlineQueue.push({
+			src,
+			tokens
+		});
+		return tokens;
+	}
+	/**
+	* Lexing/Compiling
+	*/
+	inlineTokens(src, tokens = []) {
+		let token;
+		let lastToken;
+		let cutSrc;
+		let maskedSrc = src;
+		let match;
+		let keepPrevChar;
+		let prevChar;
+		if (this.tokens.links) {
+			const links = Object.keys(this.tokens.links);
+			if (links.length > 0) {
+				while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) if (links.includes(match[0].slice(match[0].lastIndexOf("[") + 1, -1))) maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
+			}
+		}
+		while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) maskedSrc = maskedSrc.slice(0, match.index) + "[" + "a".repeat(match[0].length - 2) + "]" + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
+		while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) maskedSrc = maskedSrc.slice(0, match.index) + "++" + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
+		while (src) {
+			if (!keepPrevChar) prevChar = "";
+			keepPrevChar = false;
+			if (this.options.extensions && this.options.extensions.inline && this.options.extensions.inline.some((extTokenizer) => {
+				if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
+					src = src.substring(token.raw.length);
+					tokens.push(token);
+					return true;
+				}
+				return false;
+			})) continue;
+			if (token = this.tokenizer.escape(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.tag(src)) {
+				src = src.substring(token.raw.length);
+				lastToken = tokens[tokens.length - 1];
+				if (lastToken && token.type === "text" && lastToken.type === "text") {
+					lastToken.raw += token.raw;
+					lastToken.text += token.text;
+				} else tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.link(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.reflink(src, this.tokens.links)) {
+				src = src.substring(token.raw.length);
+				lastToken = tokens[tokens.length - 1];
+				if (lastToken && token.type === "text" && lastToken.type === "text") {
+					lastToken.raw += token.raw;
+					lastToken.text += token.text;
+				} else tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.codespan(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.br(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.del(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (token = this.tokenizer.autolink(src)) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			if (!this.state.inLink && (token = this.tokenizer.url(src))) {
+				src = src.substring(token.raw.length);
+				tokens.push(token);
+				continue;
+			}
+			cutSrc = src;
+			if (this.options.extensions && this.options.extensions.startInline) {
+				let startIndex = Infinity;
+				const tempSrc = src.slice(1);
+				let tempStart;
+				this.options.extensions.startInline.forEach((getStartIndex) => {
+					tempStart = getStartIndex.call({ lexer: this }, tempSrc);
+					if (typeof tempStart === "number" && tempStart >= 0) startIndex = Math.min(startIndex, tempStart);
+				});
+				if (startIndex < Infinity && startIndex >= 0) cutSrc = src.substring(0, startIndex + 1);
+			}
+			if (token = this.tokenizer.inlineText(cutSrc)) {
+				src = src.substring(token.raw.length);
+				if (token.raw.slice(-1) !== "_") prevChar = token.raw.slice(-1);
+				keepPrevChar = true;
+				lastToken = tokens[tokens.length - 1];
+				if (lastToken && lastToken.type === "text") {
+					lastToken.raw += token.raw;
+					lastToken.text += token.text;
+				} else tokens.push(token);
+				continue;
+			}
+			if (src) {
+				const errMsg = "Infinite loop on byte: " + src.charCodeAt(0);
+				if (this.options.silent) {
+					console.error(errMsg);
+					break;
+				} else throw new Error(errMsg);
+			}
+		}
+		return tokens;
+	}
+};
+/**
+* Renderer
+*/
+var _Renderer = class {
+	options;
+	constructor(options) {
+		this.options = options || _defaults;
+	}
+	code(code, infostring, escaped) {
+		const lang = (infostring || "").match(/^\S*/)?.[0];
+		code = code.replace(/\n$/, "") + "\n";
+		if (!lang) return "<pre><code>" + (escaped ? code : escape$1(code, true)) + "</code></pre>\n";
+		return "<pre><code class=\"language-" + escape$1(lang) + "\">" + (escaped ? code : escape$1(code, true)) + "</code></pre>\n";
+	}
+	blockquote(quote) {
+		return `<blockquote>\n${quote}</blockquote>\n`;
+	}
+	html(html, block) {
+		return html;
+	}
+	heading(text, level, raw) {
+		return `<h${level}>${text}</h${level}>\n`;
+	}
+	hr() {
+		return "<hr>\n";
+	}
+	list(body, ordered, start) {
+		const type = ordered ? "ol" : "ul";
+		const startatt = ordered && start !== 1 ? " start=\"" + start + "\"" : "";
+		return "<" + type + startatt + ">\n" + body + "</" + type + ">\n";
+	}
+	listitem(text, task, checked) {
+		return `<li>${text}</li>\n`;
+	}
+	checkbox(checked) {
+		return "<input " + (checked ? "checked=\"\" " : "") + "disabled=\"\" type=\"checkbox\">";
+	}
+	paragraph(text) {
+		return `<p>${text}</p>\n`;
+	}
+	table(header, body) {
+		if (body) body = `<tbody>${body}</tbody>`;
+		return "<table>\n<thead>\n" + header + "</thead>\n" + body + "</table>\n";
+	}
+	tablerow(content) {
+		return `<tr>\n${content}</tr>\n`;
+	}
+	tablecell(content, flags) {
+		const type = flags.header ? "th" : "td";
+		return (flags.align ? `<${type} align="${flags.align}">` : `<${type}>`) + content + `</${type}>\n`;
+	}
+	/**
+	* span level renderer
+	*/
+	strong(text) {
+		return `<strong>${text}</strong>`;
+	}
+	em(text) {
+		return `<em>${text}</em>`;
+	}
+	codespan(text) {
+		return `<code>${text}</code>`;
+	}
+	br() {
+		return "<br>";
+	}
+	del(text) {
+		return `<del>${text}</del>`;
+	}
+	link(href, title, text) {
+		const cleanHref = cleanUrl(href);
+		if (cleanHref === null) return text;
+		href = cleanHref;
+		let out = "<a href=\"" + href + "\"";
+		if (title) out += " title=\"" + title + "\"";
+		out += ">" + text + "</a>";
+		return out;
+	}
+	image(href, title, text) {
+		const cleanHref = cleanUrl(href);
+		if (cleanHref === null) return text;
+		href = cleanHref;
+		let out = `<img src="${href}" alt="${text}"`;
+		if (title) out += ` title="${title}"`;
+		out += ">";
+		return out;
+	}
+	text(text) {
+		return text;
+	}
+};
+/**
+* TextRenderer
+* returns only the textual part of the token
+*/
+var _TextRenderer = class {
+	strong(text) {
+		return text;
+	}
+	em(text) {
+		return text;
+	}
+	codespan(text) {
+		return text;
+	}
+	del(text) {
+		return text;
+	}
+	html(text) {
+		return text;
+	}
+	text(text) {
+		return text;
+	}
+	link(href, title, text) {
+		return "" + text;
+	}
+	image(href, title, text) {
+		return "" + text;
+	}
+	br() {
+		return "";
+	}
+};
+/**
+* Parsing & Compiling
+*/
+var _Parser = class _Parser {
+	options;
+	renderer;
+	textRenderer;
+	constructor(options) {
+		this.options = options || _defaults;
+		this.options.renderer = this.options.renderer || new _Renderer();
+		this.renderer = this.options.renderer;
+		this.renderer.options = this.options;
+		this.textRenderer = new _TextRenderer();
+	}
+	/**
+	* Static Parse Method
+	*/
+	static parse(tokens, options) {
+		return new _Parser(options).parse(tokens);
+	}
+	/**
+	* Static Parse Inline Method
+	*/
+	static parseInline(tokens, options) {
+		return new _Parser(options).parseInline(tokens);
+	}
+	/**
+	* Parse Loop
+	*/
+	parse(tokens, top = true) {
+		let out = "";
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+				const genericToken = token;
+				const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);
+				if (ret !== false || ![
+					"space",
+					"hr",
+					"heading",
+					"code",
+					"table",
+					"blockquote",
+					"list",
+					"html",
+					"paragraph",
+					"text"
+				].includes(genericToken.type)) {
+					out += ret || "";
+					continue;
+				}
+			}
+			switch (token.type) {
+				case "space": continue;
+				case "hr":
+					out += this.renderer.hr();
+					continue;
+				case "heading": {
+					const headingToken = token;
+					out += this.renderer.heading(this.parseInline(headingToken.tokens), headingToken.depth, unescape(this.parseInline(headingToken.tokens, this.textRenderer)));
+					continue;
+				}
+				case "code": {
+					const codeToken = token;
+					out += this.renderer.code(codeToken.text, codeToken.lang, !!codeToken.escaped);
+					continue;
+				}
+				case "table": {
+					const tableToken = token;
+					let header = "";
+					let cell = "";
+					for (let j = 0; j < tableToken.header.length; j++) cell += this.renderer.tablecell(this.parseInline(tableToken.header[j].tokens), {
+						header: true,
+						align: tableToken.align[j]
+					});
+					header += this.renderer.tablerow(cell);
+					let body = "";
+					for (let j = 0; j < tableToken.rows.length; j++) {
+						const row = tableToken.rows[j];
+						cell = "";
+						for (let k = 0; k < row.length; k++) cell += this.renderer.tablecell(this.parseInline(row[k].tokens), {
+							header: false,
+							align: tableToken.align[k]
+						});
+						body += this.renderer.tablerow(cell);
+					}
+					out += this.renderer.table(header, body);
+					continue;
+				}
+				case "blockquote": {
+					const blockquoteToken = token;
+					const body = this.parse(blockquoteToken.tokens);
+					out += this.renderer.blockquote(body);
+					continue;
+				}
+				case "list": {
+					const listToken = token;
+					const ordered = listToken.ordered;
+					const start = listToken.start;
+					const loose = listToken.loose;
+					let body = "";
+					for (let j = 0; j < listToken.items.length; j++) {
+						const item = listToken.items[j];
+						const checked = item.checked;
+						const task = item.task;
+						let itemBody = "";
+						if (item.task) {
+							const checkbox = this.renderer.checkbox(!!checked);
+							if (loose) if (item.tokens.length > 0 && item.tokens[0].type === "paragraph") {
+								item.tokens[0].text = checkbox + " " + item.tokens[0].text;
+								if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") item.tokens[0].tokens[0].text = checkbox + " " + item.tokens[0].tokens[0].text;
+							} else item.tokens.unshift({
+								type: "text",
+								text: checkbox + " "
+							});
+							else itemBody += checkbox + " ";
+						}
+						itemBody += this.parse(item.tokens, loose);
+						body += this.renderer.listitem(itemBody, task, !!checked);
+					}
+					out += this.renderer.list(body, ordered, start);
+					continue;
+				}
+				case "html": {
+					const htmlToken = token;
+					out += this.renderer.html(htmlToken.text, htmlToken.block);
+					continue;
+				}
+				case "paragraph": {
+					const paragraphToken = token;
+					out += this.renderer.paragraph(this.parseInline(paragraphToken.tokens));
+					continue;
+				}
+				case "text": {
+					let textToken = token;
+					let body = textToken.tokens ? this.parseInline(textToken.tokens) : textToken.text;
+					while (i + 1 < tokens.length && tokens[i + 1].type === "text") {
+						textToken = tokens[++i];
+						body += "\n" + (textToken.tokens ? this.parseInline(textToken.tokens) : textToken.text);
+					}
+					out += top ? this.renderer.paragraph(body) : body;
+					continue;
+				}
+				default: {
+					const errMsg = "Token with \"" + token.type + "\" type was not found.";
+					if (this.options.silent) {
+						console.error(errMsg);
+						return "";
+					} else throw new Error(errMsg);
+				}
+			}
+		}
+		return out;
+	}
+	/**
+	* Parse Inline Tokens
+	*/
+	parseInline(tokens, renderer) {
+		renderer = renderer || this.renderer;
+		let out = "";
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
+				const ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
+				if (ret !== false || ![
+					"escape",
+					"html",
+					"link",
+					"image",
+					"strong",
+					"em",
+					"codespan",
+					"br",
+					"del",
+					"text"
+				].includes(token.type)) {
+					out += ret || "";
+					continue;
+				}
+			}
+			switch (token.type) {
+				case "escape": {
+					const escapeToken = token;
+					out += renderer.text(escapeToken.text);
+					break;
+				}
+				case "html": {
+					const tagToken = token;
+					out += renderer.html(tagToken.text);
+					break;
+				}
+				case "link": {
+					const linkToken = token;
+					out += renderer.link(linkToken.href, linkToken.title, this.parseInline(linkToken.tokens, renderer));
+					break;
+				}
+				case "image": {
+					const imageToken = token;
+					out += renderer.image(imageToken.href, imageToken.title, imageToken.text);
+					break;
+				}
+				case "strong": {
+					const strongToken = token;
+					out += renderer.strong(this.parseInline(strongToken.tokens, renderer));
+					break;
+				}
+				case "em": {
+					const emToken = token;
+					out += renderer.em(this.parseInline(emToken.tokens, renderer));
+					break;
+				}
+				case "codespan": {
+					const codespanToken = token;
+					out += renderer.codespan(codespanToken.text);
+					break;
+				}
+				case "br":
+					out += renderer.br();
+					break;
+				case "del": {
+					const delToken = token;
+					out += renderer.del(this.parseInline(delToken.tokens, renderer));
+					break;
+				}
+				case "text": {
+					const textToken = token;
+					out += renderer.text(textToken.text);
+					break;
+				}
+				default: {
+					const errMsg = "Token with \"" + token.type + "\" type was not found.";
+					if (this.options.silent) {
+						console.error(errMsg);
+						return "";
+					} else throw new Error(errMsg);
+				}
+			}
+		}
+		return out;
+	}
+};
+var _Hooks = class {
+	options;
+	constructor(options) {
+		this.options = options || _defaults;
+	}
+	static passThroughHooks = new Set([
+		"preprocess",
+		"postprocess",
+		"processAllTokens"
+	]);
+	/**
+	* Process markdown before marked
+	*/
+	preprocess(markdown) {
+		return markdown;
+	}
+	/**
+	* Process HTML after marked is finished
+	*/
+	postprocess(html) {
+		return html;
+	}
+	/**
+	* Process all tokens before walk tokens
+	*/
+	processAllTokens(tokens) {
+		return tokens;
+	}
+};
+var Marked = class {
+	defaults = _getDefaults();
+	options = this.setOptions;
+	parse = this.#parseMarkdown(_Lexer.lex, _Parser.parse);
+	parseInline = this.#parseMarkdown(_Lexer.lexInline, _Parser.parseInline);
+	Parser = _Parser;
+	Renderer = _Renderer;
+	TextRenderer = _TextRenderer;
+	Lexer = _Lexer;
+	Tokenizer = _Tokenizer;
+	Hooks = _Hooks;
+	constructor(...args) {
+		this.use(...args);
+	}
+	/**
+	* Run callback for every token
+	*/
+	walkTokens(tokens, callback) {
+		let values = [];
+		for (const token of tokens) {
+			values = values.concat(callback.call(this, token));
+			switch (token.type) {
+				case "table": {
+					const tableToken = token;
+					for (const cell of tableToken.header) values = values.concat(this.walkTokens(cell.tokens, callback));
+					for (const row of tableToken.rows) for (const cell of row) values = values.concat(this.walkTokens(cell.tokens, callback));
+					break;
+				}
+				case "list": {
+					const listToken = token;
+					values = values.concat(this.walkTokens(listToken.items, callback));
+					break;
+				}
+				default: {
+					const genericToken = token;
+					if (this.defaults.extensions?.childTokens?.[genericToken.type]) this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {
+						const tokens = genericToken[childTokens].flat(Infinity);
+						values = values.concat(this.walkTokens(tokens, callback));
+					});
+					else if (genericToken.tokens) values = values.concat(this.walkTokens(genericToken.tokens, callback));
+				}
+			}
+		}
+		return values;
+	}
+	use(...args) {
+		const extensions = this.defaults.extensions || {
+			renderers: {},
+			childTokens: {}
+		};
+		args.forEach((pack) => {
+			const opts = { ...pack };
+			opts.async = this.defaults.async || opts.async || false;
+			if (pack.extensions) {
+				pack.extensions.forEach((ext) => {
+					if (!ext.name) throw new Error("extension name required");
+					if ("renderer" in ext) {
+						const prevRenderer = extensions.renderers[ext.name];
+						if (prevRenderer) extensions.renderers[ext.name] = function(...args) {
+							let ret = ext.renderer.apply(this, args);
+							if (ret === false) ret = prevRenderer.apply(this, args);
+							return ret;
+						};
+						else extensions.renderers[ext.name] = ext.renderer;
+					}
+					if ("tokenizer" in ext) {
+						if (!ext.level || ext.level !== "block" && ext.level !== "inline") throw new Error("extension level must be 'block' or 'inline'");
+						const extLevel = extensions[ext.level];
+						if (extLevel) extLevel.unshift(ext.tokenizer);
+						else extensions[ext.level] = [ext.tokenizer];
+						if (ext.start) {
+							if (ext.level === "block") if (extensions.startBlock) extensions.startBlock.push(ext.start);
+							else extensions.startBlock = [ext.start];
+							else if (ext.level === "inline") if (extensions.startInline) extensions.startInline.push(ext.start);
+							else extensions.startInline = [ext.start];
+						}
+					}
+					if ("childTokens" in ext && ext.childTokens) extensions.childTokens[ext.name] = ext.childTokens;
+				});
+				opts.extensions = extensions;
+			}
+			if (pack.renderer) {
+				const renderer = this.defaults.renderer || new _Renderer(this.defaults);
+				for (const prop in pack.renderer) {
+					if (!(prop in renderer)) throw new Error(`renderer '${prop}' does not exist`);
+					if (prop === "options") continue;
+					const rendererProp = prop;
+					const rendererFunc = pack.renderer[rendererProp];
+					const prevRenderer = renderer[rendererProp];
+					renderer[rendererProp] = (...args) => {
+						let ret = rendererFunc.apply(renderer, args);
+						if (ret === false) ret = prevRenderer.apply(renderer, args);
+						return ret || "";
+					};
+				}
+				opts.renderer = renderer;
+			}
+			if (pack.tokenizer) {
+				const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
+				for (const prop in pack.tokenizer) {
+					if (!(prop in tokenizer)) throw new Error(`tokenizer '${prop}' does not exist`);
+					if ([
+						"options",
+						"rules",
+						"lexer"
+					].includes(prop)) continue;
+					const tokenizerProp = prop;
+					const tokenizerFunc = pack.tokenizer[tokenizerProp];
+					const prevTokenizer = tokenizer[tokenizerProp];
+					tokenizer[tokenizerProp] = (...args) => {
+						let ret = tokenizerFunc.apply(tokenizer, args);
+						if (ret === false) ret = prevTokenizer.apply(tokenizer, args);
+						return ret;
+					};
+				}
+				opts.tokenizer = tokenizer;
+			}
+			if (pack.hooks) {
+				const hooks = this.defaults.hooks || new _Hooks();
+				for (const prop in pack.hooks) {
+					if (!(prop in hooks)) throw new Error(`hook '${prop}' does not exist`);
+					if (prop === "options") continue;
+					const hooksProp = prop;
+					const hooksFunc = pack.hooks[hooksProp];
+					const prevHook = hooks[hooksProp];
+					if (_Hooks.passThroughHooks.has(prop)) hooks[hooksProp] = (arg) => {
+						if (this.defaults.async) return Promise.resolve(hooksFunc.call(hooks, arg)).then((ret) => {
+							return prevHook.call(hooks, ret);
+						});
+						const ret = hooksFunc.call(hooks, arg);
+						return prevHook.call(hooks, ret);
+					};
+					else hooks[hooksProp] = (...args) => {
+						let ret = hooksFunc.apply(hooks, args);
+						if (ret === false) ret = prevHook.apply(hooks, args);
+						return ret;
+					};
+				}
+				opts.hooks = hooks;
+			}
+			if (pack.walkTokens) {
+				const walkTokens = this.defaults.walkTokens;
+				const packWalktokens = pack.walkTokens;
+				opts.walkTokens = function(token) {
+					let values = [];
+					values.push(packWalktokens.call(this, token));
+					if (walkTokens) values = values.concat(walkTokens.call(this, token));
+					return values;
+				};
+			}
+			this.defaults = {
+				...this.defaults,
+				...opts
+			};
+		});
+		return this;
+	}
+	setOptions(opt) {
+		this.defaults = {
+			...this.defaults,
+			...opt
+		};
+		return this;
+	}
+	lexer(src, options) {
+		return _Lexer.lex(src, options ?? this.defaults);
+	}
+	parser(tokens, options) {
+		return _Parser.parse(tokens, options ?? this.defaults);
+	}
+	#parseMarkdown(lexer, parser) {
+		return (src, options) => {
+			const origOpt = { ...options };
+			const opt = {
+				...this.defaults,
+				...origOpt
+			};
+			if (this.defaults.async === true && origOpt.async === false) {
+				if (!opt.silent) console.warn("marked(): The async option was set to true by an extension. The async: false option sent to parse will be ignored.");
+				opt.async = true;
+			}
+			const throwError = this.#onError(!!opt.silent, !!opt.async);
+			if (typeof src === "undefined" || src === null) return throwError(/* @__PURE__ */ new Error("marked(): input parameter is undefined or null"));
+			if (typeof src !== "string") return throwError(/* @__PURE__ */ new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"));
+			if (opt.hooks) opt.hooks.options = opt;
+			if (opt.async) return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src) => lexer(src, opt)).then((tokens) => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens).then((tokens) => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser(tokens, opt)).then((html) => opt.hooks ? opt.hooks.postprocess(html) : html).catch(throwError);
+			try {
+				if (opt.hooks) src = opt.hooks.preprocess(src);
+				let tokens = lexer(src, opt);
+				if (opt.hooks) tokens = opt.hooks.processAllTokens(tokens);
+				if (opt.walkTokens) this.walkTokens(tokens, opt.walkTokens);
+				let html = parser(tokens, opt);
+				if (opt.hooks) html = opt.hooks.postprocess(html);
+				return html;
+			} catch (e) {
+				return throwError(e);
+			}
+		};
+	}
+	#onError(silent, async) {
+		return (e) => {
+			e.message += "\nPlease report this to https://github.com/markedjs/marked.";
+			if (silent) {
+				const msg = "<p>An error occurred:</p><pre>" + escape$1(e.message + "", true) + "</pre>";
+				if (async) return Promise.resolve(msg);
+				return msg;
+			}
+			if (async) return Promise.reject(e);
+			throw e;
+		};
+	}
+};
+var markedInstance = new Marked();
+function marked(src, opt) {
+	return markedInstance.parse(src, opt);
+}
+/**
+* Sets the default options.
+*
+* @param options Hash of options
+*/
+marked.options = marked.setOptions = function(options) {
+	markedInstance.setOptions(options);
+	marked.defaults = markedInstance.defaults;
+	changeDefaults(marked.defaults);
+	return marked;
+};
+/**
+* Gets the original marked default options.
+*/
+marked.getDefaults = _getDefaults;
+marked.defaults = _defaults;
+/**
+* Use Extension
+*/
+marked.use = function(...args) {
+	markedInstance.use(...args);
+	marked.defaults = markedInstance.defaults;
+	changeDefaults(marked.defaults);
+	return marked;
+};
+/**
+* Run callback for every token
+*/
+marked.walkTokens = function(tokens, callback) {
+	return markedInstance.walkTokens(tokens, callback);
+};
+/**
+* Compiles markdown to HTML without enclosing `p` tag.
+*
+* @param src String of markdown source to be compiled
+* @param options Hash of options
+* @return String of compiled HTML
+*/
+marked.parseInline = markedInstance.parseInline;
+/**
+* Expose
+*/
+marked.Parser = _Parser;
+marked.parser = _Parser.parse;
+marked.Renderer = _Renderer;
+marked.TextRenderer = _TextRenderer;
+marked.Lexer = _Lexer;
+marked.lexer = _Lexer.lex;
+marked.Tokenizer = _Tokenizer;
+marked.Hooks = _Hooks;
+marked.parse = marked;
+marked.options;
+marked.setOptions;
+marked.use;
+marked.walkTokens;
+marked.parseInline;
+_Parser.parse;
+_Lexer.lex;
+//#endregion
+//#region ../../node_modules/.pnpm/marked-alert@2.1.2_marked@12.0.2/node_modules/marked-alert/dist/index.js
+var d = [
+	{
+		type: "note",
+		icon: "<svg class=\"octicon octicon-info mr-2\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z\"></path></svg>"
+	},
+	{
+		type: "tip",
+		icon: "<svg class=\"octicon octicon-light-bulb mr-2\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M8 1.5c-2.363 0-4 1.69-4 3.75 0 .984.424 1.625.984 2.304l.214.253c.223.264.47.556.673.848.284.411.537.896.621 1.49a.75.75 0 0 1-1.484.211c-.04-.282-.163-.547-.37-.847a8.456 8.456 0 0 0-.542-.68c-.084-.1-.173-.205-.268-.32C3.201 7.75 2.5 6.766 2.5 5.25 2.5 2.31 4.863 0 8 0s5.5 2.31 5.5 5.25c0 1.516-.701 2.5-1.328 3.259-.095.115-.184.22-.268.319-.207.245-.383.453-.541.681-.208.3-.33.565-.37.847a.751.751 0 0 1-1.485-.212c.084-.593.337-1.078.621-1.489.203-.292.45-.584.673-.848.075-.088.147-.173.213-.253.561-.679.985-1.32.985-2.304 0-2.06-1.637-3.75-4-3.75ZM5.75 12h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1 0-1.5ZM6 15.25a.75.75 0 0 1 .75-.75h2.5a.75.75 0 0 1 0 1.5h-2.5a.75.75 0 0 1-.75-.75Z\"></path></svg>"
+	},
+	{
+		type: "important",
+		icon: "<svg class=\"octicon octicon-report mr-2\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0 1 14.25 13H8.06l-2.573 2.573A1.458 1.458 0 0 1 3 14.543V13H1.75A1.75 1.75 0 0 1 0 11.25Zm1.75-.25a.25.25 0 0 0-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25Zm7 2.25v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 9a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z\"></path></svg>"
+	},
+	{
+		type: "warning",
+		icon: "<svg class=\"octicon octicon-alert mr-2\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z\"></path></svg>"
+	},
+	{
+		type: "caution",
+		icon: "<svg class=\"octicon octicon-stop mr-2\" viewBox=\"0 0 16 16\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M4.47.22A.749.749 0 0 1 5 0h6c.199 0 .389.079.53.22l4.25 4.25c.141.14.22.331.22.53v6a.749.749 0 0 1-.22.53l-4.25 4.25A.749.749 0 0 1 11 16H5a.749.749 0 0 1-.53-.22L.22 11.53A.749.749 0 0 1 0 11V5c0-.199.079-.389.22-.53Zm.84 1.28L1.5 5.31v5.38l3.81 3.81h5.38l3.81-3.81V5.31L10.69 1.5ZM8 4a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 8 4Zm0 8a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z\"></path></svg>"
+	}
+];
+function m(a) {
+	return a.length ? Object.values([...d, ...a].reduce((i, s) => (i[s.type] = s, i), {})) : d;
+}
+function u(a) {
+	return `^(?:\\[!${a.toUpperCase()}])\\s*?
+*`;
+}
+function x(a) {
+	return a.slice(0, 1).toUpperCase() + a.slice(1).toLowerCase();
+}
+function A$1(a = {}) {
+	const { className: i = "markdown-alert", variants: s = [] } = a;
+	const g = m(s);
+	return {
+		walkTokens(t) {
+			var e;
+			var h;
+			var p;
+			var v;
+			if (t.type !== "blockquote") return;
+			const c = g.find(({ type: n }) => new RegExp(u(n)).test(t.text));
+			if (c) {
+				const { type: n, icon: w, title: Z = x(n), titleClassName: f = `${i}-title` } = c;
+				const o = new RegExp(u(n));
+				Object.assign(t, {
+					type: "alert",
+					meta: {
+						className: i,
+						variant: n,
+						icon: w,
+						title: Z,
+						titleClassName: f
+					}
+				});
+				const r = (e = t.tokens) == null ? void 0 : e[0];
+				if ((h = r.raw) == null ? void 0 : h.replace(o, "").trim()) {
+					const l = r.tokens[0];
+					Object.assign(l, {
+						raw: l.raw.replace(o, ""),
+						text: l.text.replace(o, "")
+					}), ((p = r.tokens[1]) == null ? void 0 : p.type) === "br" && r.tokens.splice(1, 1);
+				} else (v = t.tokens) == null || v.shift();
+			}
+		},
+		extensions: [{
+			name: "alert",
+			level: "block",
+			renderer({ meta: t, tokens: c = [] }) {
+				let e = `<div class="${t.className} ${t.className}-${t.variant}">
+`;
+				return e += `<p class="${t.titleClassName}">`, e += t.icon, e += t.title, e += `</p>
+`, e += this.parser.parse(c), e += `</div>
+`, e;
+			}
+		}]
+	};
+}
+__name(A$1, "A");
+//#endregion
+//#region ../../node_modules/.pnpm/marked-footnote@1.4.0_marked@12.0.2/node_modules/marked-footnote/dist/index.js
+function R(e, d) {
+	const l = {
+		type: "footnotes",
+		raw: d,
+		rawItems: [],
+		items: []
+	};
+	return {
+		name: "footnote",
+		level: "block",
+		childTokens: ["content"],
+		tokenizer(c) {
+			e.hasFootnotes || (this.lexer.tokens.push(l), e.tokens = this.lexer.tokens, e.hasFootnotes = !0, l.rawItems = [], l.items = []);
+			const a = /^\[\^([^\]\n]+)\]:(?:[ \t]+|[\n]*?|$)([^\n]*?(?:\n|$)(?:\n*?[ ]{4,}[^\n]*)*)/.exec(c);
+			if (a) {
+				const [i, f, s = ""] = a;
+				let n = s.split(`
+`).reduce((r, p) => r + `
+` + p.replace(/^(?:[ ]{4}|[\t])/, ""), "");
+				const t = n.trimEnd().split(`
+`).pop();
+				n += t && /^[ \t]*?[>\-*][ ]|[`]{3,}$|^[ \t]*?[|].+[|]$/.test(t) ? `
+
+` : "";
+				const o = {
+					type: "footnote",
+					raw: i,
+					label: f,
+					refs: [],
+					content: this.lexer.blockTokens(n)
+				};
+				return l.rawItems.push(o), o;
+			}
+		},
+		renderer() {
+			return "";
+		}
+	};
+}
+function T(e) {
+	return e.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function A(e, d = !1, l = !1) {
+	let c = 0;
+	return {
+		name: "footnoteRef",
+		level: "inline",
+		tokenizer(a) {
+			const i = /^\[\^([^\]\n]+)\]/.exec(a);
+			if (i) {
+				const [f, s] = i;
+				const n = this.lexer.tokens[0];
+				const t = n.rawItems.filter((u) => u.label === s);
+				if (!t.length) return;
+				const o = t[0];
+				const r = n.items.filter((u) => u.label === s)[0];
+				const p = {
+					type: "footnoteRef",
+					raw: f,
+					index: o.refs.length,
+					id: "",
+					label: s
+				};
+				return r ? (p.id = r.refs[0].id, r.refs.push(p)) : (c++, p.id = String(c), o.refs.push(p), n.items.push(o)), p;
+			}
+		},
+		renderer({ index: a, id: i, label: f }) {
+			c = 0;
+			const s = encodeURIComponent(f);
+			const n = l ? T(f) : i;
+			return `<sup><a id="${e}ref-${s}${a > 0 ? `-${a + 1}` : ""}" href="#${e + s}" data-${e}ref aria-describedby="${e}label">${d ? `[${n}]` : n}</a></sup>`;
+		}
+	};
+}
+function E(e, d, l, c, a, i) {
+	return {
+		name: "footnotes",
+		renderer({ raw: f, items: s = [] }) {
+			if (s.length === 0) return "";
+			const n = s.reduce((p, { label: u, content: x, refs: y }) => {
+				const b = encodeURIComponent(u);
+				const $ = this.parser.parse(x).trimEnd();
+				const w = $.endsWith("</p>");
+				let h = `<li id="${e + b}">
+`;
+				return h += w ? $.replace(/<\/p>$/, "") : $, y.forEach((I, F) => {
+					const g = i.replace("{0}", u);
+					let m;
+					let k;
+					if (F > 0) {
+						const L = F + 1;
+						m = `↩<sup>${L}</sup>`, k = `-${L}`;
+					} else m = "↩", k = "";
+					h += ` <a href="#${e}ref-${b}${k}" data-${e}backref aria-label="${g}">${m}</a>`;
+				}), h += w ? `</p>
+` : `
+`, h += `</li>
+`, p + h;
+			}, "");
+			let t = "";
+			l && (t += `<hr data-${d}footnotes>
+`);
+			let o = "";
+			c && (o = ` class="${c}"`);
+			let r = "";
+			return a && (r = ` class="${a}"`), t += `<section${o} data-${d}footnotes>
+`, t += `<h2 id="${e}label"${r}>${f.trimEnd()}</h2>
+`, t += `<ol>
+${n}</ol>
+`, t += `</section>
+`, t;
+		}
+	};
+}
+function C(e = {}) {
+	const { prefixId: d = "footnote-", prefixData: l = "", description: c = "Footnotes", refMarkers: a = !1, footnoteDivider: i = !1, keepLabels: f = !1, sectionClass: s = "footnotes", headingClass: n = "sr-only", backRefLabel: t = "Back to reference {0}" } = e;
+	const o = {
+		hasFootnotes: !1,
+		tokens: []
+	};
+	return {
+		extensions: [
+			R(o, c),
+			A(d, a, f),
+			E(d, l, i, s, n, t)
+		],
+		walkTokens(r) {
+			r.type === "footnotes" && o.tokens.indexOf(r) === 0 && r.items.length && (o.tokens[0] = {
+				type: "space",
+				raw: ""
+			}, o.tokens.push(r)), o.hasFootnotes && (o.hasFootnotes = !1);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/marked-extended-tables@2.0.1_marked@12.0.2/node_modules/marked-extended-tables/src/index.js
+function src_default({ interruptPatterns = [], skipEmptyRows = true } = {}) {
+	return { extensions: [{
+		name: "spanTable",
+		level: "block",
+		start(src) {
+			return src.match(/\n *([^\n ].*\|.*)\n/m)?.index;
+		},
+		tokenizer(src, tokens) {
+			let regexString = "^ *([^\\n ].*\\|.*\\n(?: *[^\\s].*\\n)*?) {0,3}(?:\\| *)?(:?-+(?: *(?:100|[1-9][0-9]?%) *-+)?:? *(?:\\| *:?-+(?: *(?:100|[1-9][0-9]?%) *-+)?:? *)*)(?:\\| *)?(?:\\n((?:(?! *\\n| {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)| {0,3}#{1,6}(?:\\s|$)| {0,3}>| {4}[^\\n]| {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n| {0,3}(?:[*+-]|1[.)]) |<\\/?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?: +|\\n|\\/?>)|<(?:script|pre|style|textarea|!--)endRegex).*(?:\\n|$))*)\\n*|$)";
+			regexString = regexString.replace("endRegex", interruptPatterns.map((str) => `|(?:${str})`).join(""));
+			const widthRegex = / *(?:100|[1-9][0-9]?%) */g;
+			const cap = new RegExp(regexString).exec(src);
+			if (cap) {
+				const item = {
+					type: "spanTable",
+					header: cap[1].replace(/\n$/, "").split("\n"),
+					align: cap[2].replace(widthRegex, "").replace(/^ *|\| *$/g, "").split(/ *\| */),
+					rows: cap[3]?.trim() ? cap[3].replace(/\n[ \t]*$/, "").split("\n") : [],
+					width: cap[2].replace(/:/g, "").replace(/-+| /g, "").split("|")
+				};
+				item.header[0] = splitCells(item.header[0]);
+				const colCount = item.header[0].reduce((length, header) => {
+					return length + header.colspan;
+				}, 0);
+				if (colCount === item.align.length) {
+					item.raw = cap[0];
+					let i;
+					let j;
+					let k;
+					let row;
+					let l = item.align.length;
+					for (i = 0; i < l; i++) if (/^ *-+: *$/.test(item.align[i])) item.align[i] = "right";
+					else if (/^ *:-+: *$/.test(item.align[i])) item.align[i] = "center";
+					else if (/^ *:-+ *$/.test(item.align[i])) item.align[i] = "left";
+					else item.align[i] = null;
+					l = item.header.length;
+					for (i = 1; i < l; i++) item.header[i] = splitCells(item.header[i], colCount, item.header[i - 1], skipEmptyRows);
+					l = item.rows.length;
+					for (i = 0; i < l; i++) item.rows[i] = splitCells(item.rows[i], colCount, item.rows[i - 1], skipEmptyRows);
+					l = item.header.length;
+					for (j = 0; j < l; j++) {
+						row = item.header[j];
+						for (k = 0; k < row.length; k++) {
+							row[k].tokens = [];
+							this.lexer.inline(row[k].text, row[k].tokens);
+						}
+					}
+					l = item.rows.length;
+					for (j = 0; j < l; j++) {
+						row = item.rows[j];
+						for (k = 0; k < row.length; k++) {
+							row[k].tokens = [];
+							this.lexer.inline(row[k].text, row[k].tokens);
+						}
+					}
+					return item;
+				}
+			}
+		},
+		renderer(token) {
+			let i;
+			let j;
+			let row;
+			let cell;
+			let col;
+			let text;
+			let output = "<table>";
+			output += "<thead>";
+			for (i = 0; i < token.header.length; i++) {
+				row = token.header[i];
+				let col = 0;
+				output += "<tr>";
+				for (j = 0; j < row.length; j++) {
+					cell = row[j];
+					text = this.parser.parseInline(cell.tokens);
+					output += getTableCell(text, cell, "th", token.align[col], token.width[col]);
+					col += cell.colspan;
+				}
+				output += "</tr>";
+			}
+			output += "</thead>";
+			if (token.rows.length) {
+				output += "<tbody>";
+				for (i = 0; i < token.rows.length; i++) {
+					row = token.rows[i];
+					col = 0;
+					if (!row[0].emptyRow) {
+						output += "<tr>";
+						for (j = 0; j < row.length; j++) {
+							cell = row[j];
+							text = this.parser.parseInline(cell.tokens);
+							output += getTableCell(text, cell, "td", token.align[col], token.width[col]);
+							col += cell.colspan;
+						}
+						output += "</tr>";
+					}
+				}
+				output += "</tbody>";
+			}
+			output += "</table>";
+			return output;
+		}
+	}] };
+}
+__name(src_default, "default");
+var getTableCell = (text, cell, type, align, width) => {
+	if (!cell.rowspan) return "";
+	return `${`<${type}${cell.colspan > 1 ? ` colspan=${cell.colspan}` : ""}${cell.rowspan > 1 ? ` rowspan=${cell.rowspan}` : ""}${align ? ` align=${align}` : ""}${width ? ` width=${width}` : ""}>` + text}</${type}>\n`;
+};
+var splitCells = (tableRow, count, prevRow = [], skipEmptyRows) => {
+	const cells = [...tableRow.trim().matchAll(/(?:[^|\\]|\\.?)+(?:\|+|$)/g)].map((x) => x[0]);
+	if (!cells[0]?.trim()) cells.shift();
+	if (!cells[cells.length - 1]?.trim()) cells.pop();
+	let numCols = 0;
+	let i;
+	let j;
+	let trimmedCell;
+	let prevCell;
+	let prevCols;
+	for (i = 0; i < cells.length; i++) {
+		trimmedCell = cells[i].split(/\|+$/)[0];
+		cells[i] = {
+			rowspan: 1,
+			colspan: Math.max(cells[i].length - trimmedCell.length, 1),
+			text: trimmedCell.trim().replace(/\\\|/g, "|")
+		};
+		if (trimmedCell.slice(-1) === "^" && prevRow.length) {
+			prevCols = 0;
+			for (j = 0; j < prevRow.length; j++) {
+				prevCell = prevRow[j];
+				if (prevCols === numCols && prevCell.colspan === cells[i].colspan) {
+					cells[i].rowSpanTarget = prevCell.rowSpanTarget ?? prevCell;
+					cells[i].rowSpanTarget.text += ` ${cells[i].text.slice(0, -1)}`;
+					cells[i].rowSpanTarget.rowspan += 1;
+					cells[i].rowspan = 0;
+					break;
+				}
+				prevCols += prevCell.colspan;
+				if (prevCols > numCols) break;
+			}
+		}
+		numCols += cells[i].colspan;
+	}
+	if (cells.length > 0 && skipEmptyRows && cells.length === cells.filter((cell) => {
+		return cell.rowspan === 0;
+	}).length) {
+		cells[0].emptyRow = true;
+		for (i = 0; i < cells.length; i++) cells[i].rowSpanTarget.rowspan -= 1;
+	}
+	if (numCols > count) cells.splice(count);
+	else while (numCols < count) {
+		cells.push({
+			rowspan: 1,
+			colspan: 1,
+			text: ""
+		});
+		numCols += 1;
+	}
+	return cells;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/github-slugger@2.0.0/node_modules/github-slugger/regex.js
+var regex = /[\0-\x1F!-,\.\/:-@\[-\^`\{-\xA9\xAB-\xB4\xB6-\xB9\xBB-\xBF\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0378\u0379\u037E\u0380-\u0385\u0387\u038B\u038D\u03A2\u03F6\u0482\u0530\u0557\u0558\u055A-\u055F\u0589-\u0590\u05BE\u05C0\u05C3\u05C6\u05C8-\u05CF\u05EB-\u05EE\u05F3-\u060F\u061B-\u061F\u066A-\u066D\u06D4\u06DD\u06DE\u06E9\u06FD\u06FE\u0700-\u070F\u074B\u074C\u07B2-\u07BF\u07F6-\u07F9\u07FB\u07FC\u07FE\u07FF\u082E-\u083F\u085C-\u085F\u086B-\u089F\u08B5\u08C8-\u08D2\u08E2\u0964\u0965\u0970\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09F2-\u09FB\u09FD\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A76-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF0-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B70\u0B72-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BF0-\u0BFF\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C7F\u0C84\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D4F-\u0D53\u0D58-\u0D5E\u0D64\u0D65\u0D70-\u0D79\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF4-\u0E00\u0E3B-\u0E3F\u0E4F\u0E5A-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F01-\u0F17\u0F1A-\u0F1F\u0F2A-\u0F34\u0F36\u0F38\u0F3A-\u0F3D\u0F48\u0F6D-\u0F70\u0F85\u0F98\u0FBD-\u0FC5\u0FC7-\u0FFF\u104A-\u104F\u109E\u109F\u10C6\u10C8-\u10CC\u10CE\u10CF\u10FB\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u1360-\u137F\u1390-\u139F\u13F6\u13F7\u13FE-\u1400\u166D\u166E\u1680\u169B-\u169F\u16EB-\u16ED\u16F9-\u16FF\u170D\u1715-\u171F\u1735-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17D4-\u17D6\u17D8-\u17DB\u17DE\u17DF\u17EA-\u180A\u180E\u180F\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u1945\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DA-\u19FF\u1A1C-\u1A1F\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1AA6\u1AA8-\u1AAF\u1AC1-\u1AFF\u1B4C-\u1B4F\u1B5A-\u1B6A\u1B74-\u1B7F\u1BF4-\u1BFF\u1C38-\u1C3F\u1C4A-\u1C4C\u1C7E\u1C7F\u1C89-\u1C8F\u1CBB\u1CBC\u1CC0-\u1CCF\u1CD3\u1CFB-\u1CFF\u1DFA\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FBD\u1FBF-\u1FC1\u1FC5\u1FCD-\u1FCF\u1FD4\u1FD5\u1FDC-\u1FDF\u1FED-\u1FF1\u1FF5\u1FFD-\u203E\u2041-\u2053\u2055-\u2070\u2072-\u207E\u2080-\u208F\u209D-\u20CF\u20F1-\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F-\u215F\u2189-\u24B5\u24EA-\u2BFF\u2C2F\u2C5F\u2CE5-\u2CEA\u2CF4-\u2CFF\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D70-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E00-\u2E2E\u2E30-\u3004\u3008-\u3020\u3030\u3036\u3037\u303D-\u3040\u3097\u3098\u309B\u309C\u30A0\u30FB\u3100-\u3104\u3130\u318F-\u319F\u31C0-\u31EF\u3200-\u33FF\u4DC0-\u4DFF\u9FFD-\u9FFF\uA48D-\uA4CF\uA4FE\uA4FF\uA60D-\uA60F\uA62C-\uA63F\uA673\uA67E\uA6F2-\uA716\uA720\uA721\uA789\uA78A\uA7C0\uA7C1\uA7CB-\uA7F4\uA828-\uA82B\uA82D-\uA83F\uA874-\uA87F\uA8C6-\uA8CF\uA8DA-\uA8DF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA954-\uA95F\uA97D-\uA97F\uA9C1-\uA9CE\uA9DA-\uA9DF\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A-\uAA5F\uAA77-\uAA79\uAAC3-\uAADA\uAADE\uAADF\uAAF0\uAAF1\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB5B\uAB6A-\uAB6F\uABEB\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uE000-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB29\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBB2-\uFBD2\uFD3E-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFC-\uFDFF\uFE10-\uFE1F\uFE30-\uFE32\uFE35-\uFE4C\uFE50-\uFE6F\uFE75\uFEFD-\uFF0F\uFF1A-\uFF20\uFF3B-\uFF3E\uFF40\uFF5B-\uFF65\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFFF]|\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDD3F\uDD75-\uDDFC\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEE1-\uDEFF\uDF20-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDF9F\uDFC4-\uDFC7\uDFD0\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56-\uDC5F\uDC77-\uDC7F\uDC9F-\uDCDF\uDCF3\uDCF6-\uDCFF\uDD16-\uDD1F\uDD3A-\uDD7F\uDDB8-\uDDBD\uDDC0-\uDDFF\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE40-\uDE5F\uDE7D-\uDE7F\uDE9D-\uDEBF\uDEC8\uDEE7-\uDEFF\uDF36-\uDF3F\uDF56-\uDF5F\uDF73-\uDF7F\uDF92-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCFF\uDD28-\uDD2F\uDD3A-\uDE7F\uDEAA\uDEAD-\uDEAF\uDEB2-\uDEFF\uDF1D-\uDF26\uDF28-\uDF2F\uDF51-\uDFAF\uDFC5-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC47-\uDC65\uDC70-\uDC7E\uDCBB-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD40-\uDD43\uDD48-\uDD4F\uDD74\uDD75\uDD77-\uDD7F\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDFF\uDE12\uDE38-\uDE3D\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEA9-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC4B-\uDC4F\uDC5A-\uDC5D\uDC62-\uDC7F\uDCC6\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDC1-\uDDD7\uDDDE-\uDDFF\uDE41-\uDE43\uDE45-\uDE4F\uDE5A-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF3A-\uDFFF]|\uD806[\uDC3B-\uDC9F\uDCEA-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD44-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE2\uDDE5-\uDDFF\uDE3F-\uDE46\uDE48-\uDE4F\uDE9A-\uDE9C\uDE9E-\uDEBF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC41-\uDC4F\uDC5A-\uDC71\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF7-\uDFAF\uDFB1-\uDFFF]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD824-\uD82B\uD82D\uD82E\uD830-\uD833\uD837\uD839\uD83D\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDECF\uDEEE\uDEEF\uDEF5-\uDEFF\uDF37-\uDF3F\uDF44-\uDF4F\uDF5A-\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE80-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE2\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82C[\uDD1F-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A-\uDC9C\uDC9F-\uDFFF]|\uD834[\uDC00-\uDD64\uDD6A-\uDD6C\uDD73-\uDD7A\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDE41\uDE45-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3\uDFCC\uDFCD]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD4F-\uDEBF\uDEFA-\uDFFF]|\uD83A[\uDCC5-\uDCCF\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDFFF]|\uD83B[\uDC00-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDFFF]|\uD83C[\uDC00-\uDD2F\uDD4A-\uDD4F\uDD6A-\uDD6F\uDD8A-\uDFFF]|\uD83E[\uDC00-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEDE-\uDEFF]|\uD86D[\uDF35-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]/g;
+//#endregion
+//#region ../../node_modules/.pnpm/github-slugger@2.0.0/node_modules/github-slugger/index.js
+var own = Object.hasOwnProperty;
+/**
+* Slugger.
+*/
+var BananaSlug = class {
+	/**
+	* Create a new slug class.
+	*/
+	constructor() {
+		/** @type {Record<string, number>} */
+		this.occurrences;
+		this.reset();
+	}
+	/**
+	* Generate a unique slug.
+	*
+	* Tracks previously generated slugs: repeated calls with the same value
+	* will result in different slugs.
+	* Use the `slug` function to get same slugs.
+	*
+	* @param  {string} value
+	*   String of text to slugify
+	* @param  {boolean} [maintainCase=false]
+	*   Keep the current case, otherwise make all lowercase
+	* @return {string}
+	*   A unique slug string
+	*/
+	slug(value, maintainCase) {
+		const self = this;
+		let result = slug(value, maintainCase === true);
+		const originalSlug = result;
+		while (own.call(self.occurrences, result)) {
+			self.occurrences[originalSlug]++;
+			result = originalSlug + "-" + self.occurrences[originalSlug];
+		}
+		self.occurrences[result] = 0;
+		return result;
+	}
+	/**
+	* Reset - Forget all previous slugs
+	*
+	* @return void
+	*/
+	reset() {
+		this.occurrences = Object.create(null);
+	}
+};
+/**
+* Generate a slug.
+*
+* Does not track previously generated slugs: repeated calls with the same value
+* will result in the exact same slug.
+* Use the `GithubSlugger` class to get unique slugs.
+*
+* @param  {string} value
+*   String of text to slugify
+* @param  {boolean} [maintainCase=false]
+*   Keep the current case, otherwise make all lowercase
+* @return {string}
+*   A unique slug string
+*/
+function slug(value, maintainCase) {
+	if (typeof value !== "string") return "";
+	if (!maintainCase) value = value.toLowerCase();
+	return value.replace(regex, "").replace(/ /g, "-");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/marked-gfm-heading-id@3.2.0_marked@12.0.2/node_modules/marked-gfm-heading-id/src/index.js
+var slugger = new BananaSlug();
+var headings = [];
+function gfmHeadingId({ prefix = "", globalSlugs = false } = {}) {
+	return {
+		headerIds: false,
+		hooks: { preprocess(src) {
+			if (!globalSlugs) resetHeadings();
+			return src;
+		} },
+		renderer: { heading(text, level, raw) {
+			raw = raw.toLowerCase().trim().replace(/<[!\/a-z].*?>/gi, "");
+			const id = `${prefix}${slugger.slug(raw)}`;
+			const heading = {
+				level,
+				text,
+				id
+			};
+			headings.push(heading);
+			return `<h${level} id="${id}">${text}</h${level}>\n`;
+		} }
+	};
+}
+function resetHeadings() {
+	headings = [];
+	slugger = new BananaSlug();
+}
+//#endregion
+//#region ../runtime-common/marked-sync.ts
+var bfmMarked = new Marked();
+bfmMarked.use({ extensions: bfmCardReferenceExtensions() });
+bfmMarked.use(gfmHeadingId({ prefix: "user-content-" }));
+bfmMarked.use(A$1());
+bfmMarked.use(C());
+bfmMarked.use(src_default());
+bfmMarked.use(markedKatexPlaceholder());
+var _codeRenderOpts = {};
+bfmMarked.use({ renderer: { code(code, language = "") {
+	if (language === "mermaid") return `<pre class="mermaid">${escapeHtml(code)}</pre>\n`;
+	let highlighted = renderWithMonaco(code, language, _codeRenderOpts);
+	if (highlighted) return highlighted;
+	if (_codeRenderOpts.escapeHtmlInCodeBlocks) return `<pre data-code-language="${escapeHtml(language)}">${escapeHtml(code)}</pre>`;
+	else return `<pre data-code-language="${escapeHtml(language)}">${code}</pre>`;
+} } });
+var DECORATIVE_BULLET_PATTERN = /(^|\n)(\s*)([\p{Extended_Pictographic}★•▪●❖✦✧◉◦◾◽⬢⬡☑✔☑️➤➔➜➡→])(\s+)/gu;
+var DEFAULT_MARKED_SYNC_OPTIONS = {
+	escapeHtmlInCodeBlocks: true,
+	enableMonacoSyntaxHighlighting: false
+};
+/**
+* Renders code with syntax highlighting using the Monaco editor SDK.
+*
+* This function tokenizes code using Monaco's editor capabilities to generate
+* HTML with syntax highlighting spans. Each line is colorized separately and
+* combined into a pre/code block with Monaco token classes.
+*
+* @param code - The source code string to highlight
+* @param language - The programming language for syntax highlighting (e.g., 'typescript', 'javascript')
+* @param opts - Configuration options
+* @param opts.monaco - Optional Monaco SDK instance. Required for highlighting to occur
+* @param opts.monacoTheme - Optional theme name to apply before colorizing (e.g., 'vs-dark', 'vs-light')
+* @param opts.tabSize - Optional tab size for indentation rendering
+* @param opts.enableMonacoSyntaxHighlighting - Flag to enable/disable Monaco syntax highlighting. If false, function returns null immediately
+*
+let editor = monaco?.editor;
+if (monaco === null || !editor?.createModel || !editor?.colorizeModelLine) {
+* or an error occurs during colorization
+*
+* @throws Does not throw; catches all errors and returns null instead
+*/
+function renderWithMonaco(code, language, opts) {
+	if (!opts.enableMonacoSyntaxHighlighting) return null;
+	let monaco = opts.monaco;
+	let editor = monaco?.editor;
+	if (monaco === null || !editor?.createModel || !editor?.colorizeModelLine) return null;
+	let model = null;
+	try {
+		model = editor.createModel(code, language || void 0);
+		if (opts.monacoTheme && editor.setTheme) editor.setTheme(opts.monacoTheme);
+		let lineCount = model.getLineCount();
+		let highlightedLines = [];
+		for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) highlightedLines.push(editor.colorizeModelLine(model, lineNumber, opts.tabSize));
+		return `<pre data-code-language="${escapeHtml(language)}"><code class="monaco-tokenized-source monaco-highlight">${highlightedLines.join("\n")}</code></pre>`;
+	} catch (error) {
+		console.debug("[marked-sync] Monaco syntax highlighting failed:", error);
+		return null;
+	} finally {
+		model?.dispose?.();
+	}
+}
+function markedSync(markdown, opts = DEFAULT_MARKED_SYNC_OPTIONS) {
+	_codeRenderOpts = {
+		...DEFAULT_MARKED_SYNC_OPTIONS,
+		...opts
+	};
+	return bfmMarked.parse(markdown, { async: false });
+}
+var DEFAULT_OPTS = {
+	sanitize: true,
+	escapeHtmlInCodeBlocks: true,
+	enableMonacoSyntaxHighlighting: false
+};
+function markdownToHtml(markdown, opts = DEFAULT_OPTS) {
+	opts = {
+		...DEFAULT_OPTS,
+		...opts
+	};
+	if (!markdown) return "";
+	let html = markedSync(markdown.replace(DECORATIVE_BULLET_PATTERN, (_match, boundary, indentation, bullet, whitespace) => `${boundary}${indentation}* ${bullet}${whitespace}`), {
+		escapeHtmlInCodeBlocks: opts.escapeHtmlInCodeBlocks,
+		enableMonacoSyntaxHighlighting: opts.enableMonacoSyntaxHighlighting,
+		monacoTheme: opts.monacoTheme,
+		monaco: opts.monaco,
+		tabSize: opts.tabSize
+	});
+	if (opts.sanitize) html = sanitizeHtml(html);
+	return html;
+}
+function hasCodeBlocks(markdown) {
+	if (!markdown) return false;
+	return /```(\S+)?\s*[\r\n]/g.test(markdown);
+}
+/**
+* Preload Monaco language contributions referenced in fenced code blocks.
+* @param {string} markdown
+* @param {typeof import('monaco-editor')} monaco
+*/
+async function preloadMarkdownLanguages(md, monaco) {
+	const langs = new Set(["typescript", "json"]);
+	const fenceRE = /```(\S+)?\s*[\r\n]/g;
+	let match;
+	while ((match = fenceRE.exec(md)) !== null) {
+		const lang = (match[1] || "").trim();
+		if (lang) langs.add(lang.toLowerCase());
+	}
+	const registered = monaco.languages.getLanguages();
+	const languagePromises = [];
+	const seenLanguageIds = /* @__PURE__ */ new Set();
+	const contributionLoaders = {
+		json: () => __vitePreload(() => import("./monaco.contribution-DhNsYtZe.js"), __vite__mapDeps([0,1,2,3,4,5,6]), import.meta.url),
+		typescript: () => __vitePreload(() => import("./monaco.contribution-B1hOUP3w.js"), __vite__mapDeps([7,8,2,3,4,5,6]), import.meta.url)
+	};
+	for (const lang of langs) {
+		let entry = registered.find((l) => l.id.toLowerCase() === lang) || registered.find((l) => (l.aliases || []).some((a) => a.toLowerCase() === lang));
+		if (!entry) continue;
+		if (seenLanguageIds.has(entry.id)) continue;
+		seenLanguageIds.add(entry.id);
+		languagePromises.push((async () => {
+			if (contributionLoaders[lang]) await contributionLoaders[lang]();
+			if (typeof entry.loader === "function") await entry.loader();
+			await waitForLanguage(monaco, entry.id);
+			warmUpModelTokenization(monaco, entry.id);
+			await waitForTokenizationSupport(monaco, entry.id);
+		})());
+	}
+	await Promise.all(languagePromises);
+}
+function waitForLanguage(monaco, id) {
+	if (monaco.languages.getEncodedLanguageId(id) !== 0) return Promise.resolve();
+	return new Promise((resolve) => {
+		const disposable = monaco.languages.onLanguage(id, () => {
+			disposable.dispose();
+			resolve();
+		});
+	});
+}
+function waitForTokenizationSupport(monaco, id) {
+	return getTokenizationRegistry(monaco).then(async (registry) => {
+		if (!registry) return;
+		try {
+			if (await registry.getOrCreate?.(id)) return;
+		} catch (err) {
+			console.error(`[markdown preload] getOrCreate threw for "${id}": ${String(err)}`);
+		}
+		const maxAttempts = 20;
+		const delayMs = 25;
+		for (let i = 0; i < maxAttempts; i++) {
+			if (registry.get(id)) return;
+			await sleep(delayMs);
+		}
+		console.error(`[markdown preload] tokenization NOT found for "${id}" after polling`);
+	});
+}
+async function getTokenizationRegistry(monaco) {
+	let registry = monaco.languages.TokenizationRegistry;
+	if (registry) return registry;
+	try {
+		let mod = await __vitePreload(() => import("./languages-BHLYFSz9.js"), __vite__mapDeps([9,5,2]), import.meta.url);
+		if (mod.TokenizationRegistry) {
+			monaco.languages.TokenizationRegistry = mod.TokenizationRegistry;
+			registry = mod.TokenizationRegistry;
+			return registry;
+		}
+		return null;
+	} catch (_error) {
+		return null;
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function warmUpModelTokenization(monaco, id) {
+	if (typeof monaco.editor?.createModel !== "function" || typeof monaco.editor?.colorizeModelLine !== "function") return;
+	let code = "";
+	if (id === "json") code = "{ \"foo\": \"bar\" }";
+	else if (id === "typescript") code = "const x: number = 42;";
+	if (!code) return;
+	let model = monaco.editor.createModel(code, id);
+	try {
+		monaco.editor.colorizeModelLine(model, 1, 2);
+	} catch (_error) {} finally {
+		model.dispose();
+	}
+}
+//#endregion
+export { preloadMarkdownLanguages as i, markdownToHtml as n, markedSync as r, hasCodeBlocks as t };