stream-markdown-parser 0.0.7 → 0.0.9

package/dist/index.js

@@ -36,44 +36,470 @@ function applyContainers(md) {
 		} });
 	});
 	md.block.ruler.before("fence", "vmr_container_fallback", (state, startLine, endLine, silent) => {
-		const startPos = state.bMarks[startLine] + state.tShift[startLine];
-		const lineMax = state.eMarks[startLine];
-		const markerMatch = state.src.slice(startPos, lineMax).match(/^:::\s*(\w+)/);
+		const s = state;
+		const startPos = s.bMarks[startLine] + s.tShift[startLine];
+		const lineMax = s.eMarks[startLine];
+		const markerMatch = s.src.slice(startPos, lineMax).match(/^:::\s*(\w+)/);
 		if (!markerMatch) return false;
 		if (silent) return true;
 		const name = markerMatch[1];
 		let nextLine = startLine + 1;
 		let found = false;
 		while (nextLine <= endLine) {
-			const sPos = state.bMarks[nextLine] + state.tShift[nextLine];
-			const ePos = state.eMarks[nextLine];
-			if (state.src.slice(sPos, ePos).trim() === ":::") {
+			const sPos = s.bMarks[nextLine] + s.tShift[nextLine];
+			const ePos = s.eMarks[nextLine];
+			if (s.src.slice(sPos, ePos).trim() === ":::") {
 				found = true;
 				break;
 			}
 			nextLine++;
 		}
 		if (!found) return false;
-		state.push("vmr_container_open", "div", 1).attrSet("class", `vmr-container vmr-container-${name}`);
+		s.push("vmr_container_open", "div", 1).attrSet("class", `vmr-container vmr-container-${name}`);
 		const contentLines = [];
 		for (let i = startLine + 1; i < nextLine; i++) {
-			const sPos = state.bMarks[i] + state.tShift[i];
-			const ePos = state.eMarks[i];
-			contentLines.push(state.src.slice(sPos, ePos));
+			const sPos = s.bMarks[i] + s.tShift[i];
+			const ePos = s.eMarks[i];
+			contentLines.push(s.src.slice(sPos, ePos));
 		}
-		state.push("paragraph_open", "p", 1);
-		const inlineToken = state.push("inline", "", 0);
+		s.push("paragraph_open", "p", 1);
+		const inlineToken = s.push("inline", "", 0);
 		inlineToken.content = contentLines.join("\n");
 		inlineToken.map = [startLine + 1, nextLine];
 		inlineToken.children = [];
-		state.md.inline.parse(inlineToken.content, state.md, state.env, inlineToken.children);
-		state.push("paragraph_close", "p", -1);
-		state.push("vmr_container_close", "div", -1);
-		state.line = nextLine + 1;
+		s.md.inline.parse(inlineToken.content, s.md, s.env, inlineToken.children);
+		s.push("paragraph_close", "p", -1);
+		s.push("vmr_container_close", "div", -1);
+		s.line = nextLine + 1;
 		return true;
 	});
 }
 
+//#endregion
+//#region src/plugins/fixLinkInline.ts
+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 = /^\[([^\]]*)\]\(([^)\s]*)?/.exec(rest);
+		if (!m) return false;
+		if (silent) return true;
+		const text = m[1] ?? "";
+		const href = m[2] ?? "";
+		if (text.includes("*") || text.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;
+		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/parser/inline-parsers/fixLinkToken.ts
+function isTextToken(t) {
+	return !!t && t.type === "text" && typeof t.content === "string";
+}
+function fixLinkToken(tokens) {
+	const tokensAny = tokens;
+	tokens = fixLinkToken4(fixLinkToken3(tokens));
+	if (tokens.length < 5) return tokens;
+	const first = tokens[tokens.length - 5];
+	const firstAny = first;
+	const firstContent = String(firstAny.content ?? "");
+	if (first.type !== "text" || !firstContent.endsWith("[")) return fixLinkTokens2(tokens);
+	if (tokens[tokens.length - 4].tag !== "em") return fixLinkTokens2(tokens);
+	const last = tokens[tokens.length - 1];
+	const lastAny = last;
+	const lastContent = String(lastAny.content ?? "");
+	if (last?.type === "text" && !lastContent.startsWith("]")) return fixLinkTokens2(tokens);
+	const thirdAny = tokens[tokens.length - 3];
+	const thirdContent = String(thirdAny.content ?? "");
+	const href = lastContent.replace(/^\]\(*/, "");
+	const loading = !lastContent.includes(")");
+	tokensAny[tokens.length - 5].content = firstContent.replace(/\[$/, "");
+	tokens.splice(tokens.length - 3, 1, {
+		type: "link",
+		href,
+		text: thirdContent,
+		children: [{
+			type: "text",
+			content: thirdContent,
+			raw: thirdContent
+		}],
+		loading
+	});
+	tokens.splice(tokens.length - 1, 1);
+	return tokens;
+}
+function fixLinkTokens2(tokens) {
+	const tokensAny = tokens;
+	if (tokens.length < 8) return tokens;
+	let length = tokens.length;
+	let last = tokens[length - 1];
+	if (last.type !== "link_close") {
+		length--;
+		last = tokens[length - 1];
+		if (last.type !== "link_close") return tokens;
+	}
+	if (tokens[length - 7].type !== "em_open") return tokens;
+	const third = tokens[length - 6];
+	const first = tokens[length - 8];
+	if (first.type !== "text") return tokens;
+	let href = String(tokensAny[length - 2]?.content ?? "");
+	let count = 4;
+	if (length !== tokens.length) {
+		href += String(last.content ?? "");
+		count++;
+	}
+	tokens.splice(length - 4, count);
+	const thirdAny = third;
+	const content = String(thirdAny.content ?? "");
+	length -= 4;
+	const firstAny = first;
+	tokensAny[length - 8].content = String(firstAny.content ?? "").replace(/\[$/, "");
+	tokens.splice(length - 2, 1, {
+		type: "link",
+		href,
+		text: content,
+		children: [{
+			type: "text",
+			content,
+			raw: content
+		}],
+		loading: true
+	});
+	return tokens;
+}
+function fixLinkToken3(tokens) {
+	const tokensAny = tokens;
+	const last = tokens[tokens.length - 1];
+	const preLast = tokens[tokens.length - 2];
+	const fixedTokens = [...tokens];
+	if (last.type !== "text" || !last.content?.startsWith(")")) return tokens;
+	if (preLast.type !== "link_close") return tokens;
+	if (isTextToken(tokens[tokens.length - 5]) && String(tokens[tokens.length - 5].content ?? "").endsWith("(")) {
+		const a = tokensAny[tokens.length - 5];
+		const b = tokensAny[tokens.length - 3];
+		const content = String(a.content ?? "") + String(b.content ?? "") + String(last.content ?? "");
+		fixedTokens.splice(tokens.length - 5, 5, {
+			type: "text",
+			content,
+			raw: content
+		});
+	} else {
+		const lc = (last.content ?? "").slice(1);
+		fixedTokens[fixedTokens.length - 1] = {
+			...last,
+			content: lc
+		};
+	}
+	return fixedTokens;
+}
+function fixLinkToken4(tokens) {
+	const tokensAny = tokens;
+	const fixedTokens = [...tokens];
+	for (let i = tokens.length - 1; i >= 3; i--) if (tokens[i].type === "link_close") {
+		if (tokens[i - 3]?.content?.endsWith("(")) {
+			const nextToken = tokens[i + 1];
+			if (nextToken?.type === "text") {
+				if (tokens[i - 1].type === "text" && tokens[i - 3].type === "text") {
+					const nextTokenContent = String(nextToken.content ?? "");
+					const a = tokensAny[i - 3];
+					const b = tokensAny[i - 1];
+					const content = String(a.content ?? "") + String(b.content ?? "") + nextTokenContent;
+					fixedTokens.splice(i - 3, 5, {
+						type: "text",
+						content,
+						raw: content
+					});
+					i -= 3;
+				}
+			} else {
+				if (tokens[i - 1].type === "text" && tokens[i - 3].type === "text") {
+					const a = tokensAny[i - 3];
+					const b = tokensAny[i - 1];
+					const content = String(a.content ?? "") + String(b.content ?? "");
+					fixedTokens.splice(i - 3, 4, {
+						type: "text",
+						content,
+						raw: content
+					});
+				}
+				i -= 3;
+			}
+		}
+	}
+	return fixedTokens;
+}
+
+//#endregion
+//#region src/plugins/fixLinkTokens.ts
+function applyFixLinkTokens(md) {
+	md.core.ruler.after("inline", "fix_link_tokens", (state) => {
+		const toks = state.tokens ?? [];
+		for (let i = 0; i < toks.length; i++) {
+			const t = toks[i];
+			if (t && t.type === "inline" && Array.isArray(t.children)) try {
+				t.children = fixLinkToken(t.children);
+			} catch (e) {
+				console.error("[applyFixLinkTokens] failed to fix inline children", e);
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/parser/inline-parsers/fixListItem.ts
+function fixListItem(tokens) {
+	const last = tokens[tokens.length - 1];
+	const lastContent = String(last?.content ?? "");
+	if (last?.type === "text" && /^\s*\d+\.\s*$/.test(lastContent) && tokens[tokens.length - 2]?.tag === "br") tokens.splice(tokens.length - 1, 1);
+	return tokens;
+}
+
+//#endregion
+//#region src/plugins/fixListItem.ts
+function applyFixListItem(md) {
+	md.core.ruler.after("inline", "fix_list_item_tokens", (state) => {
+		const toks = state.tokens ?? [];
+		for (let i = 0; i < toks.length; i++) {
+			const t = toks[i];
+			if (t && t.type === "inline" && Array.isArray(t.children)) try {
+				t.children = fixListItem(t.children);
+			} catch (e) {
+				console.error("[applyFixListItem] failed to fix inline children", e);
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/parser/inline-parsers/fixStrongTokens.ts
+function fixStrongTokens(tokens) {
+	const fixedTokens = [...tokens];
+	if (tokens.length < 4) return fixedTokens;
+	const i = tokens.length - 4;
+	const token = tokens[i];
+	const nextToken = tokens[i + 1];
+	const tokenContent = String(token.content ?? "");
+	if (token.type === "text" && tokenContent.endsWith("*") && nextToken.type === "em_open") {
+		const _nextToken = tokens[i + 2];
+		const count = _nextToken?.type === "text" ? 4 : 3;
+		const insert = [
+			{
+				type: "strong_open",
+				tag: "strong",
+				attrs: null,
+				map: null,
+				children: null,
+				content: "",
+				markup: "**",
+				info: "",
+				meta: null
+			},
+			{
+				type: "text",
+				content: _nextToken?.type === "text" ? String(_nextToken.content ?? "") : ""
+			},
+			{
+				type: "strong_close",
+				tag: "strong",
+				attrs: null,
+				map: null,
+				children: null,
+				content: "",
+				markup: "**",
+				info: "",
+				meta: null
+			}
+		];
+		const beforeText = tokenContent.slice(0, -1);
+		if (beforeText) insert.unshift({
+			type: "text",
+			content: beforeText,
+			raw: beforeText
+		});
+		fixedTokens.splice(i, count, ...insert);
+		return fixedTokens;
+	}
+	return fixedTokens;
+}
+
+//#endregion
+//#region src/plugins/fixStrongTokens.ts
+function applyFixStrongTokens(md) {
+	md.core.ruler.after("inline", "fix_strong_tokens", (state) => {
+		const toks = state.tokens ?? [];
+		for (let i = 0; i < toks.length; i++) {
+			const t = toks[i];
+			if (t && t.type === "inline" && Array.isArray(t.children)) try {
+				t.children = fixStrongTokens(t.children);
+			} catch (e) {
+				console.error("[applyFixStrongTokens] failed to fix inline children", e);
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/parser/fixTableTokens.ts
+function createStart() {
+	return [
+		{
+			type: "table_open",
+			tag: "table",
+			attrs: null,
+			map: null,
+			children: null,
+			content: "",
+			markup: "",
+			info: "",
+			level: 0,
+			loading: true,
+			meta: null
+		},
+		{
+			type: "thead_open",
+			tag: "thead",
+			attrs: null,
+			block: true,
+			level: 1,
+			children: null
+		},
+		{
+			type: "tr_open",
+			tag: "tr",
+			attrs: null,
+			block: true,
+			level: 2,
+			children: null
+		}
+	];
+}
+function createEnd() {
+	return [
+		{
+			type: "tr_close",
+			tag: "tr",
+			attrs: null,
+			block: true,
+			level: 2,
+			children: null
+		},
+		{
+			type: "thead_close",
+			tag: "thead",
+			attrs: null,
+			block: true,
+			level: 1,
+			children: null
+		},
+		{
+			type: "table_close",
+			tag: "table",
+			attrs: null,
+			map: null,
+			children: null,
+			content: "",
+			markup: "",
+			info: "",
+			level: 0,
+			meta: null
+		}
+	];
+}
+function createTh(text) {
+	return [
+		{
+			type: "th_open",
+			tag: "th",
+			attrs: null,
+			block: true,
+			level: 3,
+			children: null
+		},
+		{
+			type: "inline",
+			tag: "",
+			children: [{
+				tag: "",
+				type: "text",
+				block: false,
+				content: text,
+				children: null
+			}],
+			content: text,
+			level: 4,
+			attrs: null,
+			block: true
+		},
+		{
+			type: "th_close",
+			tag: "th",
+			attrs: null,
+			block: true,
+			level: 3,
+			children: null
+		}
+	];
+}
+function fixTableTokens(tokens) {
+	const fixedTokens = [...tokens];
+	if (tokens.length < 3) return fixedTokens;
+	const i = tokens.length - 2;
+	const token = tokens[i];
+	if (token.type === "inline") {
+		const tcontent = String(token.content ?? "");
+		const childContent = String(token.children?.[0]?.content ?? "");
+		if (/^\|(?:[^|\n]+\|?)+/.test(tcontent)) {
+			const body = childContent.slice(1).split("|").map((i$1) => i$1.trim()).filter(Boolean).flatMap((i$1) => createTh(i$1));
+			const insert = [
+				...createStart(),
+				...body,
+				...createEnd()
+			];
+			fixedTokens.splice(i - 1, 3, ...insert);
+		} else if (/^\|(?:[^|\n]+\|)+\n\|:?-/.test(tcontent)) {
+			const body = childContent.slice(1, -1).split("|").map((i$1) => i$1.trim()).flatMap((i$1) => createTh(i$1));
+			const insert = [
+				...createStart(),
+				...body,
+				...createEnd()
+			];
+			fixedTokens.splice(i - 1, 3, ...insert);
+		} else if (/^\|(?:[^|\n:]+\|)+\n\|:?$/.test(tcontent)) {
+			token.content = tcontent.slice(0, -2);
+			token.children.splice(2, 1);
+		}
+	}
+	return fixedTokens;
+}
+
+//#endregion
+//#region src/plugins/fixTableTokens.ts
+function applyFixTableTokens(md) {
+	md.core.ruler.after("block", "fix_table_tokens", (state) => {
+		const s = state;
+		try {
+			const fixed = fixTableTokens(s.tokens ?? []);
+			if (Array.isArray(fixed)) s.tokens = fixed;
+		} catch (e) {
+			console.error("[applyFixTableTokens] failed to fix table tokens", e);
+		}
+	});
+}
+
 //#endregion
 //#region src/findMatchingClose.ts
 function findMatchingClose(src, startIdx, open, close) {
@@ -278,7 +704,8 @@ function normalizeStandaloneBackslashT(s, opts) {
 }
 function applyMath(md, mathOpts) {
 	const mathInline = (state, silent) => {
-		if (/^\*[^*]+/.test(state.src)) return false;
+		const s = state;
+		if (/^\*[^*]+/.test(s.src)) return false;
 		const delimiters = [
 			["$$", "$$"],
 			["\\(", "\\)"],
@@ -287,28 +714,28 @@ function applyMath(md, mathOpts) {
 		let searchPos = 0;
 		let preMathPos = 0;
 		for (const [open, close] of delimiters) {
-			const src = state.src;
+			const src = s.src;
 			let foundAny = false;
 			const pushText = (text) => {
 				if (text === "undefined" || text == null) text = "";
 				if (text === "\\") {
-					state.pos = state.pos + text.length;
-					searchPos = state.pos;
+					s.pos = s.pos + text.length;
+					searchPos = s.pos;
 					return;
 				}
 				if (text === "\\)" || text === "\\(") {
-					const t$1 = state.push("text_special", "", 0);
+					const t$1 = s.push("text_special", "", 0);
 					t$1.content = text === "\\)" ? ")" : "(";
 					t$1.markup = text;
-					state.pos = state.pos + text.length;
-					searchPos = state.pos;
+					s.pos = s.pos + text.length;
+					searchPos = s.pos;
 					return;
 				}
 				if (!text) return;
-				const t = state.push("text", "", 0);
+				const t = s.push("text", "", 0);
 				t.content = text;
-				state.pos = state.pos + text.length;
-				searchPos = state.pos;
+				s.pos = s.pos + text.length;
+				searchPos = s.pos;
 			};
 			while (true) {
 				if (searchPos >= src.length) break;
@@ -326,28 +753,28 @@ function applyMath(md, mathOpts) {
 						searchPos = index + open.length;
 						foundAny = true;
 						if (!silent) {
-							state.pending = "";
+							s.pending = "";
 							const isStrongPrefix = countUnescapedStrong(preMathPos ? src.slice(preMathPos, searchPos) : src.slice(0, searchPos)) % 2 === 1;
 							if (preMathPos) pushText(src.slice(preMathPos, searchPos));
 							else pushText(src.slice(0, searchPos));
 							if (isStrongPrefix) {
-								const strongToken = state.push("strong_open", "", 0);
+								const strongToken = s.push("strong_open", "", 0);
 								strongToken.markup = src.slice(0, index + 2);
-								const token = state.push("math_inline", "math", 0);
+								const token = s.push("math_inline", "math", 0);
 								token.content = normalizeStandaloneBackslashT(content$1, mathOpts);
 								token.markup = open === "$$" ? "$$" : open === "\\(" ? "\\(\\)" : open === "$" ? "$" : "()";
 								token.raw = `${open}${content$1}${close}`;
 								token.loading = true;
 								strongToken.content = content$1;
-								state.push("strong_close", "", 0);
+								s.push("strong_close", "", 0);
 							} else {
-								const token = state.push("math_inline", "math", 0);
+								const token = s.push("math_inline", "math", 0);
 								token.content = normalizeStandaloneBackslashT(content$1, mathOpts);
 								token.markup = open === "$$" ? "$$" : open === "\\(" ? "\\(\\)" : open === "$" ? "$" : "()";
 								token.raw = `${open}${content$1}${close}`;
 								token.loading = true;
 							}
-							state.pos = src.length;
+							s.pos = src.length;
 						}
 						searchPos = src.length;
 						preMathPos = searchPos;
@@ -357,8 +784,8 @@ function applyMath(md, mathOpts) {
 				const content = src.slice(index + open.length, endIdx);
 				if (!isMathLike(content)) {
 					searchPos = endIdx + close.length;
-					const text = src.slice(state.pos, searchPos);
-					if (!state.pending) pushText(text);
+					const text = src.slice(s.pos, searchPos);
+					if (!s.pending) pushText(text);
 					continue;
 				}
 				foundAny = true;
@@ -366,42 +793,42 @@ function applyMath(md, mathOpts) {
 					const before = src.slice(0, index);
 					let toPushBefore = src.slice(0, searchPos) ? src.slice(preMathPos, index) : before;
 					const isStrongPrefix = countUnescapedStrong(toPushBefore) % 2 === 1;
-					if (index !== state.pos && isStrongPrefix) toPushBefore = state.pending + src.slice(state.pos, index);
-					if (state.pending !== toPushBefore) {
-						state.pending = "";
+					if (index !== s.pos && isStrongPrefix) toPushBefore = s.pending + src.slice(s.pos, index);
+					if (s.pending !== toPushBefore) {
+						s.pending = "";
 						if (isStrongPrefix) {
 							const _match = toPushBefore.match(/(\*+)/);
 							const after = toPushBefore.slice(_match.index + _match[0].length);
 							pushText(toPushBefore.slice(0, _match.index));
-							const strongToken = state.push("strong_open", "", 0);
+							const strongToken = s.push("strong_open", "", 0);
 							strongToken.markup = _match[0];
-							const textToken = state.push("text", "", 0);
+							const textToken = s.push("text", "", 0);
 							textToken.content = after;
-							state.push("strong_close", "", 0);
+							s.push("strong_close", "", 0);
 						} else pushText(toPushBefore);
 					}
 					if (isStrongPrefix) {
-						const strongToken = state.push("strong_open", "", 0);
+						const strongToken = s.push("strong_open", "", 0);
 						strongToken.markup = "**";
-						const token = state.push("math_inline", "math", 0);
+						const token = s.push("math_inline", "math", 0);
 						token.content = normalizeStandaloneBackslashT(content, mathOpts);
 						token.markup = open === "$$" ? "$$" : open === "\\(" ? "\\(\\)" : open === "$" ? "$" : "()";
 						token.raw = `${open}${content}${close}`;
 						token.loading = false;
 						const raw = src.slice(endIdx + close.length);
 						const isBeforeClose = raw.startsWith("*");
-						if (isBeforeClose) state.push("strong_close", "", 0);
+						if (isBeforeClose) s.push("strong_close", "", 0);
 						if (raw) {
-							const textContentToken = state.push("text", "", 0);
+							const textContentToken = s.push("text", "", 0);
 							textContentToken.content = (raw == null ? "" : String(raw)).replace(/^\*+/, "");
 						}
-						if (!isBeforeClose) state.push("strong_close", "", 0);
-						state.pos = src.length;
+						if (!isBeforeClose) s.push("strong_close", "", 0);
+						s.pos = src.length;
 						searchPos = src.length;
 						preMathPos = searchPos;
 						continue;
 					} else {
-						const token = state.push("math_inline", "math", 0);
+						const token = s.push("math_inline", "math", 0);
 						token.content = normalizeStandaloneBackslashT(content, mathOpts);
 						token.markup = open === "$$" ? "$$" : open === "\\(" ? "\\(\\)" : open === "$" ? "$" : "()";
 						token.raw = `${open}${content}${close}`;
@@ -410,26 +837,27 @@ function applyMath(md, mathOpts) {
 				}
 				searchPos = endIdx + close.length;
 				preMathPos = searchPos;
-				state.pos = searchPos;
+				s.pos = searchPos;
 			}
 			if (foundAny) {
 				if (!silent) {
 					if (searchPos < src.length) pushText(src.slice(searchPos));
-					state.pos = src.length;
-				} else state.pos = searchPos;
+					s.pos = src.length;
+				} else s.pos = searchPos;
 				return true;
 			}
 		}
 		return false;
 	};
 	const mathBlock = (state, startLine, endLine, silent) => {
+		const s = state;
 		const delimiters = [
 			["\\[", "\\]"],
 			["[", "]"],
 			["$$", "$$"]
 		];
-		const startPos = state.bMarks[startLine] + state.tShift[startLine];
-		const lineText = state.src.slice(startPos, state.eMarks[startLine]).trim();
+		const startPos = s.bMarks[startLine] + s.tShift[startLine];
+		const lineText = s.src.slice(startPos, s.eMarks[startLine]).trim();
 		let matched = false;
 		let openDelim = "";
 		let closeDelim = "";
@@ -455,14 +883,14 @@ function applyMath(md, mathOpts) {
 			const startDelimIndex = lineText.indexOf(openDelim);
 			const endDelimIndex = lineText.indexOf(closeDelim, startDelimIndex + openDelim.length);
 			const content$1 = lineText.slice(startDelimIndex + openDelim.length, endDelimIndex);
-			const token$1 = state.push("math_block", "math", 0);
+			const token$1 = s.push("math_block", "math", 0);
 			token$1.content = normalizeStandaloneBackslashT(content$1);
 			token$1.markup = openDelim === "$$" ? "$$" : openDelim === "[" ? "[]" : "\\[\\]";
 			token$1.map = [startLine, startLine + 1];
 			token$1.raw = `${openDelim}${content$1}${closeDelim}`;
 			token$1.block = true;
 			token$1.loading = false;
-			state.line = startLine + 1;
+			s.line = startLine + 1;
 			return true;
 		}
 		let nextLine = startLine;
@@ -476,233 +904,114 @@ function applyMath(md, mathOpts) {
 			nextLine = startLine;
 		} else {
 			if (firstLineContent) content = firstLineContent;
-			for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
-				const lineStart = state.bMarks[nextLine] + state.tShift[nextLine];
-				const lineEnd = state.eMarks[nextLine];
-				const currentLine = state.src.slice(lineStart - 1, lineEnd);
-				if (currentLine.trim() === closeDelim) {
-					found = true;
-					break;
-				} else if (currentLine.includes(closeDelim)) {
-					found = true;
-					const endIndex = currentLine.indexOf(closeDelim);
-					content += (content ? "\n" : "") + currentLine.slice(0, endIndex);
-					break;
-				}
-				content += (content ? "\n" : "") + currentLine;
-			}
-		}
-		const token = state.push("math_block", "math", 0);
-		token.content = normalizeStandaloneBackslashT(content);
-		token.markup = openDelim === "$$" ? "$$" : openDelim === "[" ? "[]" : "\\[\\]";
-		token.raw = `${openDelim}${content}${content.startsWith("\n") ? "\n" : ""}${closeDelim}`;
-		token.map = [startLine, nextLine + 1];
-		token.block = true;
-		token.loading = !found;
-		state.line = nextLine + 1;
-		return true;
-	};
-	md.inline.ruler.before("escape", "math", mathInline);
-	md.block.ruler.before("paragraph", "math_block", mathBlock, { alt: [
-		"paragraph",
-		"reference",
-		"blockquote",
-		"list"
-	] });
-}
-
-//#endregion
-//#region src/renderers/index.ts
-function applyRenderRules(md) {
-	const defaultImage = md.renderer.rules.image || function(tokens, idx, options, env, self) {
-		return self.renderToken(tokens, idx, options);
-	};
-	md.renderer.rules.image = (tokens, idx, options, env, self) => {
-		tokens[idx].attrSet?.("loading", "lazy");
-		return defaultImage(tokens, idx, options, env, self);
-	};
-	md.renderer.rules.fence = md.renderer.rules.fence || ((tokens, idx) => {
-		const token = tokens[idx];
-		const info = token.info ? token.info.trim() : "";
-		return `<pre class="${info ? `language-${md.utils.escapeHtml(info.split(/\s+/g)[0])}` : ""}"><code>${md.utils.escapeHtml(token.content)}</code></pre>`;
-	});
-}
-
-//#endregion
-//#region src/factory.ts
-function factory(opts = {}) {
-	const md = new MarkdownIt({
-		html: true,
-		linkify: true,
-		typographer: true,
-		...opts.markdownItOptions ?? {}
-	});
-	if (opts.enableMath ?? true) applyMath(md, {
-		...getDefaultMathOptions() ?? {},
-		...opts.mathOptions ?? {}
-	});
-	if (opts.enableContainers ?? true) applyContainers(md);
-	applyRenderRules(md);
-	return md;
-}
-
-//#endregion
-//#region src/parser/fixTableTokens.ts
-function createStart() {
-	return [
-		{
-			type: "table_open",
-			tag: "table",
-			attrs: null,
-			map: null,
-			children: null,
-			content: "",
-			markup: "",
-			info: "",
-			level: 0,
-			loading: true,
-			meta: null
-		},
-		{
-			type: "thead_open",
-			tag: "thead",
-			attrs: null,
-			block: true,
-			level: 1,
-			children: null
-		},
-		{
-			type: "tr_open",
-			tag: "tr",
-			attrs: null,
-			block: true,
-			level: 2,
-			children: null
-		}
-	];
-}
-function createEnd() {
-	return [
-		{
-			type: "tr_close",
-			tag: "tr",
-			attrs: null,
-			block: true,
-			level: 2,
-			children: null
-		},
-		{
-			type: "thead_close",
-			tag: "thead",
-			attrs: null,
-			block: true,
-			level: 1,
-			children: null
-		},
-		{
-			type: "table_close",
-			tag: "table",
-			attrs: null,
-			map: null,
-			children: null,
-			content: "",
-			markup: "",
-			info: "",
-			level: 0,
-			meta: null
-		}
-	];
-}
-function createTh(text) {
-	return [
-		{
-			type: "th_open",
-			tag: "th",
-			attrs: null,
-			block: true,
-			level: 3,
-			children: null
-		},
-		{
-			type: "inline",
-			tag: "",
-			children: [{
-				tag: "",
-				type: "text",
-				block: false,
-				content: text,
-				children: null
-			}],
-			content: text,
-			level: 4,
-			attrs: null,
-			block: true
-		},
-		{
-			type: "th_close",
-			tag: "th",
-			attrs: null,
-			block: true,
-			level: 3,
-			children: null
-		}
-	];
-}
-function fixTableTokens(tokens) {
-	const fixedTokens = [...tokens];
-	if (tokens.length < 3) return fixedTokens;
-	const i = tokens.length - 2;
-	const token = tokens[i];
-	if (token.type === "inline") {
-		if (/^\|(?:[^|\n]+\|?)+/.test(token.content)) {
-			const body = token.children[0].content.slice(1).split("|").map((i$1) => i$1.trim()).filter(Boolean).flatMap((i$1) => createTh(i$1));
-			const insert = [
-				...createStart(),
-				...body,
-				...createEnd()
-			];
-			fixedTokens.splice(i - 1, 3, ...insert);
-		} else if (/^\|(?:[^|\n]+\|)+\n\|:?-/.test(token.content)) {
-			const body = token.children[0].content.slice(1, -1).split("|").map((i$1) => i$1.trim()).flatMap((i$1) => createTh(i$1));
-			const insert = [
-				...createStart(),
-				...body,
-				...createEnd()
-			];
-			fixedTokens.splice(i - 1, 3, ...insert);
-		} else if (/^\|(?:[^|\n:]+\|)+\n\|:?$/.test(token.content)) {
-			token.content = token.content.slice(0, -2);
-			token.children.splice(2, 1);
+			for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
+				const lineStart = s.bMarks[nextLine] + s.tShift[nextLine];
+				const lineEnd = s.eMarks[nextLine];
+				const currentLine = s.src.slice(lineStart - 1, lineEnd);
+				if (currentLine.trim() === closeDelim) {
+					found = true;
+					break;
+				} else if (currentLine.includes(closeDelim)) {
+					found = true;
+					const endIndex = currentLine.indexOf(closeDelim);
+					content += (content ? "\n" : "") + currentLine.slice(0, endIndex);
+					break;
+				}
+				content += (content ? "\n" : "") + currentLine;
+			}
 		}
-	}
-	return fixedTokens;
+		const token = s.push("math_block", "math", 0);
+		token.content = normalizeStandaloneBackslashT(content);
+		token.markup = openDelim === "$$" ? "$$" : openDelim === "[" ? "[]" : "\\[\\]";
+		token.raw = `${openDelim}${content}${content.startsWith("\n") ? "\n" : ""}${closeDelim}`;
+		token.map = [startLine, nextLine + 1];
+		token.block = true;
+		token.loading = !found;
+		s.line = nextLine + 1;
+		return true;
+	};
+	md.inline.ruler.before("escape", "math", mathInline);
+	md.block.ruler.before("paragraph", "math_block", mathBlock, { alt: [
+		"paragraph",
+		"reference",
+		"blockquote",
+		"list"
+	] });
+}
+
+//#endregion
+//#region src/renderers/index.ts
+function applyRenderRules(md) {
+	const defaultImage = md.renderer.rules.image || function(tokens, idx, options, env, self) {
+		const tokensAny = tokens;
+		const selfShape = self;
+		return selfShape.renderToken ? selfShape.renderToken(tokensAny, idx, options) : "";
+	};
+	md.renderer.rules.image = (tokens, idx, options, env, self) => {
+		const tokensAny = tokens;
+		tokensAny[idx].attrSet?.("loading", "lazy");
+		return defaultImage(tokensAny, idx, options, env, self);
+	};
+	md.renderer.rules.fence = md.renderer.rules.fence || ((tokens, idx) => {
+		const tokenShape = tokens[idx];
+		const info = String(tokenShape.info ?? "").trim();
+		return `<pre class="${info ? `language-${md.utils.escapeHtml(info.split(/\s+/g)[0])}` : ""}"><code>${md.utils.escapeHtml(String(tokenShape.content ?? ""))}</code></pre>`;
+	});
+}
+
+//#endregion
+//#region src/factory.ts
+function factory(opts = {}) {
+	const md = new MarkdownIt({
+		html: true,
+		linkify: true,
+		typographer: true,
+		...opts.markdownItOptions ?? {}
+	});
+	if (opts.enableMath ?? true) applyMath(md, {
+		...getDefaultMathOptions() ?? {},
+		...opts.mathOptions ?? {}
+	});
+	if (opts.enableContainers ?? true) applyContainers(md);
+	applyFixLinkInline(md);
+	applyFixLinkTokens(md);
+	applyFixStrongTokens(md);
+	applyFixListItem(md);
+	applyFixTableTokens(md);
+	applyRenderRules(md);
+	return md;
 }
 
 //#endregion
 //#region src/parser/inline-parsers/checkbox-parser.ts
 function parseCheckboxToken(token) {
+	const tokenMeta = token.meta ?? {};
 	return {
 		type: "checkbox",
-		checked: token.meta?.checked === true,
-		raw: token.meta?.checked ? "[x]" : "[ ]"
+		checked: tokenMeta.checked === true,
+		raw: tokenMeta.checked ? "[x]" : "[ ]"
 	};
 }
 function parseCheckboxInputToken(token) {
+	const tokenAny = token;
+	const rawAttr = tokenAny.attrGet ? tokenAny.attrGet("checked") : void 0;
+	const checked = rawAttr === "" || rawAttr === "true";
 	return {
 		type: "checkbox_input",
-		checked: token.attrGet("checked") === "" || token.attrGet("checked") === "true",
-		raw: token.attrGet("checked") === "" || token.attrGet("checked") === "true" ? "[x]" : "[ ]"
+		checked,
+		raw: checked ? "[x]" : "[ ]"
 	};
 }
 
 //#endregion
 //#region src/parser/inline-parsers/emoji-parser.ts
 function parseEmojiToken(token) {
+	const name = String(token.content ?? "");
 	return {
 		type: "emoji",
-		name: token.content || "",
-		markup: token.markup || "",
-		raw: `:${token.content || ""}:`
+		name,
+		markup: String(token.markup ?? ""),
+		raw: `:${name}:`
 	};
 }
 
@@ -714,7 +1023,7 @@ function parseEmphasisToken(tokens, startIndex) {
 	let i = startIndex + 1;
 	const innerTokens = [];
 	while (i < tokens.length && tokens[i].type !== "em_close") {
-		emText += tokens[i].content || "";
+		emText += String(tokens[i].content ?? "");
 		innerTokens.push(tokens[i]);
 		i++;
 	}
@@ -730,244 +1039,66 @@ function parseEmphasisToken(tokens, startIndex) {
 }
 
 //#endregion
-//#region src/parser/inline-parsers/fence-parser.ts
-function splitUnifiedDiff(content) {
-	const orig = [];
-	const updated = [];
-	for (const rawLine of content.split(/\r?\n/)) {
-		const line = rawLine;
-		if (/^(?:diff |index |--- |\+\+\+ |@@ )/.test(line)) continue;
-		if (line.startsWith("- ")) orig.push(` ${line.slice(1)}`);
-		else if (line.startsWith("+ ")) updated.push(` ${line.slice(1)}`);
-		else {
-			orig.push(line);
-			updated.push(line);
-		}
-	}
-	return {
-		original: orig.join("\n"),
-		updated: updated.join("\n")
-	};
-}
-function parseFenceToken(token) {
-	const hasMap = Array.isArray(token.map) && token.map.length === 2;
-	const meta = token.meta;
-	const closed = typeof meta?.closed === "boolean" ? meta.closed : void 0;
-	const diff = token.info?.startsWith("diff") || false;
-	const language = diff ? token.info?.split(" ")[1] || "" : token.info || "";
-	let content = token.content || "";
-	const trailingFenceLine = /\r?\n[ \t]*`+\s*$/;
-	if (trailingFenceLine.test(content)) content = content.replace(trailingFenceLine, "");
-	if (diff) {
-		const { original, updated } = splitUnifiedDiff(content);
-		return {
-			type: "code_block",
-			language,
-			code: updated || "",
-			raw: content,
-			diff,
-			loading: closed === true ? false : closed === false ? true : !hasMap,
-			originalCode: original,
-			updatedCode: updated
-		};
-	}
-	return {
-		type: "code_block",
-		language,
-		code: content || "",
-		raw: content || "",
-		diff,
-		loading: closed === true ? false : closed === false ? true : !hasMap
-	};
-}
-
-//#endregion
-//#region src/parser/inline-parsers/fixLinkToken.ts
-function isTextToken(t) {
-	return !!t && t.type === "text" && typeof t.content === "string";
-}
-function fixLinkToken(tokens) {
-	tokens = fixLinkToken4(fixLinkToken3(tokens));
-	if (tokens.length < 5) return tokens;
-	const first = tokens[tokens.length - 5];
-	if (first.type !== "text" || !first.content?.endsWith("[")) return fixLinkTokens2(tokens);
-	if (tokens[tokens.length - 4].tag !== "em") return fixLinkTokens2(tokens);
-	const last = tokens[tokens.length - 1];
-	if (last?.type === "text" && !last.content?.startsWith("]")) return fixLinkTokens2(tokens);
-	const third = tokens[tokens.length - 3];
-	const lastContent = last.content ?? "";
-	const href = lastContent.replace(/^\]\(*/, "");
-	const loading = !lastContent.includes(")");
-	first.content = first.content?.replace(/\[$/, "");
-	tokens.splice(tokens.length - 3, 1, {
-		type: "link",
-		href,
-		text: third.content,
-		children: [{
-			type: "text",
-			content: third.content,
-			raw: third.content
-		}],
-		loading
-	});
-	tokens.splice(tokens.length - 1, 1);
-	return tokens;
-}
-function fixLinkTokens2(tokens) {
-	if (tokens.length < 8) return tokens;
-	let length = tokens.length;
-	let last = tokens[length - 1];
-	if (last.type !== "link_close") {
-		length--;
-		last = tokens[length - 1];
-		if (last.type !== "link_close") return tokens;
-	}
-	if (tokens[length - 7].type !== "em_open") return tokens;
-	const third = tokens[length - 6];
-	const first = tokens[length - 8];
-	if (first.type !== "text") return tokens;
-	let href = tokens[length - 2].content ?? "";
-	let count = 4;
-	if (length !== tokens.length) {
-		href += last.content || "";
-		count++;
-	}
-	tokens.splice(length - 4, count);
-	const content = third.content;
-	length -= 4;
-	first.content = first.content?.replace(/\[$/, "");
-	tokens.splice(length - 2, 1, {
-		type: "link",
-		href,
-		text: content,
-		children: [{
-			type: "text",
-			content,
-			raw: content
-		}],
-		loading: true
-	});
-	return tokens;
-}
-function fixLinkToken3(tokens) {
-	const last = tokens[tokens.length - 1];
-	const preLast = tokens[tokens.length - 2];
-	const fixedTokens = [...tokens];
-	if (last.type !== "text" || !last.content?.startsWith(")")) return tokens;
-	if (preLast.type !== "link_close") return tokens;
-	if (isTextToken(tokens[tokens.length - 5]) && tokens[tokens.length - 5].content?.endsWith("(")) {
-		const content = tokens[tokens.length - 5].content + tokens[tokens.length - 3].content + last.content;
-		fixedTokens.splice(tokens.length - 5, 5, {
-			type: "text",
-			content,
-			raw: content
-		});
-	} else {
-		const lc = (last.content ?? "").slice(1);
-		fixedTokens[fixedTokens.length - 1] = {
-			...last,
-			content: lc
-		};
-	}
-	return fixedTokens;
-}
-function fixLinkToken4(tokens) {
-	const fixedTokens = [...tokens];
-	for (let i = tokens.length - 1; i >= 3; i--) if (tokens[i].type === "link_close") {
-		if (tokens[i - 3]?.content?.endsWith("(")) {
-			const nextToken = tokens[i + 1];
-			if (nextToken?.type === "text") {
-				if (tokens[i - 1].type === "text" && tokens[i - 3].type === "text") {
-					const content = tokens[i - 3].content + tokens[i - 1].content + nextToken.content;
-					fixedTokens.splice(i - 3, 5, {
-						type: "text",
-						content,
-						raw: content
-					});
-					i -= 3;
-				}
-			} else {
-				if (tokens[i - 1].type === "text" && tokens[i - 3].type === "text") {
-					const content = tokens[i - 3].content + tokens[i - 1].content;
-					fixedTokens.splice(i - 3, 4, {
-						type: "text",
-						content,
-						raw: content
-					});
-				}
-				i -= 3;
-			}
-		}
-	}
-	return fixedTokens;
-}
-
-//#endregion
-//#region src/parser/inline-parsers/fixListItem.ts
-function fixListItem(tokens) {
-	const last = tokens[tokens.length - 1];
-	if (last?.type === "text" && /^\s*\d+\.\s*$/.test(last.content || "") && tokens[tokens.length - 2]?.tag === "br") tokens.splice(tokens.length - 1, 1);
-	return tokens;
-}
-
-//#endregion
-//#region src/parser/inline-parsers/fixStrongTokens.ts
-function fixStrongTokens(tokens) {
-	const fixedTokens = [...tokens];
-	if (tokens.length < 4) return fixedTokens;
-	const i = tokens.length - 4;
-	const token = tokens[i];
-	const nextToken = tokens[i + 1];
-	if (token.type === "text" && token.content?.endsWith("*") && nextToken.type === "em_open") {
-		const _nextToken = tokens[i + 2];
-		const count = _nextToken?.type === "text" ? 4 : 3;
-		const insert = [
-			{
-				type: "strong_open",
-				tag: "strong",
-				attrs: null,
-				map: null,
-				children: null,
-				content: "",
-				markup: "**",
-				info: "",
-				meta: null
-			},
-			{
-				type: "text",
-				content: _nextToken?.type === "text" ? _nextToken.content : ""
-			},
-			{
-				type: "strong_close",
-				tag: "strong",
-				attrs: null,
-				map: null,
-				children: null,
-				content: "",
-				markup: "**",
-				info: "",
-				meta: null
-			}
-		];
-		const beforeText = token.content?.slice(0, -1);
-		if (beforeText) insert.unshift({
-			type: "text",
-			content: beforeText,
-			raw: beforeText
-		});
-		fixedTokens.splice(i, count, ...insert);
-		return fixedTokens;
+//#region src/parser/inline-parsers/fence-parser.ts
+function splitUnifiedDiff(content) {
+	const orig = [];
+	const updated = [];
+	for (const rawLine of content.split(/\r?\n/)) {
+		const line = rawLine;
+		if (/^(?:diff |index |--- |\+\+\+ |@@ )/.test(line)) continue;
+		if (line.startsWith("- ")) orig.push(` ${line.slice(1)}`);
+		else if (line.startsWith("+ ")) updated.push(` ${line.slice(1)}`);
+		else {
+			orig.push(line);
+			updated.push(line);
+		}
 	}
-	return fixedTokens;
+	return {
+		original: orig.join("\n"),
+		updated: updated.join("\n")
+	};
+}
+function parseFenceToken(token) {
+	const hasMap = Array.isArray(token.map) && token.map.length === 2;
+	const tokenMeta = token.meta ?? {};
+	const closed = typeof tokenMeta.closed === "boolean" ? tokenMeta.closed : void 0;
+	const info = String(token.info ?? "");
+	const diff = info.startsWith("diff");
+	const language = diff ? String(info.split(" ")[1] ?? "") : info;
+	let content = String(token.content ?? "");
+	const trailingFenceLine = /\r?\n[ \t]*`+\s*$/;
+	if (trailingFenceLine.test(content)) content = content.replace(trailingFenceLine, "");
+	if (diff) {
+		const { original, updated } = splitUnifiedDiff(content);
+		return {
+			type: "code_block",
+			language,
+			code: String(updated ?? ""),
+			raw: String(content ?? ""),
+			diff,
+			loading: closed === true ? false : closed === false ? true : !hasMap,
+			originalCode: original,
+			updatedCode: updated
+		};
+	}
+	return {
+		type: "code_block",
+		language,
+		code: String(content ?? ""),
+		raw: String(content ?? ""),
+		diff,
+		loading: closed === true ? false : closed === false ? true : !hasMap
+	};
 }
 
 //#endregion
 //#region src/parser/inline-parsers/footnote-ref-parser.ts
 function parseFootnoteRefToken(token) {
+	const tokenMeta = token.meta ?? {};
 	return {
 		type: "footnote_reference",
-		id: token.meta?.label || "",
-		raw: `[^${token.meta?.label || ""}]`
+		id: String(tokenMeta.label ?? ""),
+		raw: `[^${String(tokenMeta.label ?? "")}]`
 	};
 }
 
@@ -988,7 +1119,7 @@ function parseHighlightToken(tokens, startIndex) {
 	let i = startIndex + 1;
 	const innerTokens = [];
 	while (i < tokens.length && tokens[i].type !== "mark_close") {
-		markText += tokens[i].content || "";
+		markText += String(tokens[i].content ?? "");
 		innerTokens.push(tokens[i]);
 		i++;
 	}
@@ -1006,12 +1137,33 @@ function parseHighlightToken(tokens, startIndex) {
 //#endregion
 //#region src/parser/inline-parsers/image-parser.ts
 function parseImageToken(token, loading = false) {
+	let attrs = token.attrs ?? [];
+	let childWithAttrs = null;
+	if ((!attrs || attrs.length === 0) && Array.isArray(token.children)) for (const child of token.children) {
+		const childAttrs = child?.attrs;
+		if (Array.isArray(childAttrs) && childAttrs.length > 0) {
+			attrs = childAttrs;
+			childWithAttrs = child;
+			break;
+		}
+	}
+	const src = String(attrs.find((attr) => attr[0] === "src")?.[1] ?? "");
+	const altAttr = attrs.find((attr) => attr[0] === "alt")?.[1];
+	let alt = "";
+	if (altAttr != null && String(altAttr).length > 0) alt = String(altAttr);
+	else if (childWithAttrs?.content != null && String(childWithAttrs.content).length > 0) alt = String(childWithAttrs.content);
+	else if (Array.isArray(childWithAttrs?.children) && childWithAttrs.children[0]?.content) alt = String(childWithAttrs.children[0].content);
+	else if (Array.isArray(token.children) && token.children[0]?.content) alt = String(token.children[0].content);
+	else if (token.content != null && String(token.content).length > 0) alt = String(token.content);
+	const _title = attrs.find((attr) => attr[0] === "title")?.[1] ?? null;
+	const title = _title === null ? null : String(_title);
+	const raw = String(token.content ?? "");
 	return {
 		type: "image",
-		src: token.attrs?.find((attr) => attr[0] === "src")?.[1] || "",
-		alt: token.attrs?.find((attr) => attr[0] === "alt")?.[1] || "",
-		title: token.attrs?.find((attr) => attr[0] === "title")?.[1] || null,
-		raw: token.content || "",
+		src,
+		alt,
+		title,
+		raw,
 		loading
 	};
 }
@@ -1019,10 +1171,11 @@ function parseImageToken(token, loading = false) {
 //#endregion
 //#region src/parser/inline-parsers/inline-code-parser.ts
 function parseInlineCodeToken(token) {
+	const code = String(token.content ?? "");
 	return {
 		type: "inline_code",
-		code: token.content || "",
-		raw: token.content || ""
+		code,
+		raw: code
 	};
 }
 
@@ -1034,7 +1187,7 @@ function parseInsertToken(tokens, startIndex) {
 	let i = startIndex + 1;
 	const innerTokens = [];
 	while (i < tokens.length && tokens[i].type !== "ins_close") {
-		insText += tokens[i].content || "";
+		insText += String(tokens[i].content ?? "");
 		innerTokens.push(tokens[i]);
 		i++;
 	}
@@ -1043,7 +1196,7 @@ function parseInsertToken(tokens, startIndex) {
 		node: {
 			type: "insert",
 			children,
-			raw: `++${insText}++`
+			raw: `++${String(insText)}++`
 		},
 		nextIndex: i < tokens.length ? i + 1 : tokens.length
 	};
@@ -1052,9 +1205,10 @@ function parseInsertToken(tokens, startIndex) {
 //#endregion
 //#region src/parser/inline-parsers/link-parser.ts
 function parseLinkToken(tokens, startIndex) {
-	const openToken = tokens[startIndex];
-	const href = openToken.attrs?.find((attr) => attr[0] === "href")?.[1] || "";
-	const title = openToken.attrs?.find((attr) => attr[0] === "title")?.[1] || null;
+	const attrs = tokens[startIndex].attrs ?? [];
+	const href = String(attrs.find((attr) => attr[0] === "href")?.[1] ?? "");
+	const _title = attrs.find((attr) => attr[0] === "title")?.[1] ?? null;
+	const title = _title === null ? null : String(_title);
 	let i = startIndex + 1;
 	const linkTokens = [];
 	const loading = true;
@@ -1064,8 +1218,9 @@ function parseLinkToken(tokens, startIndex) {
 	}
 	const children = parseInlineTokens(linkTokens);
 	const linkText = children.map((node) => {
-		if ("content" in node) return node.content;
-		return node.raw;
+		const nodeAny = node;
+		if ("content" in node) return String(nodeAny.content ?? "");
+		return String(nodeAny.raw ?? "");
 	}).join("");
 	return {
 		node: {
@@ -1074,7 +1229,7 @@ function parseLinkToken(tokens, startIndex) {
 			title,
 			text: linkText,
 			children,
-			raw: `[${linkText}](${href}${title ? ` "${title}"` : ""})`,
+			raw: String(`[${linkText}](${href}${title ? ` "${title}"` : ""})`),
 			loading
 		},
 		nextIndex: i < tokens.length ? i + 1 : tokens.length
@@ -1086,7 +1241,7 @@ function parseLinkToken(tokens, startIndex) {
 function parseMathInlineToken(token) {
 	return {
 		type: "math_inline",
-		content: token.content || "",
+		content: String(token.content ?? ""),
 		loading: !!token.loading,
 		raw: token.raw
 	};
@@ -1097,8 +1252,8 @@ function parseMathInlineToken(token) {
 function parseReferenceToken(token) {
 	return {
 		type: "reference",
-		id: token.content || "",
-		raw: token.markup || `[${token.content}]`
+		id: String(token.content ?? ""),
+		raw: String(token.markup ?? `[${token.content ?? ""}]`)
 	};
 }
 
@@ -1110,7 +1265,7 @@ function parseStrikethroughToken(tokens, startIndex) {
 	let i = startIndex + 1;
 	const innerTokens = [];
 	while (i < tokens.length && tokens[i].type !== "s_close") {
-		sText += tokens[i].content || "";
+		sText += String(tokens[i].content ?? "");
 		innerTokens.push(tokens[i]);
 		i++;
 	}
@@ -1133,7 +1288,7 @@ function parseStrongToken(tokens, startIndex, raw) {
 	let i = startIndex + 1;
 	const innerTokens = [];
 	while (i < tokens.length && tokens[i].type !== "strong_close") {
-		strongText += tokens[i].content || "";
+		strongText += String(tokens[i].content ?? "");
 		innerTokens.push(tokens[i]);
 		i++;
 	}
@@ -1142,7 +1297,7 @@ function parseStrongToken(tokens, startIndex, raw) {
 		node: {
 			type: "strong",
 			children,
-			raw: `**${strongText}**`
+			raw: `**${String(strongText)}**`
 		},
 		nextIndex: i < tokens.length ? i + 1 : tokens.length
 	};
@@ -1156,20 +1311,22 @@ function parseSubscriptToken(tokens, startIndex) {
 	let i = startIndex + 1;
 	const innerTokens = [];
 	while (i < tokens.length && tokens[i].type !== "sub_close") {
-		subText += tokens[i].content || "";
+		subText += String(tokens[i].content ?? "");
 		innerTokens.push(tokens[i]);
 		i++;
 	}
 	children.push(...parseInlineTokens(innerTokens));
+	const startContent = String(tokens[startIndex].content ?? "");
+	const display = subText || startContent;
 	return {
 		node: {
 			type: "subscript",
 			children: children.length > 0 ? children : [{
 				type: "text",
-				content: subText || tokens[startIndex].content || "",
-				raw: subText || tokens[startIndex].content || ""
+				content: display,
+				raw: display
 			}],
-			raw: `~${subText || tokens[startIndex].content || ""}~`
+			raw: `~${display}~`
 		},
 		nextIndex: i < tokens.length ? i + 1 : tokens.length
 	};
@@ -1183,7 +1340,7 @@ function parseSuperscriptToken(tokens, startIndex) {
 	let i = startIndex + 1;
 	const innerTokens = [];
 	while (i < tokens.length && tokens[i].type !== "sup_close") {
-		supText += tokens[i].content || "";
+		supText += String(tokens[i].content ?? "");
 		innerTokens.push(tokens[i]);
 		i++;
 	}
@@ -1193,10 +1350,10 @@ function parseSuperscriptToken(tokens, startIndex) {
 			type: "superscript",
 			children: children.length > 0 ? children : [{
 				type: "text",
-				content: supText || tokens[startIndex].content || "",
-				raw: supText || tokens[startIndex].content || ""
+				content: supText || String(tokens[startIndex].content ?? ""),
+				raw: supText || String(tokens[startIndex].content ?? "")
 			}],
-			raw: `^${supText || tokens[startIndex].content || ""}^`
+			raw: `^${supText || String(tokens[startIndex].content ?? "")}^`
 		},
 		nextIndex: i < tokens.length ? i + 1 : tokens.length
 	};
@@ -1205,10 +1362,11 @@ function parseSuperscriptToken(tokens, startIndex) {
 //#endregion
 //#region src/parser/inline-parsers/text-parser.ts
 function parseTextToken(token) {
+	const content = String(token.content ?? "");
 	return {
 		type: "text",
-		content: token.content || "",
-		raw: token.content || ""
+		content,
+		raw: content
 	};
 }
 
@@ -1219,317 +1377,232 @@ function parseInlineTokens(tokens, raw, pPreToken) {
 	const result = [];
 	let currentTextNode = null;
 	let i = 0;
-	tokens = fixStrongTokens(tokens);
-	tokens = fixListItem(tokens);
-	tokens = fixLinkToken(tokens);
+	function resetCurrentTextNode() {
+		currentTextNode = null;
+	}
+	function handleEmphasisAndStrikethrough(content, token) {
+		if (/[^~]*~{2,}[^~]+/.test(content)) {
+			let idx = content.indexOf("~~");
+			if (idx === -1) idx = 0;
+			const _text = content.slice(0, idx);
+			if (_text) if (currentTextNode) {
+				currentTextNode.content += _text;
+				currentTextNode.raw += _text;
+			} else {
+				currentTextNode = {
+					type: "text",
+					content: String(_text ?? ""),
+					raw: String(token.content ?? "")
+				};
+				result.push(currentTextNode);
+			}
+			const { node } = parseStrikethroughToken([
+				{
+					type: "s_open",
+					tag: "s",
+					content: "",
+					markup: "*",
+					info: "",
+					meta: null
+				},
+				{
+					type: "text",
+					tag: "",
+					content: content.slice(idx).replace(/~/g, ""),
+					markup: "",
+					info: "",
+					meta: null
+				},
+				{
+					type: "s_close",
+					tag: "s",
+					content: "",
+					markup: "*",
+					info: "",
+					meta: null
+				}
+			], 0);
+			resetCurrentTextNode();
+			pushNode(node);
+			i++;
+			return true;
+		}
+		if (/\*\*/.test(content)) {
+			const openIdx = content.indexOf("**");
+			const beforeText = openIdx > -1 ? content.slice(0, openIdx) : "";
+			if (beforeText) pushText(beforeText, beforeText);
+			if (openIdx === -1) {
+				i++;
+				return true;
+			}
+			const exec = /\*\*([\s\S]*?)\*\*/.exec(content);
+			let inner = "";
+			let after = "";
+			if (exec && typeof exec.index === "number") {
+				inner = exec[1];
+				after = content.slice(exec.index + exec[0].length);
+			} else {
+				inner = content.slice(openIdx + 2);
+				after = "";
+			}
+			const { node } = parseStrongToken([
+				{
+					type: "strong_open",
+					tag: "strong",
+					content: "",
+					markup: "*",
+					info: "",
+					meta: null
+				},
+				{
+					type: "text",
+					tag: "",
+					content: inner,
+					markup: "",
+					info: "",
+					meta: null
+				},
+				{
+					type: "strong_close",
+					tag: "strong",
+					content: "",
+					markup: "*",
+					info: "",
+					meta: null
+				}
+			], 0, raw);
+			resetCurrentTextNode();
+			pushNode(node);
+			if (after) {
+				handleToken({
+					type: "text",
+					content: after,
+					raw: after
+				});
+				i--;
+			}
+			i++;
+			return true;
+		}
+		if (/[^*]*\*[^*]+/.test(content)) {
+			let idx = content.indexOf("*");
+			if (idx === -1) idx = 0;
+			const _text = content.slice(0, idx);
+			if (_text) if (currentTextNode) {
+				currentTextNode.content += _text;
+				currentTextNode.raw += _text;
+			} else {
+				currentTextNode = {
+					type: "text",
+					content: String(_text ?? ""),
+					raw: String(token.content ?? "")
+				};
+				result.push(currentTextNode);
+			}
+			const { node } = parseEmphasisToken([
+				{
+					type: "em_open",
+					tag: "em",
+					content: "",
+					markup: "*",
+					info: "",
+					meta: null
+				},
+				{
+					type: "text",
+					tag: "",
+					content: content.slice(idx).replace(/\*/g, ""),
+					markup: "",
+					info: "",
+					meta: null
+				},
+				{
+					type: "em_close",
+					tag: "em",
+					content: "",
+					markup: "*",
+					info: "",
+					meta: null
+				}
+			], 0);
+			resetCurrentTextNode();
+			pushNode(node);
+			i++;
+			return true;
+		}
+		return false;
+	}
+	function handleInlineCodeContent(content, _token) {
+		if (!/`[^`]*/.test(content)) return false;
+		resetCurrentTextNode();
+		const code_start = content.indexOf("`");
+		const code_end = content.indexOf("`", code_start + 1);
+		const _text = content.slice(0, code_start);
+		const codeContent = code_end === -1 ? content.slice(code_start) : content.slice(code_start, code_end);
+		const after = code_end === -1 ? "" : content.slice(code_end + 1);
+		if (_text) if (!handleEmphasisAndStrikethrough(_text, _token)) pushText(_text, _text);
+		else i--;
+		const code = codeContent.replace(/`/g, "");
+		pushParsed({
+			type: "inline_code",
+			code,
+			raw: String(code ?? "")
+		});
+		if (after) {
+			handleToken({
+				type: "text",
+				content: after,
+				raw: String(after ?? "")
+			});
+			i--;
+		} else if (code_end === -1) {
+			if (tokens[i + 1]) {
+				let fixedAfter = after;
+				for (let j = i + 1; j < tokens.length; j++) fixedAfter += String((tokens[j].content ?? "") + (tokens[j].markup ?? ""));
+				i = tokens.length - 1;
+				handleToken({
+					type: "text",
+					content: fixedAfter,
+					raw: String(fixedAfter ?? "")
+				});
+			}
+		}
+		i++;
+		return true;
+	}
+	function pushParsed(node) {
+		resetCurrentTextNode();
+		result.push(node);
+	}
+	function pushToken(token) {
+		resetCurrentTextNode();
+		result.push(token);
+	}
+	function pushNode(node) {
+		pushParsed(node);
+	}
+	function pushText(content, raw$1) {
+		if (currentTextNode) {
+			currentTextNode.content += content;
+			currentTextNode.raw += raw$1 ?? content;
+		} else {
+			currentTextNode = {
+				type: "text",
+				content: String(content ?? ""),
+				raw: String(raw$1 ?? content ?? "")
+			};
+			result.push(currentTextNode);
+		}
+	}
 	while (i < tokens.length) {
 		const token = tokens[i];
 		handleToken(token);
 	}
 	function handleToken(token) {
 		switch (token.type) {
-			case "text": {
-				let index = result.length - 1;
-				let content = token.content.replace(/\\/g, "") || "";
-				if (content.startsWith(")") && result[result.length - 1]?.type === "link") content = content.slice(1);
-				for (; index >= 0; index--) {
-					const item = result[index];
-					if (item.type === "text") {
-						currentTextNode = null;
-						content = item.content + content;
-						continue;
-					}
-					break;
-				}
-				if (index < result.length - 1) result.splice(index + 1);
-				const nextToken = tokens[i + 1];
-				if (content === "`" || content === "|" || content === "$" || content === "1" || /^\*+$/.test(content) || /^\d$/.test(content)) {
-					i++;
-					break;
-				}
-				if (!nextToken && /[^\]]\s*\(\s*$/.test(content)) content = content.replace(/\(\s*$/, "");
-				if (raw?.startsWith("[") && pPreToken?.type === "list_item_open") {
-					const w = content.slice(1).match(/[^\s\]]/);
-					if (w === null) {
-						i++;
-						break;
-					}
-					if (w && /x/i.test(w[0]) || !w) {
-						const checked = w ? w[0] === "x" || w[0] === "X" : false;
-						result.push({
-							type: "checkbox_input",
-							checked,
-							raw: checked ? "[x]" : "[ ]"
-						});
-						i++;
-						break;
-					}
-				}
-				if (/`[^`]*/.test(content)) {
-					currentTextNode = null;
-					const index$1 = content.indexOf("`");
-					const _text = content.slice(0, index$1);
-					const codeContent = content.slice(index$1);
-					if (_text) result.push({
-						type: "text",
-						content: _text || "",
-						raw: _text || ""
-					});
-					result.push({
-						type: "inline_code",
-						code: codeContent.replace(/`/g, ""),
-						raw: codeContent || ""
-					});
-					i++;
-					break;
-				}
-				if (content === "[") {
-					i++;
-					break;
-				}
-				if (/[^~]*~{2,}[^~]+/.test(content)) {
-					const index$1 = content.indexOf("~~") || 0;
-					const _text = content.slice(0, index$1);
-					if (_text) if (currentTextNode) {
-						currentTextNode.content += _text;
-						currentTextNode.raw += _text;
-					} else {
-						currentTextNode = {
-							type: "text",
-							content: _text || "",
-							raw: token.content || ""
-						};
-						result.push(currentTextNode);
-					}
-					const strikethroughContent = content.slice(index$1);
-					currentTextNode = null;
-					const { node } = parseStrikethroughToken([
-						{
-							type: "s_open",
-							tag: "s",
-							content: "",
-							markup: "*",
-							info: "",
-							meta: null
-						},
-						{
-							type: "text",
-							tag: "",
-							content: strikethroughContent.replace(/~/g, ""),
-							markup: "",
-							info: "",
-							meta: null
-						},
-						{
-							type: "s_close",
-							tag: "s",
-							content: "",
-							markup: "*",
-							info: "",
-							meta: null
-						}
-					], 0);
-					result.push(node);
-					i++;
-					break;
-				}
-				if (/[^*]*\*\*[^*]+/.test(content)) {
-					const index$1 = content.indexOf("*") || 0;
-					const _text = content.slice(0, index$1);
-					if (_text) if (currentTextNode) {
-						currentTextNode.content += _text;
-						currentTextNode.raw += _text;
-					} else {
-						currentTextNode = {
-							type: "text",
-							content: _text || "",
-							raw: token.content || ""
-						};
-						result.push(currentTextNode);
-					}
-					const strongContent = content.slice(index$1);
-					currentTextNode = null;
-					const { node } = parseStrongToken([
-						{
-							type: "strong_open",
-							tag: "strong",
-							content: "",
-							markup: "*",
-							info: "",
-							meta: null
-						},
-						{
-							type: "text",
-							tag: "",
-							content: strongContent.replace(/\*/g, ""),
-							markup: "",
-							info: "",
-							meta: null
-						},
-						{
-							type: "strong_close",
-							tag: "strong",
-							content: "",
-							markup: "*",
-							info: "",
-							meta: null
-						}
-					], 0, raw);
-					result.push(node);
-					i++;
-					break;
-				} else if (/[^*]*\*[^*]+/.test(content)) {
-					const index$1 = content.indexOf("*") || 0;
-					const _text = content.slice(0, index$1);
-					if (_text) if (currentTextNode) {
-						currentTextNode.content += _text;
-						currentTextNode.raw += _text;
-					} else {
-						currentTextNode = {
-							type: "text",
-							content: _text || "",
-							raw: token.content || ""
-						};
-						result.push(currentTextNode);
-					}
-					const emphasisContent = content.slice(index$1);
-					currentTextNode = null;
-					const { node } = parseEmphasisToken([
-						{
-							type: "em_open",
-							tag: "em",
-							content: "",
-							markup: "*",
-							info: "",
-							meta: null
-						},
-						{
-							type: "text",
-							tag: "",
-							content: emphasisContent.replace(/\*/g, ""),
-							markup: "",
-							info: "",
-							meta: null
-						},
-						{
-							type: "em_close",
-							tag: "em",
-							content: "",
-							markup: "*",
-							info: "",
-							meta: null
-						}
-					], 0);
-					result.push(node);
-					i++;
-					break;
-				}
-				const imageStart = content.indexOf("![");
-				if (imageStart !== -1) {
-					const textNodeContent = content.slice(0, imageStart);
-					if (!currentTextNode) currentTextNode = {
-						type: "text",
-						content: textNodeContent,
-						raw: textNodeContent
-					};
-					else currentTextNode.content += textNodeContent;
-					result.push(currentTextNode);
-					currentTextNode = null;
-					result.push(parseImageToken(token, true));
-					i++;
-					break;
-				}
-				let linkStart = content.indexOf("[");
-				if (content.endsWith("undefined") && !raw?.endsWith("undefined")) content = content.slice(0, -9);
-				const textNode = parseTextToken({
-					...token,
-					content
-				});
-				if (linkStart !== -1) {
-					let textNodeContent = content.slice(0, linkStart);
-					const linkEnd = content.indexOf("](", linkStart);
-					if (linkEnd !== -1) {
-						const textToken = tokens[i + 2];
-						let text = content.slice(linkStart + 1, linkEnd);
-						if (text.includes("[")) {
-							const secondLinkStart = text.indexOf("[");
-							linkStart = linkStart + secondLinkStart + 1;
-							textNodeContent += content.slice(0, linkStart);
-							text = content.slice(linkStart + 1, linkEnd);
-						}
-						if (content.endsWith("](") && nextToken?.type === "link_open" && textToken) {
-							const last = tokens[i + 4];
-							let index$1 = 4;
-							let loading$1 = true;
-							if (last?.type === "text" && last.content === ")") {
-								index$1++;
-								loading$1 = false;
-							} else if (last?.type === "text" && last.content === ".") i++;
-							if (textNodeContent) result.push({
-								type: "text",
-								content: textNodeContent,
-								raw: textNodeContent
-							});
-							result.push({
-								type: "link",
-								href: textToken.content || "",
-								text,
-								children: [{
-									type: "text",
-									content: text,
-									raw: text
-								}],
-								loading: loading$1
-							});
-							i += index$1;
-							break;
-						}
-						const linkContentEnd = content.indexOf(")", linkEnd);
-						const href = linkContentEnd !== -1 ? content.slice(linkEnd + 2, linkContentEnd) : "";
-						const loading = linkContentEnd === -1;
-						if (textNodeContent) result.push({
-							type: "text",
-							content: textNodeContent,
-							raw: textNodeContent
-						});
-						result.push({
-							type: "link",
-							href,
-							text,
-							children: [{
-								type: "text",
-								content: text,
-								raw: text
-							}],
-							loading
-						});
-						const afterText = linkContentEnd !== -1 ? content.slice(linkContentEnd + 1) : "";
-						if (afterText) {
-							handleToken({
-								type: "text",
-								content: afterText,
-								raw: afterText
-							});
-							i--;
-						}
-						i++;
-						break;
-					}
-				}
-				const preToken = tokens[i - 1];
-				if (currentTextNode) {
-					currentTextNode.content += textNode.content.replace(/(\*+|\(|\\)$/, "");
-					currentTextNode.raw += textNode.raw;
-				} else {
-					const maybeMath = preToken?.tag === "br" && tokens[i - 2]?.content === "[";
-					if (!tokens[i + 1]) textNode.content = textNode.content.replace(/(\*+|\(|\\)$/, "");
-					currentTextNode = textNode;
-					currentTextNode.center = maybeMath;
-					result.push(currentTextNode);
-				}
-				i++;
+			case "text":
+				handleTextToken(token);
 				break;
-			}
 			case "softbreak":
 				if (currentTextNode) {
 					currentTextNode.content += "\n";
@@ -1538,193 +1611,368 @@ function parseInlineTokens(tokens, raw, pPreToken) {
 				i++;
 				break;
 			case "code_inline":
-				currentTextNode = null;
-				result.push(parseInlineCodeToken(token));
+				pushNode(parseInlineCodeToken(token));
 				i++;
 				break;
-			case "link_open": {
-				currentTextNode = null;
-				const href = token.attrs?.find((attr) => attr[0] === "href")?.[1];
-				if (raw && tokens[i + 1].type === "text") {
-					const text = tokens[i + 1]?.content || "";
-					if (!(/* @__PURE__ */ new RegExp(`\\[${text}\\s*\\]`)).test(raw)) {
-						result.push({
-							type: "text",
-							content: text,
-							raw: text
-						});
-						i += 3;
-						break;
-					}
-				}
-				if (raw && href) {
-					const loadingMath = /* @__PURE__ */ new RegExp(`\\(\\s*${href}\\s*\\)`);
-					const pre = result.length > 0 ? result[result.length - 1] : null;
-					const loading = !loadingMath.test(raw);
-					if (loading && pre) {
-						if ((/* @__PURE__ */ new RegExp(`\\[${pre.text}\\s*\\]\\(`)).test(raw)) {
-							const text = pre?.text || pre?.content?.slice(1, -1) || "";
-							result.splice(result.length - 1, 1, {
-								type: "link",
-								href: "",
-								text,
-								loading
-							});
-							i += 3;
-							if (tokens[i]?.content === ".") i++;
-							break;
-						}
-					}
-				}
-				const { node, nextIndex } = parseLinkToken(tokens, i);
-				i = nextIndex;
-				node.loading = false;
-				result.push(node);
+			case "link_open":
+				handleLinkOpen(token);
 				break;
-			}
 			case "image":
-				currentTextNode = null;
-				result.push(parseImageToken(token));
+				resetCurrentTextNode();
+				pushNode(parseImageToken(token));
 				i++;
 				break;
 			case "strong_open": {
-				currentTextNode = null;
+				resetCurrentTextNode();
 				const { node, nextIndex } = parseStrongToken(tokens, i, token.content);
-				result.push(node);
+				pushNode(node);
 				i = nextIndex;
 				break;
 			}
 			case "em_open": {
-				currentTextNode = null;
+				resetCurrentTextNode();
 				const { node, nextIndex } = parseEmphasisToken(tokens, i);
-				result.push(node);
+				pushNode(node);
 				i = nextIndex;
 				break;
 			}
 			case "s_open": {
-				currentTextNode = null;
+				resetCurrentTextNode();
 				const { node, nextIndex } = parseStrikethroughToken(tokens, i);
-				result.push(node);
+				pushNode(node);
 				i = nextIndex;
 				break;
 			}
 			case "mark_open": {
-				currentTextNode = null;
+				resetCurrentTextNode();
 				const { node, nextIndex } = parseHighlightToken(tokens, i);
-				result.push(node);
+				pushNode(node);
 				i = nextIndex;
 				break;
 			}
 			case "ins_open": {
-				currentTextNode = null;
+				resetCurrentTextNode();
 				const { node, nextIndex } = parseInsertToken(tokens, i);
-				result.push(node);
+				pushNode(node);
 				i = nextIndex;
 				break;
 			}
 			case "sub_open": {
-				currentTextNode = null;
+				resetCurrentTextNode();
 				const { node, nextIndex } = parseSubscriptToken(tokens, i);
-				result.push(node);
+				pushNode(node);
 				i = nextIndex;
 				break;
 			}
 			case "sup_open": {
-				currentTextNode = null;
+				resetCurrentTextNode();
 				const { node, nextIndex } = parseSuperscriptToken(tokens, i);
-				result.push(node);
+				pushNode(node);
 				i = nextIndex;
 				break;
 			}
 			case "sub":
-				currentTextNode = null;
-				result.push({
+				resetCurrentTextNode();
+				pushNode({
 					type: "subscript",
 					children: [{
 						type: "text",
-						content: token.content || "",
-						raw: token.content || ""
+						content: String(token.content ?? ""),
+						raw: String(token.content ?? "")
 					}],
-					raw: `~${token.content || ""}~`
+					raw: `~${String(token.content ?? "")}~`
 				});
 				i++;
 				break;
 			case "sup":
-				currentTextNode = null;
-				result.push({
+				resetCurrentTextNode();
+				pushNode({
 					type: "superscript",
 					children: [{
 						type: "text",
-						content: token.content || "",
-						raw: token.content || ""
+						content: String(token.content ?? ""),
+						raw: String(token.content ?? "")
 					}],
-					raw: `^${token.content || ""}^`
+					raw: `^${String(token.content ?? "")}^`
 				});
 				i++;
 				break;
 			case "emoji": {
-				currentTextNode = null;
+				resetCurrentTextNode();
 				const preToken = tokens[i - 1];
-				if (preToken?.type === "text" && /\|:-+/.test(preToken.content || "")) result.push({
-					type: "text",
-					content: "",
-					raw: ""
-				});
-				else result.push(parseEmojiToken(token));
+				if (preToken?.type === "text" && /\|:-+/.test(String(preToken.content ?? ""))) pushText("", "");
+				else pushNode(parseEmojiToken(token));
 				i++;
 				break;
 			}
 			case "checkbox":
-				currentTextNode = null;
-				result.push(parseCheckboxToken(token));
+				resetCurrentTextNode();
+				pushNode(parseCheckboxToken(token));
 				i++;
 				break;
 			case "checkbox_input":
-				currentTextNode = null;
-				result.push(parseCheckboxInputToken(token));
+				resetCurrentTextNode();
+				pushNode(parseCheckboxInputToken(token));
 				i++;
 				break;
 			case "footnote_ref":
-				currentTextNode = null;
-				result.push(parseFootnoteRefToken(token));
+				resetCurrentTextNode();
+				pushNode(parseFootnoteRefToken(token));
 				i++;
 				break;
 			case "hardbreak":
-				currentTextNode = null;
-				result.push(parseHardbreakToken());
+				resetCurrentTextNode();
+				pushNode(parseHardbreakToken());
 				i++;
 				break;
 			case "fence":
-				currentTextNode = null;
-				result.push(parseFenceToken(tokens[i]));
+				resetCurrentTextNode();
+				pushNode(parseFenceToken(tokens[i]));
 				i++;
 				break;
 			case "math_inline":
-				currentTextNode = null;
-				result.push(parseMathInlineToken(token));
+				resetCurrentTextNode();
+				pushNode(parseMathInlineToken(token));
 				i++;
 				break;
-			case "reference": {
-				currentTextNode = null;
-				const nextToken = tokens[i + 1];
-				const preToken = tokens[i - 1];
-				const preResult = result[result.length - 1];
-				if (nextToken?.type === "text" && !nextToken.content?.startsWith("(") || preToken.type === "text" && /\]$|^\s*$/.test(preToken.content || "")) result.push(parseReferenceToken(token));
-				else if (nextToken && nextToken.type === "text") nextToken.content = token.markup + nextToken.content;
-				else if (preResult.type === "text") {
-					preResult.content = preResult.content + token.markup;
-					preResult.raw = preResult.raw + token.markup;
-				}
-				i++;
+			case "reference":
+				handleReference(token);
 				break;
-			}
 			default:
-				result.push(token);
-				currentTextNode = null;
+				pushToken(token);
 				i++;
 				break;
 		}
 	}
+	function handleTextToken(token) {
+		let index = result.length - 1;
+		let content = String(token.content ?? "").replace(/\\/g, "");
+		if (content.startsWith(")") && result[result.length - 1]?.type === "link") content = content.slice(1);
+		if (content.endsWith("undefined") && !raw?.endsWith("undefined")) content = content.slice(0, -9);
+		for (; index >= 0; index--) {
+			const item = result[index];
+			if (item.type === "text") {
+				currentTextNode = null;
+				content = item.content + content;
+				continue;
+			}
+			break;
+		}
+		if (index < result.length - 1) result.splice(index + 1);
+		const nextToken = tokens[i + 1];
+		if (content === "`" || content === "|" || content === "$" || content === "1" || /^\*+$/.test(content) || /^\d$/.test(content)) {
+			i++;
+			return;
+		}
+		if (!nextToken && /[^\]]\s*\(\s*$/.test(content)) content = content.replace(/\(\s*$/, "");
+		if (handleCheckboxLike(content)) return;
+		if (content === "[") {
+			i++;
+			return;
+		}
+		if (handleInlineCodeContent(content, token)) return;
+		if (handleEmphasisAndStrikethrough(content, token)) return;
+		if (handleInlineImageContent(content, token)) return;
+		const textNode = parseTextToken({
+			...token,
+			content
+		});
+		if (handleInlineLinkContent(content, token)) return;
+		const preToken = tokens[i - 1];
+		if (currentTextNode) {
+			currentTextNode.content += textNode.content.replace(/(\*+|\(|\\)$/, "");
+			currentTextNode.raw += textNode.raw;
+		} else {
+			const maybeMath = preToken?.tag === "br" && tokens[i - 2]?.content === "[";
+			if (!tokens[i + 1]) textNode.content = textNode.content.replace(/(\*+|\(|\\)$/, "");
+			currentTextNode = textNode;
+			currentTextNode.center = maybeMath;
+			result.push(currentTextNode);
+		}
+		i++;
+	}
+	function handleLinkOpen(token) {
+		resetCurrentTextNode();
+		const href = token.attrs?.find(([name]) => name === "href")?.[1];
+		function escapeRegExp(str) {
+			return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		}
+		if (raw && tokens[i + 1].type === "text") {
+			const text = String(tokens[i + 1]?.content ?? "");
+			const escText = escapeRegExp(text);
+			if (!(/* @__PURE__ */ new RegExp(`\\[${escText}\\s*\\]`)).test(raw)) {
+				pushText(text, text);
+				i += 3;
+				return;
+			}
+		}
+		if (raw && href) {
+			const loadingMath = /* @__PURE__ */ new RegExp(`\\(\\s*${escapeRegExp(href)}\\s*\\)`);
+			const pre = result.length > 0 ? result[result.length - 1] : void 0;
+			const loading = !loadingMath.test(raw);
+			if (loading && pre) {
+				let preText = "";
+				if (pre) {
+					if (pre.type === "link") preText = String(pre.text ?? "");
+					else if (pre.type === "text") preText = String(pre.content ?? "");
+					else if (pre.content && typeof pre.content === "string") preText = String(pre.content ?? "").slice(1, -1);
+				}
+				if ((/* @__PURE__ */ new RegExp(`\\[${escapeRegExp(preText)}\\s*\\]\\(`)).test(raw)) {
+					const text = String(preText ?? "");
+					resetCurrentTextNode();
+					const node$1 = {
+						type: "link",
+						href: "",
+						title: null,
+						text,
+						children: [{
+							type: "text",
+							content: text,
+							raw: text
+						}],
+						loading
+					};
+					result.splice(result.length - 1, 1, node$1);
+					i += 3;
+					if (String(tokens[i]?.content ?? "") === ".") i++;
+					return;
+				}
+			}
+		}
+		const { node, nextIndex } = parseLinkToken(tokens, i);
+		i = nextIndex;
+		const hrefAttr = token.attrs?.find(([name]) => name === "href")?.[1];
+		const hrefStr = String(hrefAttr ?? "");
+		if (raw && hrefStr) {
+			const openIdx = raw.indexOf("](");
+			if (openIdx === -1) {} else {
+				const closeIdx = raw.indexOf(")", openIdx + 2);
+				if (closeIdx === -1) node.loading = true;
+				else if (raw.slice(openIdx + 2, closeIdx).includes(hrefStr)) node.loading = false;
+				else node.loading = true;
+			}
+		}
+		pushParsed(node);
+	}
+	function handleReference(token) {
+		resetCurrentTextNode();
+		const nextToken = tokens[i + 1];
+		const preToken = tokens[i - 1];
+		const preResult = result[result.length - 1];
+		const nextIsTextNotStartingParens = nextToken?.type === "text" && !String(nextToken.content ?? "").startsWith("(");
+		const preIsTextEndingBracketOrOnlySpace = preToken?.type === "text" && /\]$|^\s*$/.test(String(preToken.content ?? ""));
+		if (nextIsTextNotStartingParens || preIsTextEndingBracketOrOnlySpace) pushNode(parseReferenceToken(token));
+		else if (nextToken && nextToken.type === "text") nextToken.content = String(token.markup ?? "") + String(nextToken.content ?? "");
+		else if (preResult && preResult.type === "text") {
+			preResult.content = String(preResult.content ?? "") + String(token.markup ?? "");
+			preResult.raw = String(preResult.raw ?? "") + String(token.markup ?? "");
+		}
+		i++;
+	}
+	function handleInlineLinkContent(content, _token) {
+		const linkStart = content.indexOf("[");
+		if (linkStart === -1) return false;
+		let textNodeContent = content.slice(0, linkStart);
+		const linkEnd = content.indexOf("](", linkStart);
+		if (linkEnd !== -1) {
+			const textToken = tokens[i + 2];
+			let text = content.slice(linkStart + 1, linkEnd);
+			if (text.includes("[")) {
+				const secondLinkStart = text.indexOf("[");
+				textNodeContent += content.slice(0, linkStart + secondLinkStart + 1);
+				const newLinkStart = linkStart + secondLinkStart + 1;
+				text = content.slice(newLinkStart + 1, linkEnd);
+			}
+			const nextToken = tokens[i + 1];
+			if (content.endsWith("](") && nextToken?.type === "link_open" && textToken) {
+				const last = tokens[i + 4];
+				let index = 4;
+				let loading$1 = true;
+				if (last?.type === "text" && last.content === ")") {
+					index++;
+					loading$1 = false;
+				} else if (last?.type === "text" && last.content === ".") i++;
+				if (textNodeContent) pushText(textNodeContent, textNodeContent);
+				pushParsed({
+					type: "link",
+					href: String(textToken.content ?? ""),
+					title: null,
+					text,
+					children: [{
+						type: "text",
+						content: text,
+						raw: text
+					}],
+					loading: loading$1
+				});
+				i += index;
+				return true;
+			}
+			const linkContentEnd = content.indexOf(")", linkEnd);
+			const href = linkContentEnd !== -1 ? content.slice(linkEnd + 2, linkContentEnd) : "";
+			const loading = linkContentEnd === -1;
+			if (textNodeContent) pushText(textNodeContent, textNodeContent);
+			pushParsed({
+				type: "link",
+				href,
+				title: null,
+				text,
+				children: [{
+					type: "text",
+					content: text,
+					raw: text
+				}],
+				loading
+			});
+			const afterText = linkContentEnd !== -1 ? content.slice(linkContentEnd + 1) : "";
+			if (afterText) {
+				handleToken({
+					type: "text",
+					content: afterText,
+					raw: afterText
+				});
+				i--;
+			}
+			i++;
+			return true;
+		}
+		return false;
+	}
+	function handleInlineImageContent(content, token) {
+		const imageStart = content.indexOf("![");
+		if (imageStart === -1) return false;
+		const textNodeContent = content.slice(0, imageStart);
+		if (!currentTextNode) currentTextNode = {
+			type: "text",
+			content: textNodeContent,
+			raw: textNodeContent
+		};
+		else currentTextNode.content += textNodeContent;
+		result.push(currentTextNode);
+		currentTextNode = null;
+		pushParsed(parseImageToken(token, true));
+		i++;
+		return true;
+	}
+	function handleCheckboxLike(content) {
+		if (!(content?.startsWith("[") && pPreToken?.type === "list_item_open")) return false;
+		const w = content.slice(1).match(/[^\s\]]/);
+		if (w === null) {
+			i++;
+			return true;
+		}
+		if (w && /x/i.test(w[0])) {
+			const checked = w[0] === "x" || w[0] === "X";
+			pushParsed({
+				type: "checkbox_input",
+				checked,
+				raw: checked ? "[x]" : "[ ]"
+			});
+			i++;
+			return true;
+		}
+		return false;
+	}
 	return result;
 }
 
@@ -1738,7 +1986,7 @@ function parseBlockquote(tokens, index) {
 		blockquoteChildren.push({
 			type: "paragraph",
 			children: parseInlineTokens(contentToken.children || []),
-			raw: contentToken.content || ""
+			raw: String(contentToken.content ?? "")
 		});
 		j += 3;
 	} else if (tokens[j].type === "bullet_list_open" || tokens[j].type === "ordered_list_open") {
@@ -1757,14 +2005,15 @@ function parseBlockquote(tokens, index) {
 //#region src/parser/node-parsers/code-block-parser.ts
 function parseCodeBlock(token) {
 	if (token.info?.startsWith("diff")) return parseFenceToken(token);
-	const match = token.content.match(/ type="application\/vnd\.ant\.([^"]+)"/);
-	if (match?.[1]) token.content = token.content.replace(/<antArtifact[^>]*>/g, "").replace(/<\/antArtifact>/g, "");
+	const contentStr = String(token.content ?? "");
+	const match = contentStr.match(/ type="application\/vnd\.ant\.([^"]+)"/);
+	if (match?.[1]) token.content = contentStr.replace(/<antArtifact[^>]*>/g, "").replace(/<\/antArtifact>/g, "");
 	const hasMap = Array.isArray(token.map) && token.map.length === 2;
 	return {
 		type: "code_block",
-		language: match ? match[1] : token.info || "",
-		code: token.content || "",
-		raw: token.content || "",
+		language: match ? match[1] : String(token.info ?? ""),
+		code: String(token.content ?? ""),
+		raw: String(token.content ?? ""),
 		loading: !hasMap
 	};
 }
@@ -1787,8 +2036,8 @@ function parseDefinitionList(tokens, index) {
 			const contentToken = tokens[k + 1];
 			definitionNodes.push({
 				type: "paragraph",
-				children: parseInlineTokens(contentToken.children || [], contentToken.content || ""),
-				raw: contentToken.content || ""
+				children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? "")),
+				raw: String(contentToken.content ?? "")
 			});
 			k += 3;
 		} else k++;
@@ -1813,7 +2062,8 @@ function parseDefinitionList(tokens, index) {
 //#endregion
 //#region src/parser/node-parsers/footnote-parser.ts
 function parseFootnote(tokens, index) {
-	const id = tokens[index].meta?.label ?? 0;
+	const meta = tokens[index].meta ?? {};
+	const id = String(meta?.label ?? "0");
 	const footnoteChildren = [];
 	let j = index + 1;
 	while (j < tokens.length && tokens[j].type !== "footnote_close") if (tokens[j].type === "paragraph_open") {
@@ -1821,7 +2071,7 @@ function parseFootnote(tokens, index) {
 		footnoteChildren.push({
 			type: "paragraph",
 			children: parseInlineTokens(contentToken.children || []),
-			raw: contentToken.content || ""
+			raw: String(contentToken.content ?? "")
 		});
 		j += 3;
 	} else j++;
@@ -1837,9 +2087,10 @@ function parseFootnote(tokens, index) {
 //#region src/parser/node-parsers/heading-parser.ts
 function parseHeading(tokens, index) {
 	const token = tokens[index];
-	const headingLevel = Number.parseInt(token.tag?.substring(1) || "1");
+	const levelStr = String(token.tag?.substring(1) ?? "1");
+	const headingLevel = Number.parseInt(levelStr, 10);
 	const headingContentToken = tokens[index + 1];
-	const headingContent = headingContentToken.content || "";
+	const headingContent = String(headingContentToken.content ?? "");
 	return {
 		type: "heading",
 		level: headingLevel,
@@ -1854,9 +2105,9 @@ function parseHeading(tokens, index) {
 function parseMathBlock(token) {
 	return {
 		type: "math_block",
-		content: token.content || "",
+		content: String(token.content ?? ""),
 		loading: !!token.loading,
-		raw: token.raw || ""
+		raw: String(token.raw ?? "")
 	};
 }
 
@@ -1880,7 +2131,7 @@ function parseTable(tokens, index) {
 		while (k < tokens.length && tokens[k].type !== "tr_close") if (tokens[k].type === "th_open" || tokens[k].type === "td_open") {
 			const isHeaderCell = tokens[k].type === "th_open";
 			const contentToken = tokens[k + 1];
-			const content = contentToken.content || "";
+			const content = String(contentToken.content ?? "");
 			cells.push({
 				type: "table_cell",
 				header: isHeaderCell || isHeader,
@@ -1907,7 +2158,7 @@ function parseTable(tokens, index) {
 		type: "table",
 		header: headerRow,
 		rows,
-		loading: tokens[index].loading || false,
+		loading: tokens[index].loading ?? false,
 		raw: [headerRow, ...rows].map((row) => row.raw).join("\n")
 	}, j + 1];
 }
@@ -1933,14 +2184,15 @@ function parseList(tokens, index) {
 		while (k < tokens.length && tokens[k].type !== "list_item_close") if (tokens[k].type === "paragraph_open") {
 			const contentToken = tokens[k + 1];
 			const preToken = tokens[k - 1];
-			if (/\n\d+$/.test(contentToken.content || "")) {
-				contentToken.content = contentToken.content?.replace(/\n\d+$/, "");
+			const contentStr = String(contentToken.content ?? "");
+			if (/\n\d+$/.test(contentStr)) {
+				contentToken.content = contentStr.replace(/\n\d+$/, "");
 				contentToken.children?.splice(-1, 1);
 			}
 			itemChildren.push({
 				type: "paragraph",
-				children: parseInlineTokens(contentToken.children || [], contentToken.content || "", preToken),
-				raw: contentToken.content || ""
+				children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? ""), preToken),
+				raw: String(contentToken.content ?? "")
 			});
 			k += 3;
 		} else if (tokens[k].type === "blockquote_open") {
@@ -1984,7 +2236,7 @@ function parseList(tokens, index) {
 			itemChildren.push(parseThematicBreak());
 			k += 1;
 		} else if (tokens[k].type === "container_open") {
-			const match = /^::: ?(warning|info|note|tip|danger|caution) ?(.*)$/.exec(tokens[k].info || "");
+			const match = /^::: ?(warning|info|note|tip|danger|caution) ?(.*)$/.exec(String(tokens[k].info ?? ""));
 			if (match) {
 				const [admonitionNode, newIndex] = parseAdmonition(tokens, k, match);
 				itemChildren.push(admonitionNode);
@@ -2004,7 +2256,10 @@ function parseList(tokens, index) {
 		start: (() => {
 			if (token.attrs && token.attrs.length) {
 				const found = token.attrs.find((a) => a[0] === "start");
-				if (found) return Number(found[1]) || 1;
+				if (found) {
+					const parsed = Number(found[1]);
+					return Number.isFinite(parsed) && parsed !== 0 ? parsed : 1;
+				}
 			}
 		})(),
 		items: listItems,
@@ -2023,8 +2278,8 @@ function parseNestedList(tokens, index) {
 			const preToken = tokens[k - 1];
 			itemChildren.push({
 				type: "paragraph",
-				children: parseInlineTokens(contentToken.children || [], contentToken.content || "", preToken),
-				raw: contentToken.content || ""
+				children: parseInlineTokens(contentToken.children || [], String(contentToken.content ?? ""), preToken),
+				raw: String(contentToken.content ?? "")
 			});
 			k += 3;
 		} else if (tokens[k].type === "bullet_list_open" || tokens[k].type === "ordered_list_open") {
@@ -2058,7 +2313,10 @@ function parseNestedList(tokens, index) {
 		start: (() => {
 			if (nestedToken.attrs && nestedToken.attrs.length) {
 				const found = nestedToken.attrs.find((a) => a[0] === "start");
-				if (found) return Number(found[1]) || 1;
+				if (found) {
+					const parsed = Number(found[1]);
+					return Number.isFinite(parsed) && parsed !== 0 ? parsed : 1;
+				}
 			}
 		})(),
 		items: nestedItems,
@@ -2069,8 +2327,8 @@ function parseNestedList(tokens, index) {
 //#endregion
 //#region src/parser/node-parsers/admonition-parser.ts
 function parseAdmonition(tokens, index, match) {
-	const kind = match[1] || "note";
-	const title = match[2] || kind.charAt(0).toUpperCase() + kind.slice(1);
+	const kind = String(match[1] ?? "note");
+	const title = String(match[2] ?? kind.charAt(0).toUpperCase() + kind.slice(1));
 	const admonitionChildren = [];
 	let j = index + 1;
 	while (j < tokens.length && tokens[j].type !== "container_close") if (tokens[j].type === "paragraph_open") {
@@ -2078,7 +2336,7 @@ function parseAdmonition(tokens, index, match) {
 		if (contentToken) admonitionChildren.push({
 			type: "paragraph",
 			children: parseInlineTokens(contentToken.children || []),
-			raw: contentToken.content || ""
+			raw: String(contentToken.content ?? "")
 		});
 		j += 3;
 	} else if (tokens[j].type === "bullet_list_open" || tokens[j].type === "ordered_list_open") {
@@ -2104,17 +2362,17 @@ function parseContainer(tokens, index) {
 	const typeMatch = openToken.type.match(/^container_(\w+)_open$/);
 	if (typeMatch) {
 		kind = typeMatch[1];
-		const info = (openToken.info || "").trim();
+		const info = String(openToken.info ?? "").trim();
 		if (info && !info.startsWith(":::")) {
 			const maybe = info.replace(/* @__PURE__ */ new RegExp(`^${kind}`), "").trim();
 			if (maybe) title = maybe;
 		}
 	} else {
-		const info = (openToken.info || "").trim();
+		const info = String(openToken.info ?? "").trim();
 		const match = /^:{1,3}\s*(warning|info|note|tip|danger|caution)\s*(.*)$/i.exec(info);
 		if (match) {
 			kind = match[1];
-			title = match[2] || "";
+			title = String(match[2] ?? "");
 		}
 	}
 	if (!title) title = kind.charAt(0).toUpperCase() + kind.slice(1);
@@ -2124,12 +2382,20 @@ function parseContainer(tokens, index) {
 	while (j < tokens.length && tokens[j].type !== "container_close" && !closeType.test(tokens[j].type)) if (tokens[j].type === "paragraph_open") {
 		const contentToken = tokens[j + 1];
 		if (contentToken) {
-			const i = contentToken.children.findLastIndex((t) => t.type === "text" && /:+/.test(t.content));
-			const _children = i !== -1 ? contentToken.children?.slice(0, i) : contentToken.children;
+			const childrenArr = contentToken.children || [];
+			let i = -1;
+			for (let k = childrenArr.length - 1; k >= 0; k--) {
+				const t = childrenArr[k];
+				if (t.type === "text" && /:+/.test(t.content)) {
+					i = k;
+					break;
+				}
+			}
+			const _children = i !== -1 ? childrenArr.slice(0, i) : childrenArr;
 			children.push({
 				type: "paragraph",
 				children: parseInlineTokens(_children || []),
-				raw: contentToken.content?.replace(/\n:+$/, "").replace(/\n\s*:::\s*$/, "") || ""
+				raw: String(contentToken.content ?? "").replace(/\n:+$/, "").replace(/\n\s*:::\s*$/, "")
 			});
 		}
 		j += 3;
@@ -2160,7 +2426,7 @@ function parseHardBreak() {
 //#region src/parser/node-parsers/paragraph-parser.ts
 function parseParagraph(tokens, index) {
 	const paragraphContentToken = tokens[index + 1];
-	const paragraphContent = paragraphContentToken.content || "";
+	const paragraphContent = String(paragraphContentToken.content ?? "");
 	return {
 		type: "paragraph",
 		children: parseInlineTokens(paragraphContentToken.children || [], paragraphContent),
@@ -2182,14 +2448,21 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 	let transformedTokens = tokens;
 	if (pre && typeof pre === "function") transformedTokens = pre(tokens) || tokens;
 	let result = processTokens(transformedTokens);
-	if (post && typeof post === "function") result = post(transformedTokens) || transformedTokens;
+	if (post && typeof post === "function") {
+		const postResult = post(transformedTokens);
+		if (Array.isArray(postResult)) {
+			const first = postResult[0];
+			const firstType = first?.type;
+			if (first && typeof firstType === "string") result = processTokens(postResult);
+			else result = postResult;
+		}
+	}
 	return result;
 }
 function processTokens(tokens) {
 	if (!tokens || !Array.isArray(tokens)) return [];
 	const result = [];
 	let i = 0;
-	tokens = fixTableTokens(tokens);
 	while (i < tokens.length) {
 		const token = tokens[i];
 		switch (token.type) {
@@ -2258,7 +2531,7 @@ function processTokens(tokens) {
 				break;
 			}
 			case "container_open": {
-				const match = /^::: ?(warning|info|note|tip|danger|caution|error) ?(.*)$/.exec(token.info || "");
+				const match = /^::: ?(warning|info|note|tip|danger|caution|error) ?(.*)$/.exec(String(token.info ?? ""));
 				if (match) {
 					const [admonitionNode, newIndex] = parseAdmonition(tokens, i, match);
 					result.push(admonitionNode);
@@ -2293,8 +2566,14 @@ function getMarkdown(msgId = `editor-${Date.now()}`, options = {}) {
 		const i18nMap = options.i18n;
 		t = (key) => i18nMap[key] ?? defaultTranslations[key] ?? key;
 	} else t = (key) => defaultTranslations[key] ?? key;
-	if (Array.isArray(options.plugin)) for (const p of options.plugin) if (Array.isArray(p)) md.use(p[0], p[1]);
-	else md.use(p);
+	if (Array.isArray(options.plugin)) for (const p of options.plugin) {
+		const pluginItem = p;
+		if (Array.isArray(pluginItem)) {
+			const fn = pluginItem[0];
+			const opts = pluginItem[1];
+			if (typeof fn === "function") md.use(fn, opts);
+		} else if (typeof pluginItem === "function") md.use(pluginItem);
+	}
 	if (Array.isArray(options.apply)) for (const fn of options.apply) try {
 		fn(md);
 	} catch (e) {
@@ -2309,8 +2588,9 @@ function getMarkdown(msgId = `editor-${Date.now()}`, options = {}) {
 	md.use(markdownItIns);
 	md.use(markdownItFootnote);
 	md.core.ruler.after("block", "mark_fence_closed", (state) => {
-		const lines = state.src.split(/\r?\n/);
-		for (const token of state.tokens) {
+		const s = state;
+		const lines = s.src.split(/\r?\n/);
+		for (const token of s.tokens) {
 			if (token.type !== "fence" || !token.map || !token.markup) continue;
 			const openLine = token.map[0];
 			const endLine = token.map[1];
@@ -2325,33 +2605,35 @@ function getMarkdown(msgId = `editor-${Date.now()}`, options = {}) {
 			let j = i + count;
 			while (j < line.length && (line[j] === " " || line[j] === "	")) j++;
 			const closed = endLine > openLine + 1 && count >= minLen && j === line.length;
-			token.meta = token.meta || {};
-			token.meta.unclosed = !closed;
-			token.meta.closed = !!closed;
+			const tokenShape = token;
+			tokenShape.meta = tokenShape.meta ?? {};
+			tokenShape.meta.unclosed = !closed;
+			tokenShape.meta.closed = !!closed;
 		}
 	});
 	const waveRule = (state, silent) => {
-		const start = state.pos;
-		if (state.src[start] !== "~") return false;
-		const prevChar = state.src[start - 1];
-		const nextChar = state.src[start + 1];
+		const s = state;
+		const start = s.pos;
+		if (s.src[start] !== "~") return false;
+		const prevChar = s.src[start - 1];
+		const nextChar = s.src[start + 1];
 		if (/\d/.test(prevChar) && /\d/.test(nextChar)) {
 			if (!silent) {
-				const token = state.push("text", "", 0);
+				const token = s.push("text", "", 0);
 				token.content = "~";
 			}
-			state.pos += 1;
+			s.pos += 1;
 			return true;
 		}
 		return false;
 	};
 	md.inline.ruler.before("sub", "wave", waveRule);
 	md.renderer.rules.fence = (tokens, idx) => {
-		const token = tokens[idx];
-		const info = token.info ? token.info.trim() : "";
-		const str = token.content;
+		const tokenShape = tokens[idx];
+		const info = String(tokenShape.info ?? "").trim();
+		const str = String(tokenShape.content ?? "");
 		const encodedCode = btoa(unescape(encodeURIComponent(str)));
-		const language = info || "text";
+		const language = String(info ?? "text");
 		return `<div class="code-block" data-code="${encodedCode}" data-lang="${language}" id="${`editor-${msgId}-${idx}-${language}`}">
       <div class="code-header">
         <span class="code-lang">${language.toUpperCase()}</span>
@@ -2361,21 +2643,23 @@ function getMarkdown(msgId = `editor-${Date.now()}`, options = {}) {
     </div>`;
 	};
 	const referenceInline = (state, silent) => {
-		if (state.src[state.pos] !== "[") return false;
-		const match = /^\[(\d+)\]/.exec(state.src.slice(state.pos));
+		const s = state;
+		if (s.src[s.pos] !== "[") return false;
+		const match = /^\[(\d+)\]/.exec(s.src.slice(s.pos));
 		if (!match) return false;
 		if (!silent) {
 			const id = match[1];
-			const token = state.push("reference", "span", 0);
+			const token = s.push("reference", "span", 0);
 			token.content = id;
 			token.markup = match[0];
 		}
-		state.pos += match[0].length;
+		s.pos += match[0].length;
 		return true;
 	};
 	md.inline.ruler.before("escape", "reference", referenceInline);
 	md.renderer.rules.reference = (tokens, idx) => {
-		const id = tokens[idx].content;
+		const tokensAny = tokens;
+		const id = String(tokensAny[idx].content ?? "");
 		return `<span class="reference-link" data-reference-id="${id}" role="button" tabindex="0" title="Click to view reference">${id}</span>`;
 	};
 	return md;