@mdream/js 0.17.0

package/dist/_chunks/parse.mjs

@@ -0,0 +1,1201 @@
+import { _ as TagIdMap, a as LIST_ITEM_SPACING, i as HTML_ENTITIES, l as TABLE_ROW_SPACING, o as NO_SPACING, t as BLOCKQUOTE_SPACING } from "./const.mjs";
+//#region src/tags.ts
+function resolveUrl(url, origin) {
+	if (!url) return url;
+	if (url.startsWith("//")) return `https:${url}`;
+	if (url.startsWith("#")) return url;
+	if (origin) {
+		if (url.startsWith("/") && origin) return `${origin.endsWith("/") ? origin.slice(0, -1) : origin}${url}`;
+		if (url.startsWith("./")) return `${origin}/${url.slice(2)}`;
+		if (!url.startsWith("http")) return `${origin}/${url.startsWith("/") ? url.slice(1) : url}`;
+	}
+	return url;
+}
+function isInsideTableCell(node) {
+	return (node.depthMap[32] || 0) > 0;
+}
+function getLanguageFromClass(className) {
+	if (!className) return "";
+	const langParts = className.split(" ").map((c) => c.split("language-")[1]).filter(Boolean);
+	return langParts && langParts.length > 0 ? langParts[0].trim() : "";
+}
+function handleHeading(depth) {
+	return {
+		enter: ({ node }) => {
+			if ((node.depthMap[26] || 0) > 0) return `<h${depth}>`;
+			return `${"#".repeat(depth)} `;
+		},
+		exit: ({ node }) => {
+			if ((node.depthMap[26] || 0) > 0) return `</h${depth}>`;
+		},
+		collapsesInnerWhiteSpace: true
+	};
+}
+const Strong = {
+	enter: ({ node }) => {
+		if ((node?.depthMap?.[15] || 0) > 1) return "";
+		return "**";
+	},
+	exit: ({ node }) => {
+		if ((node?.depthMap?.[15] || 0) > 1) return "";
+		return "**";
+	},
+	collapsesInnerWhiteSpace: true,
+	spacing: NO_SPACING,
+	isInline: true
+};
+const Emphasis = {
+	enter: ({ node }) => {
+		if ((node?.depthMap?.[17] || 0) > 1) return "";
+		return "_";
+	},
+	exit: ({ node }) => {
+		if ((node?.depthMap?.[17] || 0) > 1) return "";
+		return "_";
+	},
+	collapsesInnerWhiteSpace: true,
+	spacing: NO_SPACING,
+	isInline: true
+};
+const tagHandlers = {
+	[1]: {
+		spacing: NO_SPACING,
+		collapsesInnerWhiteSpace: true
+	},
+	[2]: {
+		enter: () => "<details>",
+		exit: () => "</details>\n\n"
+	},
+	[3]: {
+		enter: () => "<summary>",
+		exit: () => "</summary>\n\n"
+	},
+	[4]: {
+		collapsesInnerWhiteSpace: true,
+		isNonNesting: true,
+		spacing: NO_SPACING
+	},
+	[52]: {
+		excludesTextNodes: true,
+		isNonNesting: true
+	},
+	[53]: {
+		isNonNesting: true,
+		excludesTextNodes: true
+	},
+	[5]: {
+		collapsesInnerWhiteSpace: true,
+		isSelfClosing: true,
+		spacing: NO_SPACING
+	},
+	[6]: {
+		enter: ({ node }) => {
+			return isInsideTableCell(node) ? "<br>" : void 0;
+		},
+		isSelfClosing: true,
+		spacing: NO_SPACING,
+		collapsesInnerWhiteSpace: true,
+		isInline: true
+	},
+	[7]: handleHeading(1),
+	[8]: handleHeading(2),
+	[9]: handleHeading(3),
+	[10]: handleHeading(4),
+	[11]: handleHeading(5),
+	[12]: handleHeading(6),
+	[13]: {
+		enter: () => "---",
+		isSelfClosing: true
+	},
+	[14]: Strong,
+	[15]: Strong,
+	[16]: Emphasis,
+	[17]: Emphasis,
+	[18]: {
+		enter: () => "~~",
+		exit: () => "~~",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[19]: {
+		enter: () => "<sub>",
+		exit: () => "</sub>",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[20]: {
+		enter: () => "<sup>",
+		exit: () => "</sup>",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[21]: {
+		enter: () => "<ins>",
+		exit: () => "</ins>",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[22]: {
+		enter: ({ node }) => {
+			const depth = node.depthMap[22] || 1;
+			let prefix = "> ".repeat(depth);
+			const liDepth = node.depthMap[25] || 0;
+			if (liDepth > 0) prefix = `\n${"  ".repeat(liDepth)}${prefix}`;
+			return prefix;
+		},
+		spacing: BLOCKQUOTE_SPACING
+	},
+	[23]: {
+		enter: ({ node }) => {
+			if ((node.depthMap[34] || 0) > 0) return `\`\`\`${getLanguageFromClass(node.attributes?.class)}\n`;
+			return "`";
+		},
+		exit: ({ node }) => {
+			return (node.depthMap[34] || 0) > 0 ? `\n\`\`\`` : "`";
+		},
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[24]: {
+		enter: ({ node }) => isInsideTableCell(node) ? "<ul>" : void 0,
+		exit: ({ node }) => isInsideTableCell(node) ? "</ul>" : void 0
+	},
+	[33]: {
+		enter: ({ node }) => isInsideTableCell(node) ? "<ol>" : void 0,
+		exit: ({ node }) => isInsideTableCell(node) ? "</ol>" : void 0
+	},
+	[25]: {
+		enter: ({ node }) => {
+			if (isInsideTableCell(node)) return "<li>";
+			const depth = (node.depthMap[24] || 0) + (node.depthMap[33] || 0) - 1;
+			const isOrdered = node.parent?.tagId === 33;
+			return `${"  ".repeat(Math.max(0, depth))}${isOrdered ? `${node.index + 1}. ` : "- "}`;
+		},
+		exit: ({ node }) => isInsideTableCell(node) ? "</li>" : void 0,
+		spacing: LIST_ITEM_SPACING
+	},
+	[26]: {
+		enter: ({ node }) => {
+			if (node.attributes?.href) return "[";
+		},
+		exit: ({ node, state }) => {
+			if (!node.attributes?.href) return "";
+			const href = resolveUrl(node.attributes?.href || "", state.options?.origin);
+			let title = node.attributes?.title;
+			if (state.lastContentCache === title) title = "";
+			return title ? `](${href} "${title}")` : `](${href})`;
+		},
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[27]: {
+		enter: ({ node, state }) => {
+			return `![${node.attributes?.alt || ""}](${resolveUrl(node.attributes?.src || "", state.options?.origin)})`;
+		},
+		collapsesInnerWhiteSpace: true,
+		isSelfClosing: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[28]: {
+		enter: ({ node, state }) => {
+			if (isInsideTableCell(node)) return "<table>";
+			if ((node.depthMap[28] || 0) <= 1) state.tableRenderedTable = false;
+			state.tableColumnAlignments = [];
+		},
+		exit: ({ node }) => isInsideTableCell(node) ? "</table>" : void 0
+	},
+	[29]: {
+		enter: ({ node }) => {
+			if (isInsideTableCell(node)) return "<thead>";
+		},
+		exit: ({ node }) => isInsideTableCell(node) ? "</thead>" : void 0,
+		spacing: TABLE_ROW_SPACING,
+		excludesTextNodes: true
+	},
+	[30]: {
+		enter: ({ node, state }) => {
+			if (isInsideTableCell(node)) return "<tr>";
+			state.tableCurrentRowCells = 0;
+			return "| ";
+		},
+		exit: ({ node, state }) => {
+			if (isInsideTableCell(node) || (node.depthMap[28] || 0) > 1) return "</tr>";
+			if (!state.tableRenderedTable) {
+				state.tableRenderedTable = true;
+				const alignments = state.tableColumnAlignments;
+				while (alignments.length < state.tableCurrentRowCells) alignments.push("");
+				return ` |\n| ${alignments.map((align) => {
+					switch (align) {
+						case "left": return ":---";
+						case "center": return ":---:";
+						case "right": return "---:";
+						default: return "---";
+					}
+				}).join(" | ")} |`;
+			}
+			return " |";
+		},
+		excludesTextNodes: true,
+		spacing: TABLE_ROW_SPACING
+	},
+	[31]: {
+		enter: ({ node, state }) => {
+			if ((node.depthMap[28] || 0) > 1) return "<th>";
+			const align = node.attributes?.align?.toLowerCase();
+			if (align) state.tableColumnAlignments.push(align);
+			else if (state.tableColumnAlignments.length <= state.tableCurrentRowCells) state.tableColumnAlignments.push("");
+			return node.index === 0 ? "" : " | ";
+		},
+		exit: ({ node, state }) => {
+			if ((node.depthMap[28] || 0) > 1) return "</th>";
+			state.tableCurrentRowCells++;
+		},
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING
+	},
+	[32]: {
+		enter: ({ node }) => {
+			if ((node.depthMap[28] || 0) > 1) return "<td>";
+			return node.index === 0 ? "" : " | ";
+		},
+		exit: ({ node, state }) => {
+			if ((node.depthMap[28] || 0) > 1) return "</td>";
+			state.tableCurrentRowCells++;
+		},
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING
+	},
+	[35]: { enter: ({ node, state }) => {
+		const bqDepth = node.depthMap[22] || 0;
+		if (bqDepth > 0) {
+			const lastEntry = state.buffer.at(-1);
+			const lastChar = lastEntry?.charAt(lastEntry.length - 1) || "";
+			if (lastChar && lastChar !== "\n" && lastChar !== " " && lastChar !== ">") {
+				const prefix = "> ".repeat(bqDepth);
+				return `\n${prefix.trimEnd()}\n${prefix}`;
+			}
+		}
+	} },
+	[36]: {},
+	[37]: {
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[41]: {},
+	[42]: {
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[43]: {
+		collapsesInnerWhiteSpace: true,
+		isInline: true
+	},
+	[44]: { spacing: NO_SPACING },
+	[45]: {
+		enter: ({ node }) => {
+			if ((node.depthMap[28] || 0) > 1) return "<center>";
+		},
+		exit: ({ node }) => {
+			if ((node.depthMap[28] || 0) > 1) return "</center>";
+		},
+		spacing: NO_SPACING
+	},
+	[38]: {
+		spacing: NO_SPACING,
+		excludesTextNodes: true
+	},
+	[39]: {
+		spacing: TABLE_ROW_SPACING,
+		excludesTextNodes: true
+	},
+	[46]: {
+		enter: () => "`",
+		exit: () => "`",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[47]: { spacing: NO_SPACING },
+	[40]: { spacing: NO_SPACING },
+	[54]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING,
+		collapsesInnerWhiteSpace: true,
+		isInline: true
+	},
+	[55]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING,
+		isInline: true,
+		collapsesInnerWhiteSpace: true
+	},
+	[56]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING,
+		isInline: true,
+		collapsesInnerWhiteSpace: true
+	},
+	[57]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING
+	},
+	[58]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING
+	},
+	[59]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING,
+		isInline: true,
+		collapsesInnerWhiteSpace: true
+	},
+	[60]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING,
+		isInline: true,
+		collapsesInnerWhiteSpace: true
+	},
+	[61]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING
+	},
+	[62]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING
+	},
+	[63]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING
+	},
+	[64]: {
+		isSelfClosing: true,
+		spacing: NO_SPACING,
+		isInline: true,
+		collapsesInnerWhiteSpace: true
+	},
+	[49]: { spacing: NO_SPACING },
+	[65]: { spacing: NO_SPACING },
+	[66]: {
+		isNonNesting: true,
+		spacing: NO_SPACING
+	},
+	[67]: {
+		isNonNesting: true,
+		spacing: NO_SPACING
+	},
+	[68]: { spacing: NO_SPACING },
+	[69]: { spacing: NO_SPACING },
+	[70]: { spacing: NO_SPACING },
+	[71]: { spacing: NO_SPACING },
+	[72]: { spacing: NO_SPACING },
+	[73]: {
+		isNonNesting: true,
+		spacing: NO_SPACING
+	},
+	[74]: { spacing: NO_SPACING },
+	[75]: { spacing: NO_SPACING },
+	[76]: { spacing: NO_SPACING },
+	[77]: { spacing: NO_SPACING },
+	[78]: { spacing: NO_SPACING },
+	[79]: {
+		enter: () => "",
+		exit: () => "",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[80]: {
+		enter: () => "<mark>",
+		exit: () => "</mark>",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[81]: {
+		enter: () => "\"",
+		exit: () => "\"",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[82]: {
+		enter: () => "`",
+		exit: () => "`",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[83]: {
+		enter: () => "",
+		exit: () => "",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[84]: {
+		excludesTextNodes: true,
+		spacing: NO_SPACING
+	},
+	[85]: {
+		isNonNesting: true,
+		spacing: NO_SPACING
+	},
+	[86]: {
+		isNonNesting: true,
+		spacing: NO_SPACING
+	},
+	[87]: {
+		isNonNesting: true,
+		spacing: NO_SPACING
+	},
+	[88]: { spacing: NO_SPACING },
+	[89]: {
+		enter: () => {
+			return "<u>";
+		},
+		exit: () => {
+			return "</u>";
+		},
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[90]: {
+		enter: () => "*",
+		exit: () => "*",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[91]: {
+		enter: () => "**",
+		exit: () => "**",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[92]: {
+		enter: () => "`",
+		exit: () => "`",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[93]: {
+		enter: () => "",
+		exit: () => "",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[94]: {
+		enter: () => "",
+		exit: () => "",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[95]: {
+		enter: () => "",
+		exit: () => "",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[96]: {
+		enter: () => "",
+		exit: () => "",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[97]: {
+		enter: () => "",
+		exit: () => "",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[100]: {
+		enter: () => "<address>",
+		exit: () => "</address>",
+		spacing: NO_SPACING,
+		collapsesInnerWhiteSpace: true
+	},
+	[101]: {
+		spacing: NO_SPACING,
+		enter: () => "<dl>",
+		exit: () => "</dl>"
+	},
+	[99]: {
+		enter: () => "<dt>",
+		exit: () => "</dt>",
+		collapsesInnerWhiteSpace: true,
+		spacing: [0, 1]
+	},
+	[98]: {
+		enter: () => "<dd>",
+		exit: () => "</dd>",
+		spacing: [0, 1]
+	},
+	[50]: {},
+	[51]: {},
+	[105]: {},
+	[104]: {},
+	[102]: {},
+	[106]: {
+		enter: () => "_",
+		exit: () => "_",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	}
+};
+/**
+* Build a map of tag name → TagHandler from declarative tagOverrides config.
+* For alias (string value): clone the handler for the aliased tag.
+* For override object: overlay fields onto the base handler (if tag is known).
+*/
+function buildTagOverrideHandlers(overrides) {
+	const result = /* @__PURE__ */ new Map();
+	for (const tagName in overrides) {
+		const override = overrides[tagName];
+		if (!override) continue;
+		if (typeof override === "string") {
+			const targetId = TagIdMap[override];
+			if (targetId !== void 0) {
+				const baseHandler = tagHandlers[targetId];
+				if (baseHandler) result.set(tagName, { ...baseHandler });
+			}
+		} else {
+			const baseId = TagIdMap[tagName];
+			const baseHandler = baseId !== void 0 ? tagHandlers[baseId] : void 0;
+			const handler = baseHandler ? { ...baseHandler } : {};
+			if (override.enter !== void 0) {
+				const enterStr = override.enter;
+				handler.enter = () => enterStr;
+			}
+			if (override.exit !== void 0) {
+				const exitStr = override.exit;
+				handler.exit = () => exitStr;
+			}
+			if (override.spacing !== void 0) handler.spacing = override.spacing;
+			if (override.isInline !== void 0) handler.isInline = override.isInline;
+			if (override.isSelfClosing !== void 0) handler.isSelfClosing = override.isSelfClosing;
+			if (override.collapsesInnerWhiteSpace !== void 0) handler.collapsesInnerWhiteSpace = override.collapsesInnerWhiteSpace;
+			result.set(tagName, handler);
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Decode HTML entities - optimized version with single pass
+*/
+function decodeHTMLEntities(text) {
+	let result = "";
+	let i = 0;
+	while (i < text.length) {
+		if (text[i] === "&") {
+			let match = false;
+			for (const [entity, replacement] of Object.entries(HTML_ENTITIES)) if (text.startsWith(entity, i)) {
+				result += replacement;
+				i += entity.length;
+				match = true;
+				break;
+			}
+			if (match) continue;
+			if (i + 2 < text.length && text[i + 1] === "#") {
+				const start = i;
+				i += 2;
+				const isHex = text[i] === "x" || text[i] === "X";
+				if (isHex) i++;
+				const numStart = i;
+				while (i < text.length && text[i] !== ";") i++;
+				if (i < text.length && text[i] === ";") {
+					const numStr = text.substring(numStart, i);
+					const base = isHex ? 16 : 10;
+					try {
+						const codePoint = Number.parseInt(numStr, base);
+						if (!Number.isNaN(codePoint)) {
+							result += String.fromCodePoint(codePoint);
+							i++;
+							continue;
+						}
+					} catch {}
+				}
+				i = start;
+			}
+		}
+		result += text[i];
+		i++;
+	}
+	return result;
+}
+function traverseUpToFirstBlockNode(node) {
+	let firstBlockParent = node;
+	const parentsToIncrement = [firstBlockParent];
+	while (firstBlockParent.tagHandler?.isInline) {
+		if (!firstBlockParent.parent) break;
+		firstBlockParent = firstBlockParent.parent;
+		parentsToIncrement.push(firstBlockParent);
+	}
+	return parentsToIncrement;
+}
+//#endregion
+//#region src/parse.ts
+const LT_CHAR = 60;
+const GT_CHAR = 62;
+const SLASH_CHAR = 47;
+const EQUALS_CHAR = 61;
+const QUOTE_CHAR = 34;
+const APOS_CHAR = 39;
+const EXCLAMATION_CHAR = 33;
+const AMPERSAND_CHAR = 38;
+const BACKSLASH_CHAR = 92;
+const DASH_CHAR = 45;
+const SPACE_CHAR = 32;
+const TAB_CHAR = 9;
+const NEWLINE_CHAR = 10;
+const CARRIAGE_RETURN_CHAR = 13;
+const BACKTICK_CHAR = 96;
+const PIPE_CHAR = 124;
+const OPEN_BRACKET_CHAR = 91;
+const CLOSE_BRACKET_CHAR = 93;
+const EMPTY_ATTRIBUTES = Object.freeze({});
+function copyDepthMap(depthMap) {
+	return new Uint8Array(depthMap);
+}
+/**
+* Fast whitespace check using direct character code comparison
+*/
+function isWhitespace(charCode) {
+	return charCode === SPACE_CHAR || charCode === TAB_CHAR || charCode === NEWLINE_CHAR || charCode === CARRIAGE_RETURN_CHAR;
+}
+/**
+* Pure HTML parser that emits DOM events
+* Completely decoupled from markdown generation
+*/
+function parseHtml(html, options = {}) {
+	const events = [];
+	return {
+		events,
+		remainingHtml: parseHtmlInternal(html, {
+			depthMap: new Uint8Array(108),
+			depth: 0,
+			resolvedPlugins: options.resolvedPlugins || []
+		}, (event) => {
+			events.push(event);
+		})
+	};
+}
+/**
+* Streaming HTML parser - calls onEvent for each DOM event
+*/
+function parseHtmlStream(html, state, onEvent) {
+	return parseHtmlInternal(html, state, onEvent);
+}
+/**
+* Internal parsing function - extracted from original parseHTML
+*/
+function parseHtmlInternal(htmlChunk, state, handleEvent) {
+	let textBuffer = "";
+	state.depthMap ??= new Uint8Array(108);
+	state.depth ??= 0;
+	state.lastCharWasWhitespace ??= true;
+	state.justClosedTag ??= false;
+	state.isFirstTextInElement ??= false;
+	state.lastCharWasBackslash ??= false;
+	let i = 0;
+	const chunkLength = htmlChunk.length;
+	while (i < chunkLength) {
+		const currentCharCode = htmlChunk.charCodeAt(i);
+		if (currentCharCode !== LT_CHAR) {
+			if (currentCharCode === AMPERSAND_CHAR) state.hasEncodedHtmlEntity = true;
+			if (isWhitespace(currentCharCode)) {
+				const inPreTag = (state.depthMap[34] || 0) > 0;
+				if (state.justClosedTag) {
+					state.justClosedTag = false;
+					state.lastCharWasWhitespace = false;
+				}
+				if (!inPreTag && state.lastCharWasWhitespace) {
+					i++;
+					continue;
+				}
+				if (inPreTag) textBuffer += htmlChunk[i];
+				else if (currentCharCode === SPACE_CHAR || !state.lastCharWasWhitespace) textBuffer += " ";
+				state.lastCharWasWhitespace = true;
+				state.textBufferContainsWhitespace = true;
+				state.lastCharWasBackslash = false;
+			} else {
+				state.textBufferContainsNonWhitespace = true;
+				state.lastCharWasWhitespace = false;
+				state.justClosedTag = false;
+				if (currentCharCode === PIPE_CHAR && state.depthMap[28]) textBuffer += "\\|";
+				else if (currentCharCode === BACKTICK_CHAR && (state.depthMap[23] || state.depthMap[34])) textBuffer += "\\`";
+				else if (currentCharCode === OPEN_BRACKET_CHAR && state.depthMap[26]) textBuffer += "\\[";
+				else if (currentCharCode === CLOSE_BRACKET_CHAR && state.depthMap[26]) textBuffer += "\\]";
+				else if (currentCharCode === GT_CHAR && state.depthMap[22]) textBuffer += "\\>";
+				else textBuffer += htmlChunk[i];
+				if (state.currentNode?.tagHandler?.isNonNesting) {
+					if (!state.lastCharWasBackslash) {
+						if (currentCharCode === APOS_CHAR && !state.inDoubleQuote && !state.inBacktick) state.inSingleQuote = !state.inSingleQuote;
+						else if (currentCharCode === QUOTE_CHAR && !state.inSingleQuote && !state.inBacktick) state.inDoubleQuote = !state.inDoubleQuote;
+						else if (currentCharCode === BACKTICK_CHAR && !state.inSingleQuote && !state.inDoubleQuote) state.inBacktick = !state.inBacktick;
+					}
+				}
+				state.lastCharWasBackslash = currentCharCode === BACKSLASH_CHAR && !state.lastCharWasBackslash;
+			}
+			i++;
+			continue;
+		}
+		if (i + 1 >= chunkLength) {
+			textBuffer += htmlChunk[i];
+			break;
+		}
+		const nextCharCode = htmlChunk.charCodeAt(i + 1);
+		if (nextCharCode === EXCLAMATION_CHAR) {
+			if (textBuffer.length > 0) {
+				processTextBuffer(textBuffer, state, handleEvent);
+				textBuffer = "";
+			}
+			const result = processCommentOrDoctype(htmlChunk, i);
+			if (result.complete) i = result.newPosition;
+			else {
+				textBuffer += result.remainingText;
+				break;
+			}
+		} else if (nextCharCode === SLASH_CHAR) {
+			const inQuotes = state.inSingleQuote || state.inDoubleQuote || state.inBacktick;
+			if (state.currentNode?.tagHandler?.isNonNesting && inQuotes) {
+				textBuffer += htmlChunk[i];
+				i++;
+				continue;
+			}
+			if (textBuffer.length > 0) {
+				processTextBuffer(textBuffer, state, handleEvent);
+				textBuffer = "";
+			}
+			const result = processClosingTag(htmlChunk, i, state, handleEvent);
+			if (result.complete) i = result.newPosition;
+			else {
+				textBuffer += result.remainingText;
+				break;
+			}
+		} else {
+			let i2 = i + 1;
+			const tagNameStart = i2;
+			let tagNameEnd = -1;
+			while (i2 < chunkLength) {
+				const c = htmlChunk.charCodeAt(i2);
+				if (isWhitespace(c) || c === SLASH_CHAR || c === GT_CHAR) {
+					tagNameEnd = i2;
+					break;
+				}
+				i2++;
+			}
+			if (tagNameEnd === -1) {
+				textBuffer += htmlChunk.substring(i);
+				break;
+			}
+			const tagName = htmlChunk.substring(tagNameStart, tagNameEnd).toLowerCase();
+			if (!tagName) {
+				i = tagNameEnd;
+				break;
+			}
+			const tagId = TagIdMap[tagName] ?? -1;
+			i2 = tagNameEnd;
+			if (state.currentNode?.tagHandler?.isNonNesting) {
+				if (tagId !== state.currentNode?.tagId) {
+					textBuffer += htmlChunk[i++];
+					continue;
+				}
+			}
+			if (textBuffer.length > 0) {
+				processTextBuffer(textBuffer, state, handleEvent);
+				textBuffer = "";
+			}
+			const result = processOpeningTag(tagName, tagId, htmlChunk, i2, state, handleEvent);
+			if (result.skip) textBuffer += htmlChunk[i++];
+			else if (result.complete) {
+				i = result.newPosition;
+				if (!result.selfClosing) state.isFirstTextInElement = true;
+			} else {
+				textBuffer += result.remainingText;
+				break;
+			}
+		}
+	}
+	return textBuffer;
+}
+/**
+* Process accumulated text buffer and create text node event
+*/
+function processTextBuffer(textBuffer, state, handleEvent) {
+	const containsNonWhitespace = state.textBufferContainsNonWhitespace;
+	const containsWhitespace = state.textBufferContainsWhitespace;
+	state.textBufferContainsNonWhitespace = false;
+	state.textBufferContainsWhitespace = false;
+	if (!state.currentNode) return;
+	const excludesTextNodes = state.currentNode?.tagHandler?.excludesTextNodes;
+	const inPreTag = (state.depthMap[34] || 0) > 0;
+	if (!inPreTag && !containsNonWhitespace && !state.currentNode.childTextNodeIndex) return;
+	let text = textBuffer;
+	if (text.length === 0) return;
+	const parentsToIncrement = traverseUpToFirstBlockNode(state.currentNode);
+	const firstBlockParent = parentsToIncrement.at(-1);
+	if (containsWhitespace && !firstBlockParent?.childTextNodeIndex) {
+		let start = 0;
+		while (start < text.length && (inPreTag ? text.charCodeAt(start) === NEWLINE_CHAR || text.charCodeAt(start) === CARRIAGE_RETURN_CHAR : isWhitespace(text.charCodeAt(start)))) start++;
+		if (start > 0) text = text.substring(start);
+	}
+	if (state.hasEncodedHtmlEntity) {
+		text = decodeHTMLEntities(String(text));
+		state.hasEncodedHtmlEntity = false;
+	}
+	const textNode = {
+		type: 2,
+		value: text,
+		parent: state.currentNode,
+		index: state.currentNode.currentWalkIndex++,
+		depth: state.depth,
+		containsWhitespace,
+		excludedFromMarkdown: excludesTextNodes
+	};
+	for (const parent of parentsToIncrement) parent.childTextNodeIndex = (parent.childTextNodeIndex || 0) + 1;
+	handleEvent({
+		type: 0,
+		node: textNode
+	});
+	state.lastTextNode = textNode;
+}
+/**
+* Process HTML closing tag
+*/
+function processClosingTag(htmlChunk, position, state, handleEvent) {
+	let i = position + 2;
+	const tagNameStart = i;
+	const chunkLength = htmlChunk.length;
+	let foundClose = false;
+	while (i < chunkLength) {
+		if (htmlChunk.charCodeAt(i) === GT_CHAR) {
+			foundClose = true;
+			break;
+		}
+		i++;
+	}
+	if (!foundClose) return {
+		complete: false,
+		newPosition: position,
+		remainingText: htmlChunk.substring(position)
+	};
+	const tagId = TagIdMap[htmlChunk.substring(tagNameStart, i).toLowerCase()] ?? -1;
+	if (state.currentNode?.tagHandler?.isNonNesting && tagId !== state.currentNode.tagId) return {
+		complete: false,
+		newPosition: position,
+		remainingText: htmlChunk.substring(position)
+	};
+	let curr = state.currentNode;
+	if (curr) {
+		let match = curr.tagId !== tagId;
+		while (curr && match) {
+			closeNode(curr, state, handleEvent);
+			curr = curr.parent;
+			match = curr?.tagId !== tagId;
+		}
+	}
+	if (curr) closeNode(curr, state, handleEvent);
+	state.justClosedTag = true;
+	return {
+		complete: true,
+		newPosition: i + 1,
+		remainingText: ""
+	};
+}
+/**
+* Close a node and emit exit event
+*/
+function closeNode(node, state, handleEvent) {
+	if (!node) return;
+	if (node.tagId === 26 && !node.childTextNodeIndex) {
+		const prefix = node.attributes?.title || node.attributes?.["aria-label"] || "";
+		if (prefix) {
+			node.childTextNodeIndex = 1;
+			handleEvent({
+				type: 0,
+				node: {
+					type: 2,
+					value: prefix,
+					parent: node,
+					index: 0,
+					depth: node.depth + 1
+				}
+			});
+			for (const parent of traverseUpToFirstBlockNode(node)) parent.childTextNodeIndex = (parent.childTextNodeIndex || 0) + 1;
+		}
+	}
+	if (node.tagId) state.depthMap[node.tagId] = Math.max(0, (state.depthMap[node.tagId] || 0) - 1);
+	if (node.tagHandler?.isNonNesting) {
+		state.inSingleQuote = false;
+		state.inDoubleQuote = false;
+		state.inBacktick = false;
+		state.lastCharWasBackslash = false;
+	}
+	state.depth--;
+	handleEvent({
+		type: 1,
+		node
+	});
+	state.currentNode = state.currentNode.parent;
+	state.hasEncodedHtmlEntity = false;
+	state.justClosedTag = true;
+}
+/**
+* Process HTML comment or doctype
+*/
+function processCommentOrDoctype(htmlChunk, position) {
+	let i = position;
+	const chunkLength = htmlChunk.length;
+	if (i + 3 < chunkLength && htmlChunk.charCodeAt(i + 2) === DASH_CHAR && htmlChunk.charCodeAt(i + 3) === DASH_CHAR) {
+		i += 4;
+		while (i < chunkLength - 2) {
+			if (htmlChunk.charCodeAt(i) === DASH_CHAR && htmlChunk.charCodeAt(i + 1) === DASH_CHAR && htmlChunk.charCodeAt(i + 2) === GT_CHAR) {
+				i += 3;
+				return {
+					complete: true,
+					newPosition: i,
+					remainingText: ""
+				};
+			}
+			i++;
+		}
+		return {
+			complete: false,
+			newPosition: position,
+			remainingText: htmlChunk.substring(position)
+		};
+	} else {
+		i += 2;
+		while (i < chunkLength) {
+			if (htmlChunk.charCodeAt(i) === GT_CHAR) {
+				i++;
+				return {
+					complete: true,
+					newPosition: i,
+					remainingText: ""
+				};
+			}
+			i++;
+		}
+		return {
+			complete: false,
+			newPosition: i,
+			remainingText: htmlChunk.substring(position, i)
+		};
+	}
+}
+/**
+* Process HTML opening tag
+*/
+function processOpeningTag(tagName, tagId, htmlChunk, i, state, handleEvent) {
+	if (state.currentNode?.tagHandler?.isNonNesting) closeNode(state.currentNode, state, handleEvent);
+	const tagHandler = state.tagOverrideHandlers?.get(tagName) ?? tagHandlers[tagId];
+	const result = processTagAttributes(htmlChunk, i, tagHandler);
+	if (!result.complete) return {
+		complete: false,
+		newPosition: i,
+		remainingText: `<${tagName}${result.attrBuffer}`,
+		selfClosing: false
+	};
+	const currentTagCount = result.attributes && result.attributes.id ? void 0 : state.depthMap[tagId] || 0;
+	state.depthMap[tagId] = (currentTagCount || 0) + 1;
+	state.depth++;
+	i = result.newPosition;
+	if (state.currentNode) state.currentNode.currentWalkIndex = state.currentNode.currentWalkIndex || 0;
+	const currentWalkIndex = state.currentNode ? state.currentNode.currentWalkIndex++ : 0;
+	const tag = {
+		type: 1,
+		name: tagName,
+		attributes: result.attributes,
+		parent: state.currentNode,
+		depthMap: copyDepthMap(state.depthMap),
+		depth: state.depth,
+		index: currentWalkIndex,
+		tagId,
+		tagHandler
+	};
+	state.lastTextNode = tag;
+	handleEvent({
+		type: 0,
+		node: tag
+	});
+	const parentNode = tag;
+	parentNode.currentWalkIndex = 0;
+	state.currentNode = parentNode;
+	state.hasEncodedHtmlEntity = false;
+	if (tagHandler?.isNonNesting && !result.selfClosing) {
+		state.inSingleQuote = false;
+		state.inDoubleQuote = false;
+		state.inBacktick = false;
+		state.lastCharWasBackslash = false;
+	}
+	if (result.selfClosing) {
+		closeNode(tag, state, handleEvent);
+		state.justClosedTag = true;
+	} else state.justClosedTag = false;
+	return {
+		complete: true,
+		newPosition: i,
+		remainingText: "",
+		selfClosing: result.selfClosing
+	};
+}
+/**
+* Extract and process HTML tag attributes
+*/
+function processTagAttributes(htmlChunk, position, tagHandler) {
+	let i = position;
+	const chunkLength = htmlChunk.length;
+	const selfClosing = tagHandler?.isSelfClosing || false;
+	const attrStartPos = i;
+	let insideQuote = false;
+	let quoteChar = 0;
+	let prevChar = 0;
+	while (i < chunkLength) {
+		const c = htmlChunk.charCodeAt(i);
+		if (insideQuote) {
+			if (c === quoteChar && prevChar !== BACKSLASH_CHAR) insideQuote = false;
+			i++;
+			continue;
+		} else if (c === QUOTE_CHAR || c === APOS_CHAR) {
+			insideQuote = true;
+			quoteChar = c;
+		} else if (c === SLASH_CHAR && i + 1 < chunkLength && htmlChunk.charCodeAt(i + 1) === GT_CHAR) {
+			const attrStr = htmlChunk.substring(attrStartPos, i).trim();
+			return {
+				complete: true,
+				newPosition: i + 2,
+				attributes: parseAttributes(attrStr),
+				selfClosing: true,
+				attrBuffer: attrStr
+			};
+		} else if (c === GT_CHAR) {
+			const attrStr = htmlChunk.substring(attrStartPos, i).trim();
+			return {
+				complete: true,
+				newPosition: i + 1,
+				attributes: parseAttributes(attrStr),
+				selfClosing,
+				attrBuffer: attrStr
+			};
+		}
+		i++;
+		prevChar = c;
+	}
+	return {
+		complete: false,
+		newPosition: i,
+		attributes: EMPTY_ATTRIBUTES,
+		selfClosing: false,
+		attrBuffer: htmlChunk.substring(attrStartPos, i)
+	};
+}
+/**
+* Parse HTML attributes string into key-value object
+*/
+function parseAttributes(attrStr) {
+	if (!attrStr) return EMPTY_ATTRIBUTES;
+	const result = {};
+	const len = attrStr.length;
+	let i = 0;
+	const WHITESPACE = 0;
+	const NAME = 1;
+	const AFTER_NAME = 2;
+	const BEFORE_VALUE = 3;
+	const QUOTED_VALUE = 4;
+	const UNQUOTED_VALUE = 5;
+	let state = WHITESPACE;
+	let nameStart = 0;
+	let nameEnd = 0;
+	let valueStart = 0;
+	let quoteChar = 0;
+	let name = "";
+	while (i < len) {
+		const charCode = attrStr.charCodeAt(i);
+		const isSpace = isWhitespace(charCode);
+		switch (state) {
+			case WHITESPACE:
+				if (!isSpace) {
+					state = NAME;
+					nameStart = i;
+					nameEnd = 0;
+				}
+				break;
+			case NAME:
+				if (charCode === EQUALS_CHAR || isSpace) {
+					nameEnd = i;
+					name = attrStr.substring(nameStart, nameEnd).toLowerCase();
+					state = charCode === EQUALS_CHAR ? BEFORE_VALUE : AFTER_NAME;
+				}
+				break;
+			case AFTER_NAME:
+				if (charCode === EQUALS_CHAR) state = BEFORE_VALUE;
+				else if (!isSpace) {
+					result[name] = "";
+					state = NAME;
+					nameStart = i;
+					nameEnd = 0;
+				}
+				break;
+			case BEFORE_VALUE:
+				if (charCode === QUOTE_CHAR || charCode === APOS_CHAR) {
+					quoteChar = charCode;
+					state = QUOTED_VALUE;
+					valueStart = i + 1;
+				} else if (!isSpace) {
+					state = UNQUOTED_VALUE;
+					valueStart = i;
+				}
+				break;
+			case QUOTED_VALUE:
+				if (charCode === BACKSLASH_CHAR && i + 1 < len) i++;
+				else if (charCode === quoteChar) {
+					const raw = attrStr.substring(valueStart, i);
+					result[name] = raw.includes("&") ? decodeHTMLEntities(raw) : raw;
+					state = WHITESPACE;
+				}
+				break;
+			case UNQUOTED_VALUE:
+				if (isSpace || charCode === GT_CHAR) {
+					const raw = attrStr.substring(valueStart, i);
+					result[name] = raw.includes("&") ? decodeHTMLEntities(raw) : raw;
+					state = WHITESPACE;
+				}
+				break;
+		}
+		i++;
+	}
+	if (state === QUOTED_VALUE || state === UNQUOTED_VALUE) {
+		if (name) {
+			const raw = attrStr.substring(valueStart, i);
+			result[name] = raw.includes("&") ? decodeHTMLEntities(raw) : raw;
+		}
+	} else if (state === NAME || state === AFTER_NAME || state === BEFORE_VALUE) {
+		nameEnd = nameEnd || i;
+		const currentName = attrStr.substring(nameStart, nameEnd).toLowerCase();
+		if (currentName) result[currentName] = "";
+	}
+	return result;
+}
+//#endregion
+export { buildTagOverrideHandlers as i, parseHtml as n, parseHtmlStream as r, parseAttributes as t };