mdream 0.16.0 → 0.17.0

package/dist/_chunks/markdown-processor.mjs

@@ -1,4 +1,5 @@
-import { $ as TAG_H5, $t as TAG_TH, A as TAG_CANVAS, At as TAG_PROGRESS, B as TAG_DIV, Bt as TAG_SPAN, C as TAG_B, D as TAG_BODY, Dt as TAG_PARAM, E as TAG_BLOCKQUOTE, Et as TAG_P, F as TAG_DD, Ft as TAG_SAMP, G as TAG_FIELDSET, Gt as TAG_SUP, H as TAG_DT, Ht as TAG_STYLE, I as TAG_DEL, It as TAG_SCRIPT, J as TAG_FORM, Jt as TAG_TBODY, Kt as TAG_SVG, L as TAG_DETAILS, Lt as TAG_SELECT, M as TAG_CITE, Mt as TAG_RP, N as TAG_CODE, Nt as TAG_RT, O as TAG_BR, Ot as TAG_PLAINTEXT, P as TAG_COL, Pt as TAG_RUBY, Q as TAG_H4, Qt as TAG_TFOOT, R as TAG_DFN, Rt as TAG_SMALL, S as TAG_AUDIO, St as TAG_NOSCRIPT, T as TAG_BDO, Tt as TAG_OPTION, U as TAG_EM, Ut as TAG_SUB, V as TAG_DL, Vt as TAG_STRONG, W as TAG_EMBED, Wt as TAG_SUMMARY, X as TAG_H2, Xt as TAG_TEMPLATE, Y as TAG_H1, Yt as TAG_TD, Z as TAG_H3, Zt as TAG_TEXTAREA, _ as TAG_A, _t as TAG_MARK, a as LIST_ITEM_SPACING, an as TAG_U, at as TAG_IFRAME, b as TAG_AREA, bt as TAG_NAV, c as MARKDOWN_HORIZONTAL_RULE, cn as TAG_VIDEO, ct as TAG_INS, d as MARKDOWN_STRONG, dn as TEXT_NODE, dt as TAG_LABEL, en as TAG_THEAD, et as TAG_H6, f as MAX_TAG_ID, fn as TagIdMap, ft as TAG_LEGEND, g as TABLE_ROW_SPACING, gt as TAG_MAP, h as NodeEventExit, i as HTML_ENTITIES, in as TAG_TRACK, it as TAG_I, j as TAG_CENTER, jt as TAG_Q, k as TAG_BUTTON, kt as TAG_PRE, l as MARKDOWN_INLINE_CODE, ln as TAG_WBR, lt as TAG_KBD, m as NodeEventEnter, mt as TAG_LINK, n as DEFAULT_BLOCK_SPACING, nn as TAG_TITLE, o as MARKDOWN_CODE_BLOCK, on as TAG_UL, ot as TAG_IMG, p as NO_SPACING, pt as TAG_LI, q as TAG_FOOTER, qt as TAG_TABLE, r as ELEMENT_NODE, rn as TAG_TR, rt as TAG_HR, s as MARKDOWN_EMPHASIS, sn as TAG_VAR, st as TAG_INPUT, t as BLOCKQUOTE_SPACING, tn as TAG_TIME, tt as TAG_HEAD, u as MARKDOWN_STRIKETHROUGH, un as TAG_XMP, ut as TAG_KEYGEN, v as TAG_ABBR, vt as TAG_META, w as TAG_BASE, wt as TAG_OL, x as TAG_ASIDE, xt as TAG_NOFRAMES, y as TAG_ADDRESS, yt as TAG_METER, z as TAG_DIALOG, zt as TAG_SOURCE } from "./const.mjs";
+import { a as NO_SPACING, i as LIST_ITEM_SPACING, n as DEFAULT_BLOCK_SPACING, o as TABLE_ROW_SPACING, r as HTML_ENTITIES, s as TagIdMap, 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}`;
@@ -11,7 +12,7 @@ function resolveUrl(url, origin) {
 	return url;
 }
 function isInsideTableCell(node) {
-	return node.depthMap[TAG_TD] > 0;
+	return node.depthMap[32] > 0;
 }
 function getLanguageFromClass(className) {
 	if (!className) return "";
@@ -21,23 +22,23 @@ function getLanguageFromClass(className) {
 function handleHeading(depth) {
 	return {
 		enter: ({ node }) => {
-			if (node.depthMap[TAG_A]) return `<h${depth}>`;
+			if (node.depthMap[26]) return `<h${depth}>`;
 			return `${"#".repeat(depth)} `;
 		},
 		exit: ({ node }) => {
-			if (node.depthMap[TAG_A]) return `</h${depth}>`;
+			if (node.depthMap[26]) return `</h${depth}>`;
 		},
 		collapsesInnerWhiteSpace: true
 	};
 }
 const Strong = {
 	enter: ({ node }) => {
-		if (node.depthMap[TAG_B] > 1) return "";
-		return MARKDOWN_STRONG;
+		if (node.depthMap[15] > 1) return "";
+		return "**";
 	},
 	exit: ({ node }) => {
-		if (node.depthMap[TAG_B] > 1) return "";
-		return MARKDOWN_STRONG;
+		if (node.depthMap[15] > 1) return "";
+		return "**";
 	},
 	collapsesInnerWhiteSpace: true,
 	spacing: NO_SPACING,
@@ -45,49 +46,49 @@ const Strong = {
 };
 const Emphasis = {
 	enter: ({ node }) => {
-		if (node.depthMap[TAG_I] > 1) return "";
-		return MARKDOWN_EMPHASIS;
+		if (node.depthMap[17] > 1) return "";
+		return "_";
 	},
 	exit: ({ node }) => {
-		if (node.depthMap[TAG_I] > 1) return "";
-		return MARKDOWN_EMPHASIS;
+		if (node.depthMap[17] > 1) return "";
+		return "_";
 	},
 	collapsesInnerWhiteSpace: true,
 	spacing: NO_SPACING,
 	isInline: true
 };
 const tagHandlers = {
-	[TAG_HEAD]: {
+	[1]: {
 		spacing: NO_SPACING,
 		collapsesInnerWhiteSpace: true
 	},
-	[TAG_DETAILS]: {
+	[2]: {
 		enter: () => "<details>",
 		exit: () => "</details>\n\n"
 	},
-	[TAG_SUMMARY]: {
+	[3]: {
 		enter: () => "<summary>",
 		exit: () => "</summary>\n\n"
 	},
-	[TAG_TITLE]: {
+	[4]: {
 		collapsesInnerWhiteSpace: true,
 		isNonNesting: true,
 		spacing: NO_SPACING
 	},
-	[TAG_SCRIPT]: {
+	[52]: {
 		excludesTextNodes: true,
 		isNonNesting: true
 	},
-	[TAG_STYLE]: {
+	[53]: {
 		isNonNesting: true,
 		excludesTextNodes: true
 	},
-	[TAG_META]: {
+	[5]: {
 		collapsesInnerWhiteSpace: true,
 		isSelfClosing: true,
 		spacing: NO_SPACING
 	},
-	[TAG_BR]: {
+	[6]: {
 		enter: ({ node }) => {
 			return isInsideTableCell(node) ? "<br>" : void 0;
 		},
@@ -96,84 +97,84 @@ const tagHandlers = {
 		collapsesInnerWhiteSpace: true,
 		isInline: true
 	},
-	[TAG_H1]: handleHeading(1),
-	[TAG_H2]: handleHeading(2),
-	[TAG_H3]: handleHeading(3),
-	[TAG_H4]: handleHeading(4),
-	[TAG_H5]: handleHeading(5),
-	[TAG_H6]: handleHeading(6),
-	[TAG_HR]: {
-		enter: () => MARKDOWN_HORIZONTAL_RULE,
+	[7]: handleHeading(1),
+	[8]: handleHeading(2),
+	[9]: handleHeading(3),
+	[10]: handleHeading(4),
+	[11]: handleHeading(5),
+	[12]: handleHeading(6),
+	[13]: {
+		enter: () => "---",
 		isSelfClosing: true
 	},
-	[TAG_STRONG]: Strong,
-	[TAG_B]: Strong,
-	[TAG_EM]: Emphasis,
-	[TAG_I]: Emphasis,
-	[TAG_DEL]: {
-		enter: () => MARKDOWN_STRIKETHROUGH,
-		exit: () => MARKDOWN_STRIKETHROUGH,
+	[14]: Strong,
+	[15]: Strong,
+	[16]: Emphasis,
+	[17]: Emphasis,
+	[18]: {
+		enter: () => "~~",
+		exit: () => "~~",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_SUB]: {
+	[19]: {
 		enter: () => "<sub>",
 		exit: () => "</sub>",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_SUP]: {
+	[20]: {
 		enter: () => "<sup>",
 		exit: () => "</sup>",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_INS]: {
+	[21]: {
 		enter: () => "<ins>",
 		exit: () => "</ins>",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_BLOCKQUOTE]: {
+	[22]: {
 		enter: ({ node }) => {
-			const depth = node.depthMap[TAG_BLOCKQUOTE] || 1;
+			const depth = node.depthMap[22] || 1;
 			let prefix = "> ".repeat(depth);
-			if (node.depthMap[TAG_LI] > 0) prefix = `\n${"  ".repeat(node.depthMap[TAG_LI])}${prefix}`;
+			if (node.depthMap[25] > 0) prefix = `\n${"  ".repeat(node.depthMap[25])}${prefix}`;
 			return prefix;
 		},
 		spacing: BLOCKQUOTE_SPACING
 	},
-	[TAG_CODE]: {
+	[23]: {
 		enter: ({ node }) => {
-			if ((node.depthMap[TAG_PRE] || 0) > 0) return `${MARKDOWN_CODE_BLOCK}${getLanguageFromClass(node.attributes?.class)}\n`;
-			return MARKDOWN_INLINE_CODE;
+			if ((node.depthMap[34] || 0) > 0) return `\`\`\`${getLanguageFromClass(node.attributes?.class)}\n`;
+			return "`";
 		},
 		exit: ({ node }) => {
-			return node.depthMap[TAG_PRE] > 0 ? `\n${MARKDOWN_CODE_BLOCK}` : MARKDOWN_INLINE_CODE;
+			return node.depthMap[34] > 0 ? `\n\`\`\`` : "`";
 		},
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_UL]: {
+	[24]: {
 		enter: ({ node }) => isInsideTableCell(node) ? "<ul>" : void 0,
 		exit: ({ node }) => isInsideTableCell(node) ? "</ul>" : void 0
 	},
-	[TAG_LI]: {
+	[25]: {
 		enter: ({ node }) => {
 			if (isInsideTableCell(node)) return "<li>";
-			const depth = (node.depthMap[TAG_UL] || 0) + (node.depthMap[TAG_OL] || 0) - 1;
-			const isOrdered = node.parent?.tagId === TAG_OL;
+			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
 	},
-	[TAG_A]: {
+	[26]: {
 		enter: ({ node }) => {
 			if (node.attributes?.href) return "[";
 		},
@@ -188,7 +189,7 @@ const tagHandlers = {
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_IMG]: {
+	[27]: {
 		enter: ({ node, state }) => {
 			return `![${node.attributes?.alt || ""}](${resolveUrl(node.attributes?.src || "", state.options?.origin)})`;
 		},
@@ -197,15 +198,15 @@ const tagHandlers = {
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_TABLE]: {
+	[28]: {
 		enter: ({ node, state }) => {
 			if (isInsideTableCell(node)) return "<table>";
-			if (node.depthMap[TAG_TABLE] <= 1) state.tableRenderedTable = false;
+			if (node.depthMap[28] <= 1) state.tableRenderedTable = false;
 			state.tableColumnAlignments = [];
 		},
 		exit: ({ node }) => isInsideTableCell(node) ? "</table>" : void 0
 	},
-	[TAG_THEAD]: {
+	[29]: {
 		enter: ({ node }) => {
 			if (isInsideTableCell(node)) return "<thead>";
 		},
@@ -213,14 +214,14 @@ const tagHandlers = {
 		spacing: TABLE_ROW_SPACING,
 		excludesTextNodes: true
 	},
-	[TAG_TR]: {
+	[30]: {
 		enter: ({ node, state }) => {
 			if (isInsideTableCell(node)) return "<tr>";
 			state.tableCurrentRowCells = 0;
 			return "| ";
 		},
 		exit: ({ node, state }) => {
-			if (isInsideTableCell(node) || node.depthMap[TAG_TABLE] > 1) return "</tr>";
+			if (isInsideTableCell(node) || node.depthMap[28] > 1) return "</tr>";
 			if (!state.tableRenderedTable) {
 				state.tableRenderedTable = true;
 				const alignments = state.tableColumnAlignments;
@@ -239,205 +240,205 @@ const tagHandlers = {
 		excludesTextNodes: true,
 		spacing: TABLE_ROW_SPACING
 	},
-	[TAG_TH]: {
+	[31]: {
 		enter: ({ node, state }) => {
-			if (node.depthMap[TAG_TABLE] > 1) return "<th>";
+			if (node.depthMap[28] > 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[TAG_TABLE] > 1) return "</th>";
+			if (node.depthMap[28] > 1) return "</th>";
 			state.tableCurrentRowCells++;
 		},
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING
 	},
-	[TAG_TD]: {
+	[32]: {
 		enter: ({ node }) => {
-			if (node.depthMap[TAG_TABLE] > 1) return "<td>";
+			if (node.depthMap[28] > 1) return "<td>";
 			return node.index === 0 ? "" : " | ";
 		},
 		exit: ({ node, state }) => {
-			if (node.depthMap[TAG_TABLE] > 1) return "</td>";
+			if (node.depthMap[28] > 1) return "</td>";
 			state.tableCurrentRowCells++;
 		},
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING
 	},
-	[TAG_P]: {},
-	[TAG_DIV]: {},
-	[TAG_SPAN]: {
+	[35]: {},
+	[36]: {},
+	[37]: {
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_NAV]: {},
-	[TAG_LABEL]: {
+	[41]: {},
+	[42]: {
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_BUTTON]: {
+	[43]: {
 		collapsesInnerWhiteSpace: true,
 		isInline: true
 	},
-	[TAG_BODY]: { spacing: NO_SPACING },
-	[TAG_CENTER]: {
+	[44]: { spacing: NO_SPACING },
+	[45]: {
 		enter: ({ node }) => {
-			if (node.depthMap[TAG_TABLE] > 1) return "<center>";
+			if (node.depthMap[28] > 1) return "<center>";
 		},
 		exit: ({ node }) => {
-			if (node.depthMap[TAG_TABLE] > 1) return "</center>";
+			if (node.depthMap[28] > 1) return "</center>";
 		},
 		spacing: NO_SPACING
 	},
-	[TAG_TBODY]: {
+	[38]: {
 		spacing: NO_SPACING,
 		excludesTextNodes: true
 	},
-	[TAG_TFOOT]: {
+	[39]: {
 		spacing: TABLE_ROW_SPACING,
 		excludesTextNodes: true
 	},
-	[TAG_KBD]: {
+	[46]: {
 		enter: () => "`",
 		exit: () => "`",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_FOOTER]: { spacing: NO_SPACING },
-	[TAG_FORM]: { spacing: NO_SPACING },
-	[TAG_LINK]: {
+	[47]: { spacing: NO_SPACING },
+	[40]: { spacing: NO_SPACING },
+	[54]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING,
 		collapsesInnerWhiteSpace: true,
 		isInline: true
 	},
-	[TAG_AREA]: {
+	[55]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_BASE]: {
+	[56]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_COL]: {
+	[57]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING
 	},
-	[TAG_EMBED]: {
+	[58]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING
 	},
-	[TAG_INPUT]: {
+	[59]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_KEYGEN]: {
+	[60]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_PARAM]: {
+	[61]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING
 	},
-	[TAG_SOURCE]: {
+	[62]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING
 	},
-	[TAG_TRACK]: {
+	[63]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING
 	},
-	[TAG_WBR]: {
+	[64]: {
 		isSelfClosing: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_SVG]: { spacing: NO_SPACING },
-	[TAG_SELECT]: { spacing: NO_SPACING },
-	[TAG_TEXTAREA]: {
+	[49]: { spacing: NO_SPACING },
+	[65]: { spacing: NO_SPACING },
+	[66]: {
 		isNonNesting: true,
 		spacing: NO_SPACING
 	},
-	[TAG_OPTION]: {
+	[67]: {
 		isNonNesting: true,
 		spacing: NO_SPACING
 	},
-	[TAG_FIELDSET]: { spacing: NO_SPACING },
-	[TAG_LEGEND]: { spacing: NO_SPACING },
-	[TAG_AUDIO]: { spacing: NO_SPACING },
-	[TAG_VIDEO]: { spacing: NO_SPACING },
-	[TAG_CANVAS]: { spacing: NO_SPACING },
-	[TAG_IFRAME]: {
+	[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
 	},
-	[TAG_MAP]: { spacing: NO_SPACING },
-	[TAG_DIALOG]: { spacing: NO_SPACING },
-	[TAG_METER]: { spacing: NO_SPACING },
-	[TAG_PROGRESS]: { spacing: NO_SPACING },
-	[TAG_TEMPLATE]: { spacing: NO_SPACING },
-	[TAG_ABBR]: {
+	[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
 	},
-	[TAG_MARK]: {
+	[80]: {
 		enter: () => "<mark>",
 		exit: () => "</mark>",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_Q]: {
+	[81]: {
 		enter: () => "\"",
 		exit: () => "\"",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_SAMP]: {
+	[82]: {
 		enter: () => "`",
 		exit: () => "`",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_SMALL]: {
+	[83]: {
 		enter: () => "",
 		exit: () => "",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_NOSCRIPT]: {
+	[84]: {
 		excludesTextNodes: true,
 		spacing: NO_SPACING
 	},
-	[TAG_NOFRAMES]: {
+	[85]: {
 		isNonNesting: true,
 		spacing: NO_SPACING
 	},
-	[TAG_XMP]: {
+	[86]: {
 		isNonNesting: true,
 		spacing: NO_SPACING
 	},
-	[TAG_PLAINTEXT]: {
+	[87]: {
 		isNonNesting: true,
 		spacing: NO_SPACING
 	},
-	[TAG_ASIDE]: { spacing: NO_SPACING },
-	[TAG_U]: {
+	[88]: { spacing: NO_SPACING },
+	[89]: {
 		enter: () => {
 			return "<u>";
 		},
@@ -448,85 +449,98 @@ const tagHandlers = {
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_CITE]: {
+	[90]: {
 		enter: () => "*",
 		exit: () => "*",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_DFN]: {
+	[91]: {
 		enter: () => "**",
 		exit: () => "**",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_VAR]: {
+	[92]: {
 		enter: () => "`",
 		exit: () => "`",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_TIME]: {
+	[93]: {
 		enter: () => "",
 		exit: () => "",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_BDO]: {
+	[94]: {
 		enter: () => "",
 		exit: () => "",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_RUBY]: {
+	[95]: {
 		enter: () => "",
 		exit: () => "",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_RT]: {
+	[96]: {
 		enter: () => "",
 		exit: () => "",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_RP]: {
+	[97]: {
 		enter: () => "",
 		exit: () => "",
 		collapsesInnerWhiteSpace: true,
 		spacing: NO_SPACING,
 		isInline: true
 	},
-	[TAG_ADDRESS]: {
+	[100]: {
 		enter: () => "<address>",
 		exit: () => "</address>",
 		spacing: NO_SPACING,
 		collapsesInnerWhiteSpace: true
 	},
-	[TAG_DL]: {
+	[101]: {
 		spacing: NO_SPACING,
 		enter: () => "<dl>",
 		exit: () => "</dl>"
 	},
-	[TAG_DT]: {
+	[99]: {
 		enter: () => "<dt>",
 		exit: () => "</dt>",
 		collapsesInnerWhiteSpace: true,
 		spacing: [0, 1]
 	},
-	[TAG_DD]: {
+	[98]: {
 		enter: () => "<dd>",
 		exit: () => "</dd>",
 		spacing: [0, 1]
+	},
+	[102]: {},
+	[106]: {
+		enter: () => "_",
+		exit: () => "_",
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
 	}
 };
+//#endregion
+//#region src/utils.ts
+/**
+* Decode HTML entities - optimized version with single pass
+*/
 function decodeHTMLEntities(text) {
 	let result = "";
 	let i = 0;
@@ -577,6 +591,8 @@ function traverseUpToFirstBlockNode(node) {
 	}
 	return parentsToIncrement;
 }
+//#endregion
+//#region src/parse.ts
 const LT_CHAR = 60;
 const GT_CHAR = 62;
 const SLASH_CHAR = 47;
@@ -599,15 +615,22 @@ 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(MAX_TAG_ID),
+			depthMap: new Uint8Array(108),
 			depth: 0,
 			plugins: options.plugins || []
 		}, (event) => {
@@ -615,12 +638,18 @@ function parseHtml(html, options = {}) {
 		})
 	};
 }
+/**
+* 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(MAX_TAG_ID);
+	state.depthMap ??= new Uint8Array(108);
 	state.depth ??= 0;
 	state.lastCharWasWhitespace ??= true;
 	state.justClosedTag ??= false;
@@ -633,7 +662,7 @@ function parseHtmlInternal(htmlChunk, state, handleEvent) {
 		if (currentCharCode !== LT_CHAR) {
 			if (currentCharCode === AMPERSAND_CHAR) state.hasEncodedHtmlEntity = true;
 			if (isWhitespace(currentCharCode)) {
-				const inPreTag = state.depthMap[TAG_PRE] > 0;
+				const inPreTag = state.depthMap[34] > 0;
 				if (state.justClosedTag) {
 					state.justClosedTag = false;
 					state.lastCharWasWhitespace = false;
@@ -651,11 +680,11 @@ function parseHtmlInternal(htmlChunk, state, handleEvent) {
 				state.textBufferContainsNonWhitespace = true;
 				state.lastCharWasWhitespace = false;
 				state.justClosedTag = false;
-				if (currentCharCode === PIPE_CHAR && state.depthMap[TAG_TABLE]) textBuffer += "\\|";
-				else if (currentCharCode === BACKTICK_CHAR && (state.depthMap[TAG_CODE] || state.depthMap[TAG_PRE])) textBuffer += "\\`";
-				else if (currentCharCode === OPEN_BRACKET_CHAR && state.depthMap[TAG_A]) textBuffer += "\\[";
-				else if (currentCharCode === CLOSE_BRACKET_CHAR && state.depthMap[TAG_A]) textBuffer += "\\]";
-				else if (currentCharCode === GT_CHAR && state.depthMap[TAG_BLOCKQUOTE]) textBuffer += "\\>";
+				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) {
@@ -748,6 +777,9 @@ function parseHtmlInternal(htmlChunk, state, handleEvent) {
 	}
 	return textBuffer;
 }
+/**
+* Process accumulated text buffer and create text node event
+*/
 function processTextBuffer(textBuffer, state, handleEvent) {
 	const containsNonWhitespace = state.textBufferContainsNonWhitespace;
 	const containsWhitespace = state.textBufferContainsWhitespace;
@@ -755,12 +787,12 @@ function processTextBuffer(textBuffer, state, handleEvent) {
 	state.textBufferContainsWhitespace = false;
 	if (!state.currentNode) return;
 	const excludesTextNodes = state.currentNode?.tagHandler?.excludesTextNodes;
-	const inPreTag = state.depthMap[TAG_PRE] > 0;
+	const inPreTag = state.depthMap[34] > 0;
 	if (!inPreTag && !containsNonWhitespace && !state.currentNode.childTextNodeIndex) return;
 	let text = textBuffer;
 	if (text.length === 0) return;
 	const parentsToIncrement = traverseUpToFirstBlockNode(state.currentNode);
-	const firstBlockParent = parentsToIncrement[parentsToIncrement.length - 1];
+	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++;
@@ -771,7 +803,7 @@ function processTextBuffer(textBuffer, state, handleEvent) {
 		state.hasEncodedHtmlEntity = false;
 	}
 	const textNode = {
-		type: TEXT_NODE,
+		type: 2,
 		value: text,
 		parent: state.currentNode,
 		index: state.currentNode.currentWalkIndex++,
@@ -781,11 +813,14 @@ function processTextBuffer(textBuffer, state, handleEvent) {
 	};
 	for (const parent of parentsToIncrement) parent.childTextNodeIndex = (parent.childTextNodeIndex || 0) + 1;
 	handleEvent({
-		type: NodeEventEnter,
+		type: 0,
 		node: textNode
 	});
 	state.lastTextNode = textNode;
 }
+/**
+* Process HTML closing tag
+*/
 function processClosingTag(htmlChunk, position, state, handleEvent) {
 	let i = position + 2;
 	const tagNameStart = i;
@@ -826,16 +861,19 @@ function processClosingTag(htmlChunk, position, state, handleEvent) {
 		remainingText: ""
 	};
 }
+/**
+* Close a node and emit exit event
+*/
 function closeNode(node, state, handleEvent) {
 	if (!node) return;
-	if (node.tagId === TAG_A && !node.childTextNodeIndex) {
+	if (node.tagId === 26 && !node.childTextNodeIndex) {
 		const prefix = node.attributes?.title || node.attributes?.["aria-label"] || "";
 		if (prefix) {
 			node.childTextNodeIndex = 1;
 			handleEvent({
-				type: NodeEventEnter,
+				type: 0,
 				node: {
-					type: TEXT_NODE,
+					type: 2,
 					value: prefix,
 					parent: node,
 					index: 0,
@@ -854,13 +892,16 @@ function closeNode(node, state, handleEvent) {
 	}
 	state.depth--;
 	handleEvent({
-		type: NodeEventExit,
+		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;
@@ -902,6 +943,9 @@ function processCommentOrDoctype(htmlChunk, position) {
 		};
 	}
 }
+/**
+* Process HTML opening tag
+*/
 function processOpeningTag(tagName, tagId, htmlChunk, i, state, handleEvent) {
 	if (state.currentNode?.tagHandler?.isNonNesting) closeNode(state.currentNode, state, handleEvent);
 	const tagHandler = tagHandlers[tagId];
@@ -919,7 +963,7 @@ function processOpeningTag(tagName, tagId, htmlChunk, i, state, handleEvent) {
 	if (state.currentNode) state.currentNode.currentWalkIndex = state.currentNode.currentWalkIndex || 0;
 	const currentWalkIndex = state.currentNode ? state.currentNode.currentWalkIndex++ : 0;
 	const tag = {
-		type: ELEMENT_NODE,
+		type: 1,
 		name: tagName,
 		attributes: result.attributes,
 		parent: state.currentNode,
@@ -931,7 +975,7 @@ function processOpeningTag(tagName, tagId, htmlChunk, i, state, handleEvent) {
 	};
 	state.lastTextNode = tag;
 	handleEvent({
-		type: NodeEventEnter,
+		type: 0,
 		node: tag
 	});
 	const parentNode = tag;
@@ -955,6 +999,9 @@ function processOpeningTag(tagName, tagId, htmlChunk, i, state, handleEvent) {
 		selfClosing: result.selfClosing
 	};
 }
+/**
+* Extract and process HTML tag attributes
+*/
 function processTagAttributes(htmlChunk, position, tagHandler) {
 	let i = position;
 	const chunkLength = htmlChunk.length;
@@ -1002,6 +1049,9 @@ function processTagAttributes(htmlChunk, position, tagHandler) {
 		attrBuffer: htmlChunk.substring(attrStartPos, i)
 	};
 }
+/**
+* Parse HTML attributes string into key-value object
+*/
 function parseAttributes(attrStr) {
 	if (!attrStr) return EMPTY_ATTRIBUTES;
 	const result = {};
@@ -1081,25 +1131,39 @@ function parseAttributes(attrStr) {
 	}
 	return result;
 }
+//#endregion
+//#region src/plugin-processor.ts
+/**
+* Processes plugins for a given node event
+* Shared logic between markdown-processor.ts and stream.ts
+*
+* @param event - The node event to process
+* @param plugins - Array of plugins to apply
+* @param state - The current runtime state
+* @param processEvent - Callback to process the event after plugin processing
+* @returns true if the event should be skipped, false to continue processing
+*/
 function processPluginsForEvent(event, plugins, state, processEvent) {
 	if (plugins?.length) {
+		let shouldSkip = false;
 		for (const plugin of plugins) {
 			const res = plugin.beforeNodeProcess?.(event, state);
-			if (typeof res === "object" && res.skip) return true;
+			if (typeof res === "object") shouldSkip = res.skip;
 		}
-		if (event.node.type === ELEMENT_NODE) {
+		if (shouldSkip) return true;
+		if (event.node.type === 1) {
 			const element = event.node;
-			if (event.type === NodeEventEnter) {
+			if (event.type === 0) {
 				for (const plugin of plugins) if (plugin.processAttributes) plugin.processAttributes(element, state);
 			}
-			const fn = event.type === NodeEventEnter ? "onNodeEnter" : "onNodeExit";
+			const fn = event.type === 0 ? "onNodeEnter" : "onNodeExit";
 			const pluginOutputs = [];
 			for (const plugin of plugins) if (plugin[fn]) {
 				const result = plugin[fn](element, state);
 				if (result) pluginOutputs.push(result);
 			}
-			if (pluginOutputs.length > 0) element.pluginOutput = (element.pluginOutput || []).concat(pluginOutputs);
-		} else if (event.node.type === TEXT_NODE && event.type === NodeEventEnter) {
+			if (pluginOutputs.length > 0) element.pluginOutput = [...element.pluginOutput || [], ...pluginOutputs];
+		} else if (event.node.type === 2 && event.type === 0) {
 			const textNode = event.node;
 			for (const plugin of plugins) if (plugin.processTextNode) {
 				const result = plugin.processTextNode(textNode, state);
@@ -1113,6 +1177,11 @@ function processPluginsForEvent(event, plugins, state, processEvent) {
 	processEvent(event);
 	return false;
 }
+//#endregion
+//#region src/markdown-processor.ts
+/**
+* Determines if spacing is needed between two characters
+*/
 function needsSpacing(lastChar, firstChar, state) {
 	if (lastChar === " " || lastChar === "\n" || lastChar === "	") return false;
 	if (firstChar === " " || firstChar === "\n" || firstChar === "	") return false;
@@ -1138,22 +1207,28 @@ function needsSpacing(lastChar, firstChar, state) {
 		"_",
 		"`"
 	]);
-	if (lastChar === "|" && firstChar === "<" && state && state.depthMap[TAG_TABLE] > 0) return true;
+	if (lastChar === "|" && firstChar === "<" && state && state.depthMap[28] > 0) return true;
 	if (noSpaceAfter.has(lastChar) || noSpaceBefore.has(firstChar)) return false;
 	return true;
 }
+/**
+* Determines if spacing should be added before text content
+*/
 function shouldAddSpacingBeforeText(lastChar, lastNode, textNode) {
 	return !!lastChar && lastChar !== "\n" && lastChar !== " " && lastChar !== "[" && lastChar !== ">" && !lastNode?.tagHandler?.isInline && textNode.value[0] !== " ";
 }
+/**
+* Calculate newline configuration based on tag handler spacing config
+*/
 function calculateNewLineConfig(node) {
 	const tagId = node.tagId;
 	const depthMap = node.depthMap;
-	if (tagId !== TAG_LI && depthMap[TAG_LI] > 0 || tagId !== TAG_BLOCKQUOTE && depthMap[TAG_BLOCKQUOTE] > 0) return NO_SPACING;
-	const isBlockElement = tagId !== void 0 && (tagId >= TAG_H1 && tagId <= TAG_H6 || tagId === TAG_P || tagId === TAG_DIV);
+	if (tagId !== 25 && depthMap[25] > 0 || tagId !== 22 && depthMap[22] > 0) return NO_SPACING;
+	const isBlockElement = tagId !== void 0 && (tagId >= 7 && tagId <= 12 || tagId === 35 || tagId === 36);
 	let currParent = node.parent;
 	while (currParent) {
 		if (currParent.tagHandler?.collapsesInnerWhiteSpace) {
-			if (isBlockElement && currParent.tagId === TAG_SPAN) {
+			if (isBlockElement && currParent.tagId === 37) {
 				currParent = currParent.parent;
 				continue;
 			}
@@ -1164,25 +1239,31 @@ function calculateNewLineConfig(node) {
 	if (node.tagHandler?.spacing) return node.tagHandler?.spacing;
 	return DEFAULT_BLOCK_SPACING;
 }
+/**
+* Creates a markdown processor that consumes DOM events and generates markdown
+*/
 function createMarkdownProcessor(options = {}) {
 	const state = {
 		options,
 		buffer: [],
-		depthMap: new Uint8Array(MAX_TAG_ID)
+		depthMap: new Uint8Array(108)
 	};
 	let lastYieldedLength = 0;
+	/**
+	* Process a DOM event and generate markdown
+	*/
 	function processEvent(event) {
 		const { type: eventType, node } = event;
 		const lastNode = state.lastNode;
 		state.lastNode = event.node;
 		state.depth = node.depth;
 		const buff = state.buffer;
-		const lastBuffEntry = buff[buff.length - 1];
+		const lastBuffEntry = buff.at(-1);
 		const lastChar = lastBuffEntry?.charAt(lastBuffEntry.length - 1) || "";
 		let secondLastChar;
 		if (lastBuffEntry?.length > 1) secondLastChar = lastBuffEntry.charAt(lastBuffEntry.length - 2);
 		else secondLastChar = buff[buff.length - 2]?.charAt(buff[buff.length - 2].length - 1);
-		if (node.type === TEXT_NODE && eventType === NodeEventEnter) {
+		if (node.type === 2 && eventType === 0) {
 			const textNode = node;
 			if (textNode.value) {
 				if (textNode.excludedFromMarkdown) return;
@@ -1194,7 +1275,7 @@ function createMarkdownProcessor(options = {}) {
 			state.lastTextNode = textNode;
 			return;
 		}
-		if (node.type !== ELEMENT_NODE) return;
+		if (node.type !== 1) return;
 		const context = {
 			node,
 			state
@@ -1209,7 +1290,7 @@ function createMarkdownProcessor(options = {}) {
 		let lastNewLines = 0;
 		if (lastChar === "\n") lastNewLines++;
 		if (secondLastChar === "\n") lastNewLines++;
-		const eventFn = eventType === NodeEventEnter ? "enter" : "exit";
+		const eventFn = eventType === 0 ? "enter" : "exit";
 		const handler = node.tagHandler;
 		if (!output.length && handler?.[eventFn]) {
 			const res = handler[eventFn](context);
@@ -1226,25 +1307,25 @@ function createMarkdownProcessor(options = {}) {
 				return;
 			}
 			const newlinesStr = "\n".repeat(newLines);
-			if (lastChar === " " && buff?.length) buff[buff.length - 1] = buff[buff.length - 1].substring(0, buff[buff.length - 1].length - 1);
-			if (eventType === NodeEventEnter) output.unshift(newlinesStr);
+			if (lastChar === " " && buff?.length) buff[buff.length - 1] = buff.at(-1).substring(0, buff.at(-1).length - 1);
+			if (eventType === 0) output.unshift(newlinesStr);
 			else output.push(newlinesStr);
 		} else if (lastFragment && state.lastTextNode?.containsWhitespace && !!node.parent && "value" in state.lastTextNode && typeof state.lastTextNode.value === "string") {
-			if (!node.parent.depthMap[TAG_PRE] || node.parent.tagId === TAG_PRE) {
+			if (!node.parent.depthMap[34] || node.parent.tagId === 34) {
 				const isInlineElement = node.tagHandler?.isInline;
 				const collapsesWhiteSpace = node.tagHandler?.collapsesInnerWhiteSpace;
 				const hasSpacing = node.tagHandler?.spacing && Array.isArray(node.tagHandler.spacing);
-				if ((!isInlineElement || eventType === NodeEventExit) && !(!isInlineElement && !collapsesWhiteSpace && configuredNewLines > 0) && !(collapsesWhiteSpace && eventType === NodeEventEnter) && !(hasSpacing && eventType === NodeEventEnter)) {
+				if ((!isInlineElement || eventType === 1) && !(!isInlineElement && !collapsesWhiteSpace && configuredNewLines > 0) && !(collapsesWhiteSpace && eventType === 0) && !(hasSpacing && eventType === 0)) {
 					const originalLength = lastFragment.length;
 					const trimmed = lastFragment.trimEnd();
 					if (originalLength - trimmed.length > 0) {
-						if (buff?.length && buff[buff.length - 1] === lastFragment) buff[buff.length - 1] = trimmed;
+						if (buff?.length && buff.at(-1) === lastFragment) buff[buff.length - 1] = trimmed;
 					}
 				}
 				state.lastTextNode = void 0;
 			}
 		}
-		if (output[0]?.[0] && eventType === NodeEventEnter && lastChar && needsSpacing(lastChar, output[0][0], state)) {
+		if (output[0]?.[0] && eventType === 0 && lastChar && needsSpacing(lastChar, output[0][0], state)) {
 			state.buffer.push(" ");
 			state.lastContentCache = " ";
 		}
@@ -1253,6 +1334,9 @@ function createMarkdownProcessor(options = {}) {
 			state.lastContentCache = fragment;
 		}
 	}
+	/**
+	* Process HTML string and generate events
+	*/
 	function processHtml(html) {
 		parseHtmlStream(html, {
 			depthMap: state.depthMap,
@@ -1262,11 +1346,17 @@ function createMarkdownProcessor(options = {}) {
 			processPluginsForEvent(event, state.options?.plugins, state, processEvent);
 		});
 	}
+	/**
+	* Get the final markdown output
+	*/
 	function getMarkdown() {
 		const result = state.buffer.join("").trimStart();
 		state.buffer.length = 0;
 		return result.trimEnd();
 	}
+	/**
+	* Get new markdown content since the last call (for streaming)
+	*/
 	function getMarkdownChunk() {
 		const currentContent = state.buffer.join("").trimStart();
 		const newContent = currentContent.slice(lastYieldedLength);
@@ -1282,4 +1372,5 @@ function createMarkdownProcessor(options = {}) {
 	};
 }
 const MarkdownProcessor = createMarkdownProcessor;
+//#endregion
 export { parseHtmlStream as a, parseHtml as i, createMarkdownProcessor as n, processPluginsForEvent as r, MarkdownProcessor as t };