stream-markdown-parser 0.0.31 → 0.0.33

package/dist/index.js

@@ -601,7 +601,7 @@ var require_markdown_it_task_checkbox = /* @__PURE__ */ __commonJS({ "../../node
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.5/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.8/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
 var import_markdown_it_task_checkbox = /* @__PURE__ */ __toESM(require_markdown_it_task_checkbox(), 1);
 var __defProp = Object.defineProperty;
 var __export = (all) => {
@@ -2187,7 +2187,7 @@ var require_punycode = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/pu
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.5/node_modules/markdown-it-ts/dist/index.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.2-beta.8/node_modules/markdown-it-ts/dist/index.js
 var import_punycode = /* @__PURE__ */ __toESM(require_punycode(), 1);
 var utils_exports = /* @__PURE__ */ __export({
 	arrayReplaceAt: () => arrayReplaceAt,
@@ -2865,13 +2865,46 @@ function normalize(state) {
 	str = str.replace(NULL_RE, "�");
 	state.src = str;
 }
+const RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
+const SCOPED_ABBR_TEST_RE = /\((?:c|tm|r)\)/i;
+const SCOPED_ABBR_RE = /\((c|tm|r)\)/gi;
+const SCOPED_ABBR = {
+	c: "©",
+	r: "®",
+	tm: "™"
+};
+function replaceFn(_match, name) {
+	return SCOPED_ABBR[name.toLowerCase()];
+}
+function replace_scoped(inlineTokens) {
+	let inside_autolink = 0;
+	for (let i = inlineTokens.length - 1; i >= 0; i--) {
+		const token = inlineTokens[i];
+		if (token.type === "text" && !inside_autolink) token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);
+		if (token.type === "link_open" && token.info === "auto") inside_autolink--;
+		if (token.type === "link_close" && token.info === "auto") inside_autolink++;
+	}
+}
+function replace_rare(inlineTokens) {
+	let inside_autolink = 0;
+	for (let i = inlineTokens.length - 1; i >= 0; i--) {
+		const token = inlineTokens[i];
+		if (token.type === "text" && !inside_autolink) {
+			if (RARE_RE.test(token.content)) token.content = token.content.replace(/\+-/g, "±").replace(/\.{2,}/g, "…").replace(/([?!])…/g, "$1..").replace(/([?!]){4,}/g, "$1$1$1").replace(/,{2,}/g, ",").replace(/(^|[^-])---(?=[^-]|$)/gm, "$1—").replace(/(^|\s)--(?=\s|$)/gm, "$1–").replace(/(^|[^-\s])--(?=[^-\s]|$)/gm, "$1–");
+		}
+		if (token.type === "link_open" && token.info === "auto") inside_autolink--;
+		if (token.type === "link_close" && token.info === "auto") inside_autolink++;
+	}
+}
 function replacements(state) {
 	if (!state.md?.options?.typographer) return;
-	(state.tokens || []).forEach((tk) => {
-		if (tk.type === "inline" && Array.isArray(tk.children)) tk.children.forEach((ch) => {
-			if (ch.type === "text" && typeof ch.content === "string") ch.content = ch.content.replace(/\.\.\./g, "…").replace(/---/g, "—").replace(/--/g, "–");
-		});
-	});
+	for (let blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
+		const blk = state.tokens[blkIdx];
+		if (blk.type !== "inline") continue;
+		const blkContent = blk.content || (Array.isArray(blk.children) ? blk.children.map((c) => c.type === "text" ? c.content : "").join("") : "");
+		if (SCOPED_ABBR_TEST_RE.test(blkContent)) replace_scoped(blk.children || []);
+		if (RARE_RE.test(blkContent)) replace_rare(blk.children || []);
+	}
 }
 var CoreRuler = class {
 	rules = [];
@@ -4639,24 +4672,12 @@ var entity_default = entity;
 * Inline rule: escape
 * Process escaped characters
 */
-const ESCAPED = [
-	92,
-	96,
-	42,
-	95,
-	123,
-	125,
-	91,
-	93,
-	40,
-	41,
-	35,
-	43,
-	45,
-	46,
-	33,
-	124
-];
+const ESCAPED = (() => {
+	const table$1 = new Array(256).fill(0);
+	const chars = "\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-";
+	for (let i = 0; i < 32; i++) table$1[chars.charCodeAt(i)] = 1;
+	return table$1;
+})();
 function escape(state, silent) {
 	const { pos, posMax, src } = state;
 	if (src.charCodeAt(pos) !== 92) return false;
@@ -4668,12 +4689,25 @@ function escape(state, silent) {
 		state.pos += 2;
 		return true;
 	}
-	if (ch < 128 && ESCAPED.includes(ch)) {
-		if (!silent) state.pending += src[pos_next];
-		state.pos += 2;
-		return true;
+	let escapedStr = src[pos_next];
+	let nextPos = pos_next;
+	if (ch >= 55296 && ch <= 56319 && pos_next + 1 < posMax) {
+		const ch2 = src.charCodeAt(pos_next + 1);
+		if (ch2 >= 56320 && ch2 <= 57343) {
+			escapedStr += src[pos_next + 1];
+			nextPos++;
+		}
 	}
-	return false;
+	const origStr = src[pos] + escapedStr;
+	if (!silent) {
+		const token = state.push("text_special", "", 0);
+		if (ch < 256 && ESCAPED[ch]) token.content = escapedStr;
+		else token.content = origStr;
+		token.markup = origStr;
+		token.info = "escape";
+	}
+	state.pos = nextPos + 1;
+	return true;
 }
 var escape_default = escape;
 function fragments_join(state) {
@@ -5584,6 +5618,36 @@ function unescapeAll(str) {
 		return match;
 	});
 }
+function isPromiseLike(value) {
+	return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function ensureSyncResult(value, ruleName) {
+	if (isPromiseLike(value)) throw new TypeError(`Renderer rule "${ruleName}" returned a Promise. Use renderAsync() instead.`);
+	return value;
+}
+const resolveResult = (value) => isPromiseLike(value) ? value : Promise.resolve(value);
+function renderFence(token, highlighted, info, langName, options, self) {
+	if (highlighted.startsWith("<pre")) return `${highlighted}\n`;
+	if (info) {
+		const classIndex = typeof token.attrIndex === "function" ? token.attrIndex("class") : -1;
+		const tmpAttrs = token.attrs ? token.attrs.map((attr) => attr.slice()) : [];
+		const langClass = `${options.langPrefix || "language-"}${langName}`;
+		if (classIndex < 0) tmpAttrs.push(["class", langClass]);
+		else tmpAttrs[classIndex][1] += ` ${langClass}`;
+		const tmpToken = {
+			...token,
+			attrs: tmpAttrs
+		};
+		return `<pre><code${self.renderAttrs(tmpToken)}>${highlighted}</code></pre>\n`;
+	}
+	return `<pre><code${self.renderAttrs(token)}>${highlighted}</code></pre>\n`;
+}
+const DEFAULT_RENDERER_OPTIONS = {
+	langPrefix: "language-",
+	xhtmlOut: false,
+	breaks: false
+};
+const hasOwn = Object.prototype.hasOwnProperty;
 const defaultRules = {
 	code_inline(tokens, idx, _options, _env, self) {
 		const token = tokens[idx];
@@ -5604,21 +5668,11 @@ const defaultRules = {
 			langAttrs = parts.slice(2).join("");
 		}
 		const highlight = options.highlight;
-		const highlighted = highlight ? highlight(token.content, langName, langAttrs) || escapeHtml(token.content) : escapeHtml(token.content);
-		if (highlighted.startsWith("<pre")) return `${highlighted}\n`;
-		if (info) {
-			const classIndex = typeof token.attrIndex === "function" ? token.attrIndex("class") : -1;
-			const tmpAttrs = token.attrs ? token.attrs.map((attr) => attr.slice()) : [];
-			const langClass = `${options.langPrefix || "language-"}${langName}`;
-			if (classIndex < 0) tmpAttrs.push(["class", langClass]);
-			else tmpAttrs[classIndex][1] += ` ${langClass}`;
-			const tmpToken = {
-				...token,
-				attrs: tmpAttrs
-			};
-			return `<pre><code${self.renderAttrs(tmpToken)}>${highlighted}</code></pre>\n`;
-		}
-		return `<pre><code${self.renderAttrs(token)}>${highlighted}</code></pre>\n`;
+		const fallback = () => escapeHtml(token.content);
+		if (!highlight) return renderFence(token, fallback(), info, langName, options, self);
+		const highlighted = highlight(token.content, langName, langAttrs);
+		if (isPromiseLike(highlighted)) return highlighted.then((res) => renderFence(token, res || fallback(), info, langName, options, self));
+		return renderFence(token, highlighted || fallback(), info, langName, options, self);
 	},
 	image(tokens, idx, options, env, self) {
 		const token = tokens[idx];
@@ -5640,6 +5694,9 @@ const defaultRules = {
 	text(tokens, idx) {
 		return escapeHtml(tokens[idx].content);
 	},
+	text_special(tokens, idx) {
+		return escapeHtml(tokens[idx].content);
+	},
 	html_block(tokens, idx) {
 		return tokens[idx].content;
 	},
@@ -5647,84 +5704,93 @@ const defaultRules = {
 		return tokens[idx].content;
 	}
 };
-function mergeOptions(base$1, override) {
-	return {
-		langPrefix: "language-",
-		xhtmlOut: false,
-		breaks: false,
-		...base$1,
-		...override
-	};
-}
 var Renderer = class {
 	rules;
 	baseOptions;
+	normalizedBase;
+	bufferPool;
 	constructor(options = {}) {
 		this.baseOptions = { ...options };
+		this.normalizedBase = this.buildNormalizedBase();
 		this.rules = { ...defaultRules };
+		this.bufferPool = [];
 	}
 	set(options) {
 		this.baseOptions = {
 			...this.baseOptions,
 			...options
 		};
+		this.normalizedBase = this.buildNormalizedBase();
 		return this;
 	}
 	render(tokens, options = {}, env = {}) {
 		if (!Array.isArray(tokens)) throw new TypeError("render expects token array as first argument");
-		const merged = mergeOptions(this.baseOptions, options);
-		let result = "";
+		const merged = this.mergeOptions(options);
+		const chunks = this.acquireBuffer();
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
 			if (token.type === "inline") {
-				result += this.renderInline(token.children || [], merged, env);
+				this.pushInlineTokens(token.children || [], merged, env, chunks);
 				continue;
 			}
 			const rule = this.rules[token.type];
-			if (rule) result += rule(tokens, i, merged, env, this);
-			else result += this.renderToken(tokens, i, merged);
+			if (rule) chunks.push(ensureSyncResult(rule(tokens, i, merged, env, this), token.type));
+			else chunks.push(this.renderToken(tokens, i, merged));
 		}
-		return result;
+		const output = chunks.join("");
+		this.releaseBuffer(chunks);
+		return output;
 	}
-	renderInline(tokens, options = {}, env = {}) {
-		const merged = mergeOptions(this.baseOptions, options);
-		let result = "";
+	async renderAsync(tokens, options = {}, env = {}) {
+		if (!Array.isArray(tokens)) throw new TypeError("render expects token array as first argument");
+		const merged = this.mergeOptions(options);
+		const chunks = this.acquireBuffer();
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
+			if (token.type === "inline") {
+				await this.pushInlineTokensAsync(token.children || [], merged, env, chunks);
+				continue;
+			}
 			const rule = this.rules[token.type];
-			if (rule) result += rule(tokens, i, merged, env, this);
-			else result += this.renderToken(tokens, i, merged);
+			if (rule) chunks.push(await resolveResult(rule(tokens, i, merged, env, this)));
+			else chunks.push(this.renderToken(tokens, i, merged));
 		}
-		return result;
+		const output = chunks.join("");
+		this.releaseBuffer(chunks);
+		return output;
+	}
+	renderInline(tokens, options = {}, env = {}) {
+		const merged = this.mergeOptions(options);
+		const chunks = this.acquireBuffer();
+		this.pushInlineTokens(tokens, merged, env, chunks);
+		const output = chunks.join("");
+		this.releaseBuffer(chunks);
+		return output;
+	}
+	async renderInlineAsync(tokens, options = {}, env = {}) {
+		const merged = this.mergeOptions(options);
+		const chunks = this.acquireBuffer();
+		await this.pushInlineTokensAsync(tokens, merged, env, chunks);
+		const output = chunks.join("");
+		this.releaseBuffer(chunks);
+		return output;
 	}
 	renderInlineAsText(tokens, options = {}, env = {}) {
-		const merged = mergeOptions(this.baseOptions, options);
-		let result = "";
-		for (let i = 0; i < tokens.length; i++) {
-			const token = tokens[i];
-			switch (token.type) {
-				case "text":
-					result += token.content;
-					break;
-				case "image":
-					result += this.renderInlineAsText(token.children || [], merged, env);
-					break;
-				case "html_inline":
-				case "html_block":
-					result += token.content;
-					break;
-				case "softbreak":
-				case "hardbreak":
-					result += "\n";
-					break;
-				default: break;
-			}
-		}
-		return result;
+		const merged = this.mergeOptions(options);
+		const chunks = this.acquireBuffer();
+		this.renderInlineAsTextInternal(tokens, merged, env, chunks);
+		const output = chunks.join("");
+		this.releaseBuffer(chunks);
+		return output;
 	}
 	renderAttrs(token) {
 		if (!token.attrs || token.attrs.length === 0) return "";
-		return token.attrs.map(([name, value]) => ` ${escapeHtml(name)}="${escapeHtml(value)}"`).join("");
+		let result = "";
+		for (let i = 0; i < token.attrs.length; i++) {
+			const attr = token.attrs[i];
+			result += ` ${escapeHtml(attr[0])}="${escapeHtml(attr[1])}"`;
+		}
+		return result;
 	}
 	renderToken(tokens, idx, options) {
 		const token = tokens[idx];
@@ -5746,6 +5812,86 @@ var Renderer = class {
 		result += needLineFeed ? ">\n" : ">";
 		return result;
 	}
+	mergeOptions(overrides) {
+		const base$1 = this.normalizedBase;
+		if (!overrides) return base$1;
+		let merged = null;
+		const ensureMerged = () => {
+			if (!merged) merged = { ...base$1 };
+			return merged;
+		};
+		if (hasOwn.call(overrides, "highlight") && overrides.highlight !== base$1.highlight) ensureMerged().highlight = overrides.highlight;
+		if (hasOwn.call(overrides, "langPrefix")) {
+			const value = overrides.langPrefix;
+			if (value !== base$1.langPrefix) ensureMerged().langPrefix = value;
+		}
+		if (hasOwn.call(overrides, "xhtmlOut")) {
+			const value = overrides.xhtmlOut;
+			if (value !== base$1.xhtmlOut) ensureMerged().xhtmlOut = value;
+		}
+		if (hasOwn.call(overrides, "breaks")) {
+			const value = overrides.breaks;
+			if (value !== base$1.breaks) ensureMerged().breaks = value;
+		}
+		return merged || base$1;
+	}
+	buildNormalizedBase() {
+		return Object.freeze({
+			...DEFAULT_RENDERER_OPTIONS,
+			...this.baseOptions
+		});
+	}
+	pushInlineTokens(tokens, options, env, buffer) {
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			const rule = this.rules[token.type];
+			if (rule) buffer.push(ensureSyncResult(rule(tokens, i, options, env, this), token.type));
+			else buffer.push(this.renderToken(tokens, i, options));
+		}
+	}
+	async pushInlineTokensAsync(tokens, options, env, buffer) {
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			const rule = this.rules[token.type];
+			if (rule) buffer.push(await resolveResult(rule(tokens, i, options, env, this)));
+			else buffer.push(this.renderToken(tokens, i, options));
+		}
+	}
+	renderInlineAsTextInternal(tokens, options, env, buffer) {
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			switch (token.type) {
+				case "text":
+				case "text_special":
+					buffer.push(token.content);
+					break;
+				case "image":
+					this.renderInlineAsTextInternal(token.children || [], options, env, buffer);
+					break;
+				case "html_inline":
+				case "html_block":
+					buffer.push(token.content);
+					break;
+				case "softbreak":
+				case "hardbreak":
+					buffer.push("\n");
+					break;
+				default: break;
+			}
+		}
+	}
+	acquireBuffer() {
+		const buf = this.bufferPool.pop();
+		if (buf) {
+			buf.length = 0;
+			return buf;
+		}
+		return [];
+	}
+	releaseBuffer(buffer) {
+		buffer.length = 0;
+		this.bufferPool.push(buffer);
+	}
 };
 var renderer_default = Renderer;
 const DEFAULTS = {
@@ -6005,12 +6151,100 @@ var StreamParser = class {
 		}
 		const appended = this.getAppendedSegment(cached.src, src);
 		if (appended) {
-			const appendedState = this.core.parse(appended, cached.env, md);
-			const lineOffset = cached.lineCount ?? countLines(cached.src);
-			if (lineOffset > 0) this.shiftTokenLines(appendedState.tokens, lineOffset);
-			cached.tokens.push(...appendedState.tokens);
+			const cachedLineCount = cached.lineCount ?? countLines(cached.src);
+			let ctxLines = 3;
+			if (appended.length > 5e3) ctxLines = 8;
+			else if (appended.length > 1e3) ctxLines = 6;
+			else if (appended.length > 200) ctxLines = 4;
+			ctxLines = Math.min(ctxLines, cachedLineCount);
+			let appendedState = null;
+			const ctxStrategy = md.options?.streamContextParseStrategy ?? "chars";
+			const CONTEXT_PARSE_MIN_CHARS = md.options?.streamContextParseMinChars ?? 200;
+			const CONTEXT_PARSE_MIN_LINES = md.options?.streamContextParseMinLines ?? 2;
+			function appendedHasBlockConstructs(s) {
+				return /(?:^|\n)\s{0,3}(?:#{1,6}\s|>\s|[-*+]\s|\d+\.\s|```|~~~| {4,})/.test(s);
+			}
+			let shouldAttemptContext = false;
+			switch (ctxStrategy) {
+				case "lines":
+					shouldAttemptContext = countLines(appended) >= CONTEXT_PARSE_MIN_LINES;
+					break;
+				case "constructs": {
+					const appendedLines = countLines(appended);
+					shouldAttemptContext = appendedHasBlockConstructs(appended) || appendedLines >= CONTEXT_PARSE_MIN_LINES || appended.length >= CONTEXT_PARSE_MIN_CHARS;
+					break;
+				}
+				case "chars":
+				default: shouldAttemptContext = appended.length >= CONTEXT_PARSE_MIN_CHARS;
+			}
+			if (ctxLines > 0 && shouldAttemptContext) {
+				const cachedLines = cached.src.split("\n");
+				const ctxStart = Math.max(0, cachedLines.length - ctxLines);
+				const ctxSrc = cachedLines.slice(ctxStart).join("\n") + appended;
+				try {
+					const ctxTokens = this.core.parse(ctxSrc, cached.env, md).tokens;
+					const idx = ctxTokens.findIndex((t) => t.map && typeof t.map[1] === "number" && t.map[1] >= ctxLines);
+					if (idx !== -1) {
+						const appendedTokens = ctxTokens.slice(idx);
+						const shiftBy = cachedLineCount - ctxLines;
+						if (shiftBy !== 0) this.shiftTokenLines(appendedTokens, shiftBy);
+						appendedState = { tokens: appendedTokens };
+					}
+				} catch {
+					appendedState = null;
+				}
+			} else appendedState = null;
+			if (!appendedState) {
+				const simpleState = this.core.parse(appended, cached.env, md);
+				const lineOffset = cachedLineCount;
+				if (lineOffset > 0) this.shiftTokenLines(simpleState.tokens, lineOffset);
+				appendedState = simpleState;
+			}
+			if (cached.tokens.length > 0 && appendedState.tokens.length > 0) {
+				const lastCached = cached.tokens[cached.tokens.length - 1];
+				const firstApp = appendedState.tokens[0];
+				try {
+					if (lastCached.type === "inline" && firstApp.type === "inline") {
+						if (firstApp.children && firstApp.children.length > 0) {
+							if (!lastCached.children) lastCached.children = [];
+							lastCached.children.push(...firstApp.children);
+						}
+						lastCached.content = (lastCached.content || "") + (firstApp.content || "");
+						appendedState.tokens.shift();
+					}
+				} catch {}
+			}
+			if (appendedState.tokens.length > 0) {
+				const cachedTail = cached.tokens;
+				const a = appendedState.tokens;
+				const maxCheck = Math.min(cachedTail.length, a.length);
+				function tokenEquals(x, y) {
+					if (!x || !y) return false;
+					if (x.type !== y.type) return false;
+					if (x.type === "inline") return (x.content || "") === (y.content || "");
+					return true;
+				}
+				let dup = 0;
+				for (let n = maxCheck; n > 0; n--) {
+					let ok = true;
+					for (let i = 0; i < n; i++) {
+						const tailToken = cachedTail[cachedTail.length - n + i];
+						const prefToken = a[i];
+						if (!tokenEquals(tailToken, prefToken)) {
+							ok = false;
+							break;
+						}
+					}
+					if (ok) {
+						dup = n;
+						break;
+					}
+				}
+				if (dup > 0) a.splice(0, dup);
+				if (a.length > 0) cached.tokens.push(...a);
+			}
 			cached.src = src;
-			cached.lineCount = lineOffset + countLines(appended);
+			cached.lineCount = cachedLineCount + countLines(appended);
 			this.stats.total += 1;
 			this.stats.appendHits += 1;
 			this.stats.lastMode = "append";
@@ -6331,6 +6565,10 @@ function markdownIt(presetName, options) {
 			const tokens = this.parse(src, env);
 			return getRenderer().render(tokens, this.options, env);
 		},
+		async renderAsync(src, env = {}) {
+			const tokens = this.parse(src, env);
+			return getRenderer().renderAsync(tokens, this.options, env);
+		},
 		renderInline(src, env = {}) {
 			const tokens = this.parseInline(src, env);
 			return getRenderer().render(tokens, this.options, env);
@@ -6722,37 +6960,6 @@ function applyFixHtmlInlineTokens(md) {
 	});
 }
 
-//#endregion
-//#region src/plugins/fixLinkInline.ts
-const LINK_PREFIX_RE = /^\[([^\]]*)\]\(([^)\s]*)/;
-function applyFixLinkInline(md) {
-	const rule = (state, silent) => {
-		const s = state;
-		const start = s.pos;
-		if (s.src[start] !== "[") return false;
-		if (start > 0 && s.src[start - 1] === "!") return false;
-		const rest = s.src.slice(start);
-		const m = LINK_PREFIX_RE.exec(rest);
-		if (!m) return false;
-		if (silent) return true;
-		const text$1 = m[1] ?? "";
-		const href = m[2] ?? "";
-		if (text$1.includes("*") || text$1.includes(":")) return false;
-		const idxClose = rest.indexOf(")");
-		const hasClosingParen = idxClose !== -1;
-		const open = s.push("link_open", "a", 1);
-		open.attrs = [["href", href]];
-		const txt = s.push("text", "", 0);
-		txt.content = text$1;
-		if (hasClosingParen) {
-			s.push("link_close", "a", -1);
-			s.pos += idxClose + 1;
-		} else s.pos += m[0].length;
-		return true;
-	};
-	md.inline.ruler.before("link", "fix_link_inline", rule);
-}
-
 //#endregion
 //#region src/plugins/fixLinkTokens.ts
 function textToken(content) {
@@ -6811,11 +7018,17 @@ function pushEmClose(arr, type) {
 	}
 }
 function createLinkToken(text$1, href, loading) {
+	let title = "";
+	if (href.includes("\"")) {
+		const temps = href.split("\"");
+		href = temps[0].trim();
+		title = temps[1].trim();
+	}
 	return {
 		type: "link",
 		loading,
 		href,
-		title: "",
+		title,
 		text: text$1,
 		children: [{
 			type: "text",
@@ -6972,7 +7185,9 @@ function fixLinkToken(tokens) {
 		if (curToken.type === "link_close" && curToken.nesting === -1 && tokens[i + 1]?.type === "text" && tokens[i - 1]?.type === "text") {
 			let loading = true;
 			const text$1 = tokens[i - 1].content || "";
-			let href = tokens[i - 2].attrs?.[0]?.[1] || "";
+			const attrs = tokens[i - 2].attrs || [];
+			let href = attrs.find((a) => a[0] === "href")?.[1] || "";
+			const title = attrs.find((a) => a[0] === "title")?.[1] || "";
 			let count = 3;
 			let deleteCount = 2;
 			const emphasisMatch = (tokens[i - 3]?.content || "").match(/^(\*+)$/);
@@ -6988,8 +7203,8 @@ function fixLinkToken(tokens) {
 				if (m === -1) {
 					href += tokens[i + 1]?.content?.slice(0, m) || "";
 					tokens[i + 1].content = "";
+					count += 1;
 				} else loading = false;
-				count += 1;
 			} else if (tokens[i + 1].type === "text" && tokens[i + 1]?.content?.startsWith("](")) {
 				count += 1;
 				for (let j = i + 1; j < tokens.length; j++) {
@@ -7009,12 +7224,12 @@ function fixLinkToken(tokens) {
 					}
 					count += 1;
 				}
-			}
+			} else loading = false;
 			replacerTokens.push({
 				type: "link",
 				loading,
 				href,
-				title: "",
+				title,
 				text: text$1,
 				children: [{
 					type: "text",
@@ -7171,11 +7386,89 @@ function applyFixStrongTokens(md) {
 	});
 }
 function fixStrongTokens(tokens) {
-	const fixedTokens = [...tokens];
-	if (tokens.length < 4) return fixedTokens;
+	let strongIndex = 0;
+	const cleansStrong = /* @__PURE__ */ new Set();
+	const cleansEm = /* @__PURE__ */ new Set();
+	let emIndex = 0;
+	for (let i$1 = 0; i$1 < tokens.length; i$1++) {
+		const t = tokens[i$1];
+		const type = t.type;
+		if (type === "strong_open") {
+			strongIndex++;
+			const markup = String(t.markup ?? "");
+			let j = i$1 - 1;
+			while (j >= 0 && tokens[j].type === "text" && tokens[j].content === "") j--;
+			const preToken = tokens[j];
+			let k = i$1 + 1;
+			while (k < tokens.length && tokens[k].type === "text" && tokens[k].content === "") k++;
+			const postToken = tokens[k];
+			if (markup === "__" && (preToken?.content?.endsWith("_") || postToken?.content?.startsWith("_") || postToken?.markup?.includes("_"))) {
+				t.type = "text";
+				t.tag = "";
+				t.content = markup;
+				t.raw = markup;
+				t.markup = "";
+				t.attrs = null;
+				t.map = null;
+				t.info = "";
+				t.meta = null;
+				cleansStrong.add(strongIndex);
+			}
+		} else if (type === "strong_close") {
+			if (cleansStrong.has(strongIndex) && t.markup === "__") {
+				t.type = "text";
+				t.content = t.markup;
+				t.raw = String(t.markup ?? "");
+				t.tag = "";
+				t.markup = "";
+				t.attrs = null;
+				t.map = null;
+				t.info = "";
+				t.meta = null;
+			}
+			strongIndex--;
+			if (strongIndex < 0) strongIndex = 0;
+		} else if (type === "em_open") {
+			emIndex++;
+			const markup = String(t.markup ?? "");
+			let j = i$1 - 1;
+			while (j >= 0 && tokens[j].type === "text" && tokens[j].content === "") j--;
+			const preToken = tokens[j];
+			let k = i$1 + 1;
+			while (k < tokens.length && tokens[k].type === "text" && tokens[k].content === "") k++;
+			const postToken = tokens[k];
+			if (markup === "_" && (preToken?.content?.endsWith("_") || postToken?.content?.startsWith("_") || postToken?.markup?.includes("_"))) {
+				t.type = "text";
+				t.tag = "";
+				t.content = markup;
+				t.raw = markup;
+				t.markup = "";
+				t.attrs = null;
+				t.map = null;
+				t.info = "";
+				t.meta = null;
+				cleansEm.add(emIndex);
+			}
+		} else if (type === "em_close") {
+			if (cleansEm.has(emIndex) && t.markup === "_") {
+				t.type = "text";
+				t.content = t.markup;
+				t.raw = String(t.markup ?? "");
+				t.tag = "";
+				t.markup = "";
+				t.attrs = null;
+				t.map = null;
+				t.info = "";
+				t.meta = null;
+			}
+			emIndex--;
+			if (emIndex < 0) emIndex = 0;
+		}
+	}
+	if (tokens.length < 5) return tokens;
 	const i = tokens.length - 4;
 	const token = tokens[i];
-	if (!token) return fixedTokens;
+	const fixedTokens = [...tokens];
 	const nextToken = tokens[i + 1];
 	const tokenContent = String(token.content ?? "");
 	if (token.type === "link_open" && tokens[i - 1]?.type === "em_open" && tokens[i - 2]?.type === "text" && tokens[i - 2].content?.endsWith("*")) {
@@ -7190,7 +7483,8 @@ function fixStrongTokens(tokens) {
 				content: "",
 				markup: "**",
 				info: "",
-				meta: null
+				meta: null,
+				raw: ""
 			},
 			tokens[i],
 			tokens[i + 1],
@@ -7204,7 +7498,8 @@ function fixStrongTokens(tokens) {
 				content: "",
 				markup: "**",
 				info: "",
-				meta: null
+				meta: null,
+				raw: ""
 			}
 		];
 		if (textContent) replaceTokens.unshift({
@@ -7226,11 +7521,13 @@ function fixStrongTokens(tokens) {
 				content: "",
 				markup: "**",
 				info: "",
-				meta: null
+				meta: null,
+				raw: ""
 			},
 			{
 				type: "text",
-				content: _nextToken?.type === "text" ? String(_nextToken.content ?? "") : ""
+				content: _nextToken?.type === "text" ? String(_nextToken.content ?? "") : "",
+				raw: _nextToken?.type === "text" ? String(_nextToken.content ?? "") : ""
 			},
 			{
 				type: "strong_close",
@@ -7241,7 +7538,8 @@ function fixStrongTokens(tokens) {
 				content: "",
 				markup: "**",
 				info: "",
-				meta: null
+				meta: null,
+				raw: ""
 			}
 		];
 		const beforeText = tokenContent.slice(0, -1);
@@ -7458,7 +7756,6 @@ var findMatchingClose_default = findMatchingClose;
 //#endregion
 //#region src/plugins/isMathLike.ts
 const TEX_BRACE_COMMANDS = [
-	"mathbf",
 	"boldsymbol",
 	"mathbb",
 	"mathcal",
@@ -7483,7 +7780,7 @@ const PREFIX_CLASS = "(?:\\\\|\\u0008)";
 const TEX_CMD_WITH_BRACES_RE = new RegExp(`${PREFIX_CLASS}(?:${ESCAPED_TEX_BRACE_COMMANDS})\\s*\\{[^}]+\\}`, "i");
 const TEX_BRACE_CMD_START_RE = new RegExp(`(?:${PREFIX_CLASS})?(?:${ESCAPED_TEX_BRACE_COMMANDS})\s*\{`, "i");
 const TEX_SPECIFIC_RE = /\\(?:text|frac|left|right|times)/;
-const OPS_RE = /* @__PURE__ */ new RegExp("(?<!\\+)\\+(?!\\+)|[=\\-*/^<>]|\\\\times|\\\\pm|\\\\cdot|\\\\le|\\\\ge|\\\\neq");
+const OPS_RE = /* @__PURE__ */ new RegExp("(?:^|[^+])\\+(?!\\+)|[=\\-*/^<>]|\\\\times|\\\\pm|\\\\cdot|\\\\le|\\\\ge|\\\\neq");
 const HYPHENATED_MULTIWORD_RE = /\b[A-Z]{2,}-[A-Z]{2,}\b/i;
 const FUNC_CALL_RE = /[A-Z]+\s*\([^)]+\)/i;
 const WORDS_RE = /\b(?:sin|cos|tan|log|ln|exp|sqrt|frac|sum|lim|int|prod)\b/;
@@ -7495,7 +7792,6 @@ function isMathLike(s) {
 	if (DATE_TIME_RE.test(stripped)) return false;
 	if (stripped.includes("**")) return false;
 	if (stripped.length > 2e3) return true;
-	if (/[./]\s*\D|\D\s*[./]/.test(s)) return false;
 	const texCmd = TEX_CMD_RE.test(norm);
 	const texCmdWithBraces = TEX_CMD_WITH_BRACES_RE.test(norm);
 	const texBraceStart = TEX_BRACE_CMD_START_RE.test(norm);
@@ -7504,7 +7800,7 @@ function isMathLike(s) {
 	const ops = OPS_RE.test(norm) && !HYPHENATED_MULTIWORD_RE.test(norm);
 	const funcCall = FUNC_CALL_RE.test(norm);
 	const words = WORDS_RE.test(norm);
-	const pureWord = /^\([a-z]\)$/i.test(stripped) || /^[a-z]$/i.test(stripped);
+	const pureWord = /^\([a-z]\)$/i.test(stripped) || /^(?:[a-z]|pi)$/i.test(stripped);
 	const chemicalLike = /^(?:[A-Z][a-z]?(?:_\{?\d+\}?|\^\{?\d+\}?)?)+$/.test(stripped);
 	return texCmd || texCmdWithBraces || texBraceStart || texSpecific || superSub || ops || funcCall || words || pureWord || chemicalLike;
 }
@@ -7516,6 +7812,12 @@ const KATEX_COMMANDS = [
 	"cdots",
 	"quad",
 	"in",
+	"displaystyle",
+	"int_",
+	"lim",
+	"lim_",
+	"ce",
+	"pu",
 	"end",
 	"infty",
 	"perp",
@@ -7526,11 +7828,11 @@ const KATEX_COMMANDS = [
 	"leftarrow",
 	"math",
 	"mathrm",
-	"mathbf",
 	"mathit",
 	"mathbb",
 	"mathcal",
 	"mathfrak",
+	"implies",
 	"alpha",
 	"beta",
 	"gamma",
@@ -7538,8 +7840,8 @@ const KATEX_COMMANDS = [
 	"epsilon",
 	"lambda",
 	"sum",
+	"sum_",
 	"prod",
-	"int",
 	"sqrt",
 	"fbox",
 	"boxed",
@@ -7561,19 +7863,25 @@ const KATEX_COMMANDS = [
 	"log",
 	"ln",
 	"exp",
-	"lim",
 	"frac",
 	"text",
 	"left",
 	"right"
 ];
+const ANY_COMMANDS = [
+	"cdot",
+	"mathbf{",
+	"partial",
+	"mu_{"
+];
 const ESCAPED_KATEX_COMMANDS = KATEX_COMMANDS.slice().sort((a, b) => b.length - a.length).map((c) => c.replace(/[.*+?^${}()|[\\]\\\]/g, "\\$&")).join("|");
 const CONTROL_CHARS_CLASS = "[	\r\b\f\v]";
+const ESCAPED_MKATWX_COMMANDS = new RegExp(`([^\\\\])(${ANY_COMMANDS.map((c) => c).join("|")})+`, "g");
 const SPAN_CURLY_RE = /span\{([^}]+)\}/;
 const OPERATORNAME_SPAN_RE = /\\operatorname\{span\}\{((?:[^{}]|\{[^}]*\})+)\}/;
 const SINGLE_BACKSLASH_NEWLINE_RE = /(^|[^\\])\\\r?\n/g;
 const ENDING_SINGLE_BACKSLASH_RE = /(^|[^\\])\\$/g;
-const DEFAULT_MATH_RE = new RegExp(`${CONTROL_CHARS_CLASS}|(?<!\\\\|\\w)(${ESCAPED_KATEX_COMMANDS})\\b`, "g");
+const DEFAULT_MATH_RE = new RegExp(`(${CONTROL_CHARS_CLASS})|(${ESCAPED_KATEX_COMMANDS})\\b`, "g");
 const MATH_RE_CACHE = /* @__PURE__ */ new Map();
 const BRACE_CMD_RE_CACHE = /* @__PURE__ */ new Map();
 function getMathRegex(commands) {
@@ -7584,7 +7892,7 @@ function getMathRegex(commands) {
 	const cached = MATH_RE_CACHE.get(key);
 	if (cached) return cached;
 	const commandPattern = `(?:${arr.map((c) => c.replace(/[.*+?^${}()|[\\]\\"\]/g, "\\$&")).join("|")})`;
-	const re = new RegExp(`${CONTROL_CHARS_CLASS}|(?<!\\\\|\\w)(${commandPattern})\\b`, "g");
+	const re = new RegExp(`(${CONTROL_CHARS_CLASS})|(${commandPattern})\\b`, "g");
 	MATH_RE_CACHE.set(key, re);
 	return re;
 }
@@ -7617,9 +7925,13 @@ function normalizeStandaloneBackslashT(s, opts) {
 	const escapeExclamation = opts?.escapeExclamation ?? true;
 	const useDefault = opts?.commands == null;
 	const re = getMathRegex(useDefault ? void 0 : commands);
-	let out = s.replace(re, (m, cmd) => {
-		if (CONTROL_MAP[m] !== void 0) return `\\${CONTROL_MAP[m]}`;
-		if (cmd && commands.includes(cmd)) return `\\${cmd}`;
+	let out = s.replace(re, (m, control, cmd, offset, str) => {
+		if (control !== void 0 && CONTROL_MAP[control] !== void 0) return `\\${CONTROL_MAP[control]}`;
+		if (cmd && commands.includes(cmd)) {
+			const prev = str && typeof offset === "number" ? str[offset - 1] : void 0;
+			if (prev === "\\" || prev && /\w/.test(prev)) return m;
+			return `\\${cmd}`;
+		}
 		return m;
 	});
 	if (escapeExclamation) out = out.replace(/(^|[^\\])!/g, "$1\\!");
@@ -7629,6 +7941,7 @@ function normalizeStandaloneBackslashT(s, opts) {
 	result = result.replace(SPAN_CURLY_RE, "span\\{$1\\}").replace(OPERATORNAME_SPAN_RE, "\\operatorname{span}\\{$1\\}");
 	result = result.replace(SINGLE_BACKSLASH_NEWLINE_RE, "$1\\\\\n");
 	result = result.replace(ENDING_SINGLE_BACKSLASH_RE, "$1\\\\");
+	result = result.replace(ESCAPED_MKATWX_COMMANDS, "$1\\$2");
 	return result;
 }
 function applyMath(md, mathOpts) {
@@ -7756,13 +8069,11 @@ function applyMath(md, mathOpts) {
 						const isBeforeClose = raw.startsWith("*");
 						if (isBeforeClose) s.push("strong_close", "", 0);
 						if (raw) {
-							const textContentToken = s.push("text", "", 0);
-							textContentToken.content = (raw == null ? "" : String(raw)).replace(/^\*+/, "");
+							s.pos = endIdx + close.length;
+							searchPos = s.pos;
+							preMathPos = searchPos;
 						}
 						if (!isBeforeClose) s.push("strong_close", "", 0);
-						s.pos = src.length;
-						searchPos = src.length;
-						preMathPos = searchPos;
 						continue;
 					} else {
 						const token = s.push("math_inline", "math", 0);
@@ -7795,11 +8106,12 @@ function applyMath(md, mathOpts) {
 			["$$", "$$"]
 		];
 		const startPos = s.bMarks[startLine] + s.tShift[startLine];
-		const lineText = s.src.slice(startPos, s.eMarks[startLine]).trim();
+		let lineText = s.src.slice(startPos, s.eMarks[startLine]).trim();
 		let matched = false;
 		let openDelim = "";
 		let closeDelim = "";
-		for (const [open, close] of delimiters) if (lineText.startsWith(open)) if (open.includes("[")) {
+		let skipFirstLine = false;
+		for (const [open, close] of delimiters) if (lineText.startsWith(open)) if (open.includes("[")) if (mathOpts?.strictDelimiters) {
 			if (lineText.replace("\\", "") === "[") {
 				if (startLine + 1 < endLine) {
 					matched = true;
@@ -7809,12 +8121,47 @@ function applyMath(md, mathOpts) {
 				}
 				continue;
 			}
+		} else if (lineText.replace("\\", "") === "[") {
+			if (startLine + 1 < endLine) {
+				matched = true;
+				openDelim = open;
+				closeDelim = close;
+				break;
+			}
+			continue;
 		} else {
+			const lastToken = s.tokens[s.tokens.length - 1];
+			if (lastToken && lastToken.type === "list_item_open" && lastToken.mark === "-" && lineText.slice(open.length, lineText.indexOf("]")).trim() === "x") continue;
+			if (lineText.replace("\\", "").startsWith("[") && !lineText.includes("](")) {
+				const closeIndex = lineText.indexOf("]");
+				if (lineText.slice(closeIndex).trim() !== "]") continue;
+				if (isMathLike(lineText.slice(open.length, closeIndex))) {
+					matched = true;
+					openDelim = open;
+					closeDelim = close;
+					break;
+				}
+				continue;
+			}
+		}
+		else {
 			matched = true;
 			openDelim = open;
 			closeDelim = close;
 			break;
 		}
+		else if (lineText.endsWith(open) && !lineText.slice(0, lineText.length - open.length).trim().includes(open) && startLine + 1 < endLine) {
+			s.push("text", "", 0).content = lineText.slice(0, lineText.length - open.length);
+			const nextLineStartPos = s.bMarks[startLine + 1] + s.tShift[startLine + 1];
+			lineText = s.src.slice(nextLineStartPos, s.eMarks[startLine + 1]).trim();
+			if (open === "$$") {
+				skipFirstLine = true;
+				matched = true;
+				openDelim = open;
+				closeDelim = close;
+				break;
+			}
+		}
 		if (!matched) return false;
 		if (silent) return true;
 		if (lineText.includes(closeDelim) && lineText.indexOf(closeDelim) > openDelim.length) {
@@ -7841,7 +8188,7 @@ function applyMath(md, mathOpts) {
 			found = true;
 			nextLine = startLine;
 		} else {
-			if (firstLineContent) content = firstLineContent;
+			if (firstLineContent && !skipFirstLine) content = firstLineContent;
 			for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
 				const lineStart = s.bMarks[nextLine] + s.tShift[nextLine];
 				const lineEnd = s.eMarks[nextLine];
@@ -7859,6 +8206,7 @@ function applyMath(md, mathOpts) {
 			}
 		}
 		if (strict && !found) return false;
+		if (!isMathLike(content)) return false;
 		const token = s.push("math_block", "math", 0);
 		token.content = normalizeStandaloneBackslashT(content);
 		token.markup = openDelim === "$$" ? "$$" : openDelim === "[" ? "[]" : "\\[\\]";
@@ -7913,7 +8261,6 @@ function factory(opts = {}) {
 		...opts.mathOptions ?? {}
 	});
 	if (opts.enableContainers ?? true) applyContainers(md);
-	applyFixLinkInline(md);
 	applyFixLinkTokens(md);
 	applyFixStrongTokens(md);
 	applyFixListItem(md);
@@ -8405,10 +8752,6 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 	if (!tokens || tokens.length === 0) return [];
 	const result = [];
 	let currentTextNode = null;
-	const hasSuspiciousCodeInline = tokens.some((t) => t.type === "code_inline" && /[^\x00-\x7F]/.test(String(t.content ?? "")));
-	const hasBackticksInRaw = typeof raw === "string" && /`/.test(raw);
-	const hasMathInlineUsingBackticks = tokens.some((t) => t.type === "math_inline" && /`/.test(String(t.raw ?? t.content ?? "")));
-	if (hasBackticksInRaw && (hasSuspiciousCodeInline || hasMathInlineUsingBackticks)) return parseFromRawWithCodeAndStrong(String(raw ?? ""));
 	let i = 0;
 	const requireClosingStrong = options?.requireClosingStrong;
 	function resetCurrentTextNode() {
@@ -8489,7 +8832,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 					type: "strong_open",
 					tag: "strong",
 					content: "",
-					markup: "*",
+					markup: "**",
 					info: "",
 					meta: null
 				},
@@ -8505,7 +8848,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 					type: "strong_close",
 					tag: "strong",
 					content: "",
-					markup: "*",
+					markup: "**",
 					info: "",
 					meta: null
 				}
@@ -8538,6 +8881,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 				};
 				result.push(currentTextNode);
 			}
+			const closeIndex = content.indexOf("*", idx + 1);
 			const { node } = parseEmphasisToken([
 				{
 					type: "em_open",
@@ -8550,7 +8894,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 				{
 					type: "text",
 					tag: "",
-					content: content.slice(idx).replace(/\*/g, ""),
+					content: content.slice(idx, closeIndex > -1 ? closeIndex + 1 : void 0).replace(/\*/g, ""),
 					markup: "",
 					info: "",
 					meta: null
@@ -8564,6 +8908,14 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 					meta: null
 				}
 			], 0, options);
+			if (closeIndex !== -1 && closeIndex < content.length - 1) {
+				const afterContent = content.slice(closeIndex + 1);
+				if (afterContent) handleToken({
+					type: "text",
+					content: afterContent,
+					raw: afterContent
+				});
+			}
 			resetCurrentTextNode();
 			pushNode(node);
 			i++;
@@ -8785,6 +9137,17 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 				pushNode(parseFootnoteRefToken(token));
 				i++;
 				break;
+			case "footnote_anchor": {
+				resetCurrentTextNode();
+				const meta = token.meta ?? {};
+				pushParsed({
+					type: "footnote_anchor",
+					id: String(meta.label ?? token.content ?? ""),
+					raw: String(token.content ?? "")
+				});
+				i++;
+				break;
+			}
 			case "hardbreak":
 				resetCurrentTextNode();
 				pushNode(parseHardbreakToken());
@@ -8822,7 +9185,6 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 			i++;
 			return;
 		}
-		if (content.startsWith(")") && result[result.length - 1]?.type === "link") content = content.slice(1);
 		if (Array.from(content.matchAll(/\$/g)).length === 1 && content.endsWith("$")) content = content.slice(0, -1);
 		if (content.endsWith("undefined") && !raw?.endsWith("undefined")) content = content.slice(0, -9);
 		for (; index >= 0; index--) {
@@ -8920,8 +9282,24 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 					});
 					i += 1;
 				} else {
-					pushText(text$1, text$1);
-					i += 3;
+					i += 2;
+					while (i < tokens.length && tokens[i].type !== "link_close") {
+						text$1 += String(tokens[i]?.content || "");
+						i++;
+					}
+					const loading = tokens[i].type !== "link_close";
+					pushParsed({
+						type: "link",
+						href: String(hrefAttr$1),
+						title: null,
+						text: text$1,
+						children: [{
+							type: "text",
+							content: text$1,
+							raw: text$1
+						}],
+						loading
+					});
 				}
 				return;
 			}
@@ -9182,78 +9560,6 @@ function normalizeSingleLinkResult(raw, nodes) {
 	if (preferred) return [preferred];
 	return nodes;
 }
-function parseFromRawWithCodeAndStrong(raw) {
-	const root = [];
-	const stack = [{
-		type: "root",
-		children: root
-	}];
-	let i = 0;
-	function cur() {
-		return stack[stack.length - 1].children;
-	}
-	function pushText(s) {
-		if (!s) return;
-		const last = cur()[cur().length - 1];
-		if (last && last.type === "text") {
-			last.content += s;
-			last.raw += s;
-		} else cur().push({
-			type: "text",
-			content: s,
-			raw: s
-		});
-	}
-	while (i < raw.length) {
-		if (raw[i] === "*" && raw[i + 1] === "*") {
-			const isClosing = stack.length > 1 && stack[stack.length - 1].type === "strong";
-			i += 2;
-			if (isClosing) {
-				const nodeChildren = stack.pop().children;
-				cur().push({
-					type: "strong",
-					children: nodeChildren,
-					raw: `**${nodeChildren.map((n) => n.raw ?? "").join("")}**`
-				});
-			} else stack.push({
-				type: "strong",
-				children: []
-			});
-			continue;
-		}
-		if (raw[i] === "`") {
-			let runLen = 1;
-			let k = i + 1;
-			while (k < raw.length && raw[k] === "`") {
-				runLen++;
-				k++;
-			}
-			const closingSeq = "`".repeat(runLen);
-			const codeStart = i + runLen;
-			const close = raw.indexOf(closingSeq, codeStart);
-			if (close === -1) {
-				pushText(raw.slice(i));
-				break;
-			}
-			const code$1 = raw.slice(codeStart, close);
-			cur().push({
-				type: "inline_code",
-				code: code$1,
-				raw: code$1
-			});
-			i = close + runLen;
-			continue;
-		}
-		let next = raw.indexOf("`", i);
-		const nextStrong = raw.indexOf("**", i);
-		if (nextStrong !== -1 && (next === -1 || nextStrong < next)) next = nextStrong;
-		if (next === -1) next = raw.length;
-		pushText(raw.slice(i, next));
-		i = next;
-	}
-	while (stack.length > 1) pushText(`**${stack.pop().children.map((n) => n.raw ?? n.content ?? "").join("")}`);
-	return root;
-}
 
 //#endregion
 //#region src/parser/node-parsers/blockquote-parser.ts
@@ -9347,6 +9653,8 @@ function parseFootnote(tokens, index, options) {
 	let j = index + 1;
 	while (j < tokens.length && tokens[j].type !== "footnote_close") if (tokens[j].type === "paragraph_open") {
 		const contentToken = tokens[j + 1];
+		const children = contentToken.children || [];
+		if (tokens[j + 2].type === "footnote_anchor") children.push(tokens[j + 2]);
 		footnoteChildren.push({
 			type: "paragraph",
 			children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? ""), void 0, { requireClosingStrong: options?.requireClosingStrong }),
@@ -9778,7 +10086,7 @@ function parseParagraph(tokens, index, options) {
 //#endregion
 //#region src/parser/index.ts
 function parseMarkdownToStructure(markdown, md, options = {}) {
-	let safeMarkdown = (markdown ?? "").toString().replace(/([^\\])\right/g, "$1\\right");
+	let safeMarkdown = (markdown ?? "").toString().replace(/([^\\])\r(ight|ho)/g, "$1\\r$2").replace(/([^\\])\n(abla|eq|ot|exists)/g, "$1\\n$2");
 	if (safeMarkdown.endsWith("- *")) safeMarkdown = safeMarkdown.replace(/- \*$/, "- \\*");
 	if (/\n\s*-\s*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/\n\s*-\s*$/, "\n");
 	else if (/\n[[(]\n*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/(\n\[|\n\()+\n*$/g, "\n");
@@ -9874,6 +10182,17 @@ function processTokens(tokens, options) {
 				i = newIndex;
 				break;
 			}
+			case "footnote_anchor": {
+				const meta = token.meta ?? {};
+				const id = String(meta.label ?? token.content ?? "");
+				result.push({
+					type: "footnote_anchor",
+					id,
+					raw: String(token.content ?? "")
+				});
+				i++;
+				break;
+			}
 			case "container_open": {
 				const match = /^::: ?(warning|info|note|tip|danger|caution|error) ?(.*)$/.exec(String(token.info ?? ""));
 				if (match) {