nuxt-ai-ready 2.5.0 → 2.5.2

package/node_modules/@mdream/js/dist/_chunks/parse.mjs

@@ -0,0 +1,2756 @@
+import { BLOCKQUOTE_SPACING, LIST_ITEM_SPACING, NO_SPACING, TABLE_ROW_SPACING, TagIdMap, isInsideRawHtmlBlock } from "./const.mjs";
+const HTML_ENTITIES = {
+	AElig: "Æ",
+	AMP: "&",
+	Aacute: "Á",
+	Acirc: "Â",
+	Agrave: "À",
+	$Alpha: "Α",
+	Aring: "Å",
+	Atilde: "Ã",
+	Auml: "Ä",
+	$Beta: "Β",
+	COPY: "©",
+	Ccedil: "Ç",
+	$Chi: "Χ",
+	$Dagger: "‡",
+	$Delta: "Δ",
+	ETH: "Ð",
+	Eacute: "É",
+	Ecirc: "Ê",
+	Egrave: "È",
+	$Epsilon: "Ε",
+	$Eta: "Η",
+	Euml: "Ë",
+	GT: ">",
+	$Gamma: "Γ",
+	Iacute: "Í",
+	Icirc: "Î",
+	Igrave: "Ì",
+	$Iota: "Ι",
+	Iuml: "Ï",
+	$Kappa: "Κ",
+	LT: "<",
+	$Lambda: "Λ",
+	$Mu: "Μ",
+	Ntilde: "Ñ",
+	$Nu: "Ν",
+	$OElig: "Œ",
+	Oacute: "Ó",
+	Ocirc: "Ô",
+	Ograve: "Ò",
+	$Omega: "Ω",
+	$Omicron: "Ο",
+	Oslash: "Ø",
+	Otilde: "Õ",
+	Ouml: "Ö",
+	$Phi: "Φ",
+	$Pi: "Π",
+	$Prime: "″",
+	$Psi: "Ψ",
+	QUOT: "\"",
+	REG: "®",
+	$Rho: "Ρ",
+	$Scaron: "Š",
+	$Sigma: "Σ",
+	THORN: "Þ",
+	$Tau: "Τ",
+	$Theta: "Θ",
+	Uacute: "Ú",
+	Ucirc: "Û",
+	Ugrave: "Ù",
+	$Upsilon: "Υ",
+	Uuml: "Ü",
+	$Xi: "Ξ",
+	Yacute: "Ý",
+	$Yuml: "Ÿ",
+	$Zeta: "Ζ",
+	aacute: "á",
+	acirc: "â",
+	acute: "´",
+	aelig: "æ",
+	agrave: "à",
+	$alefsym: "ℵ",
+	$alpha: "α",
+	amp: "&",
+	$and: "∧",
+	$ang: "∠",
+	$apos: "'",
+	aring: "å",
+	$asymp: "≈",
+	atilde: "ã",
+	auml: "ä",
+	$bdquo: "„",
+	$beta: "β",
+	brvbar: "¦",
+	$bull: "•",
+	$cap: "∩",
+	ccedil: "ç",
+	cedil: "¸",
+	cent: "¢",
+	$chi: "χ",
+	$circ: "ˆ",
+	$clubs: "♣",
+	$cong: "≅",
+	copy: "©",
+	$crarr: "↵",
+	$cup: "∪",
+	curren: "¤",
+	$dArr: "⇓",
+	$dagger: "†",
+	$darr: "↓",
+	deg: "°",
+	$delta: "δ",
+	$diams: "♦",
+	divide: "÷",
+	eacute: "é",
+	ecirc: "ê",
+	egrave: "è",
+	$empty: "∅",
+	$epsilon: "ε",
+	$equiv: "≡",
+	$eta: "η",
+	eth: "ð",
+	euml: "ë",
+	$euro: "€",
+	$exist: "∃",
+	$fnof: "ƒ",
+	$forall: "∀",
+	frac12: "½",
+	frac14: "¼",
+	frac34: "¾",
+	$frasl: "⁄",
+	$gamma: "γ",
+	$ge: "≥",
+	gt: ">",
+	$hArr: "⇔",
+	$harr: "↔",
+	$hearts: "♥",
+	$hellip: "…",
+	iacute: "í",
+	icirc: "î",
+	iexcl: "¡",
+	igrave: "ì",
+	$image: "ℑ",
+	$infin: "∞",
+	$int: "∫",
+	$iota: "ι",
+	iquest: "¿",
+	$isin: "∈",
+	iuml: "ï",
+	$kappa: "κ",
+	$lArr: "⇐",
+	$lambda: "λ",
+	$lang: "⟨",
+	laquo: "«",
+	$larr: "←",
+	$lceil: "⌈",
+	$ldquo: "“",
+	$le: "≤",
+	$lfloor: "⌊",
+	$lowast: "∗",
+	$loz: "◊",
+	$lsaquo: "‹",
+	$lsquo: "‘",
+	lt: "<",
+	macr: "¯",
+	$mdash: "—",
+	micro: "µ",
+	middot: "·",
+	$minus: "−",
+	$mu: "μ",
+	$nabla: "∇",
+	nbsp: "\xA0",
+	$ndash: "–",
+	$ne: "≠",
+	$ni: "∋",
+	not: "¬",
+	$notin: "∉",
+	$nsub: "⊄",
+	ntilde: "ñ",
+	$nu: "ν",
+	oacute: "ó",
+	ocirc: "ô",
+	$oelig: "œ",
+	ograve: "ò",
+	$oline: "‾",
+	$omega: "ω",
+	$omicron: "ο",
+	$oplus: "⊕",
+	$or: "∨",
+	ordf: "ª",
+	ordm: "º",
+	oslash: "ø",
+	otilde: "õ",
+	$otimes: "⊗",
+	ouml: "ö",
+	para: "¶",
+	$part: "∂",
+	$permil: "‰",
+	$perp: "⊥",
+	$phi: "φ",
+	$pi: "π",
+	$piv: "ϖ",
+	plusmn: "±",
+	pound: "£",
+	$prime: "′",
+	$prod: "∏",
+	$prop: "∝",
+	$psi: "ψ",
+	quot: "\"",
+	$rArr: "⇒",
+	$radic: "√",
+	$rang: "⟩",
+	raquo: "»",
+	$rarr: "→",
+	$rceil: "⌉",
+	$rdquo: "”",
+	$real: "ℜ",
+	reg: "®",
+	$rfloor: "⌋",
+	$rho: "ρ",
+	$rsaquo: "›",
+	$rsquo: "’",
+	$sbquo: "‚",
+	$scaron: "š",
+	$sdot: "⋅",
+	sect: "§",
+	shy: "­",
+	$sigma: "σ",
+	$sigmaf: "ς",
+	$sim: "∼",
+	$spades: "♠",
+	$sub: "⊂",
+	$sube: "⊆",
+	$sum: "∑",
+	$sup: "⊃",
+	sup1: "¹",
+	sup2: "²",
+	sup3: "³",
+	$supe: "⊇",
+	szlig: "ß",
+	$tau: "τ",
+	$there4: "∴",
+	$theta: "θ",
+	$thetasym: "ϑ",
+	thorn: "þ",
+	$tilde: "˜",
+	times: "×",
+	$trade: "™",
+	$uArr: "⇑",
+	uacute: "ú",
+	$uarr: "↑",
+	ucirc: "û",
+	ugrave: "ù",
+	uml: "¨",
+	$upsih: "ϒ",
+	$upsilon: "υ",
+	uuml: "ü",
+	$weierp: "℘",
+	$xi: "ξ",
+	yacute: "ý",
+	yen: "¥",
+	yuml: "ÿ",
+	$zeta: "ζ"
+};
+function lowerAscii(code) {
+	return code >= 65 && code <= 90 ? code + 32 : code;
+}
+function isInsideHeading(depthMap) {
+	for (let tagId = 7; tagId <= 12; tagId++) if (depthMap[tagId]) return true;
+	return false;
+}
+function isInsideTableCell(state) {
+	const depthMap = state.depthMap;
+	return depthMap[32] > 0 || depthMap[31] > 0;
+}
+function schemeMatches(href, start, end, scheme) {
+	let matched = 0;
+	for (let index = start; index < end; index++) {
+		const code = href.charCodeAt(index);
+		if (code === 9 || code === 10 || code === 13) continue;
+		if (lowerAscii(code) !== scheme.charCodeAt(matched)) return false;
+		if (++matched === scheme.length) return true;
+	}
+	return false;
+}
+function isDataUrl(src) {
+	let start = 0;
+	while (start < src.length && src.charCodeAt(start) <= 32) start++;
+	let end = src.length;
+	while (end > start && src.charCodeAt(end - 1) <= 32) end--;
+	return schemeMatches(src, start, end, "data:");
+}
+function isEmptyLinkHref(href) {
+	let start = 0;
+	while (start < href.length && href.charCodeAt(start) <= 32) start++;
+	let end = href.length;
+	while (end > start && href.charCodeAt(end - 1) <= 32) end--;
+	switch (lowerAscii(href.charCodeAt(start))) {
+		case 35: return end - start === 1;
+		case 106: return schemeMatches(href, start, end, "javascript:");
+		case 100: return schemeMatches(href, start, end, "data:");
+		case 118: return schemeMatches(href, start, end, "vbscript:");
+		default: return false;
+	}
+}
+function isSafeHtmlUrl(href, image = false) {
+	let start = 0;
+	while (start < href.length && href.charCodeAt(start) <= 32) start++;
+	let end = href.length;
+	while (end > start && href.charCodeAt(end - 1) <= 32) end--;
+	if (start === end) return false;
+	for (let index = start; index < end; index++) {
+		const code = href.charCodeAt(index);
+		if (code === 9 || code === 10 || code === 13) continue;
+		if (code === 58) switch (lowerAscii(href.charCodeAt(start))) {
+			case 104: return schemeMatches(href, start, end, "http:") || schemeMatches(href, start, end, "https:");
+			case 109: return !image && schemeMatches(href, start, end, "mailto:");
+			case 116: return !image && schemeMatches(href, start, end, "tel:");
+			case 102: return !image && schemeMatches(href, start, end, "ftp:");
+			default: return false;
+		}
+		if (code === 47 || code === 63 || code === 35) return true;
+		const lower = lowerAscii(code);
+		if (!(lower >= 97 && lower <= 122 || code >= 48 && code <= 57 || code === 43 || code === 45 || code === 46)) return true;
+	}
+	return true;
+}
+function escapeHtml(value, attribute = false, protectMarkdown = false) {
+	let escaped = "";
+	let copiedUntil = 0;
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		let replacement;
+		if (code === 38) replacement = "&amp;";
+		else if (code === 60) replacement = "&lt;";
+		else if (code === 62) replacement = "&gt;";
+		else if (attribute && code === 34) replacement = "&quot;";
+		else if (protectMarkdown && code === 91) replacement = "&#91;";
+		else if (protectMarkdown && code === 93) replacement = "&#93;";
+		if (replacement !== void 0) {
+			escaped += value.slice(copiedUntil, index) + replacement;
+			copiedUntil = index + 1;
+		}
+	}
+	return copiedUntil === 0 ? value : escaped + value.slice(copiedUntil);
+}
+function continuationPrefix(node, listIndentWidths, includeBlockquotes = true) {
+	const chain = [];
+	let current = node.parent;
+	while (current) {
+		chain.push(current);
+		current = current.parent;
+	}
+	let prefix = "";
+	let listIndex = 0;
+	for (let i = chain.length - 1; i >= 0; i--) {
+		const tagId = chain[i].tagId;
+		if (tagId === 22 && includeBlockquotes) prefix += "> ";
+		else if (tagId === 25) {
+			prefix += " ".repeat(listIndentWidths[listIndex] ?? 2);
+			listIndex++;
+		}
+	}
+	return prefix;
+}
+const C1_REPLACEMENTS = "€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ";
+function isAsciiAlphaNumeric(code) {
+	return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function isHtmlAsciiWhitespace(code) {
+	return code === 32 || code === 9 || code === 10 || code === 12 || code === 13;
+}
+const LANGUAGE_PREFIX = [
+	108,
+	97,
+	110,
+	103,
+	117,
+	97,
+	103,
+	101,
+	45
+];
+function hasLanguagePrefix(value, start) {
+	for (let offset = 0; offset < 9; offset++) if (value.charCodeAt(start + offset) !== LANGUAGE_PREFIX[offset]) return false;
+	return true;
+}
+function isUnsafeFenceInfoCode(code) {
+	if (code < 32 || code === 127) return true;
+	return code === 34 || code === 39 || code === 38 || code === 60 || code === 62 || code === 96 || code === 126;
+}
+function getLanguageFromClass(className) {
+	if (!className) return "";
+	const length = className.length;
+	let index = 0;
+	while (index < length) {
+		if (isHtmlAsciiWhitespace(className.charCodeAt(index))) {
+			index++;
+			continue;
+		}
+		const tokenStart = index;
+		do
+			index++;
+		while (index < length && !isHtmlAsciiWhitespace(className.charCodeAt(index)));
+		const tokenEnd = index;
+		const languageStart = tokenStart + 9;
+		if (languageStart >= tokenEnd || !hasLanguagePrefix(className, tokenStart)) continue;
+		let valid = true;
+		for (let cursor = languageStart; cursor < tokenEnd; cursor++) if (isUnsafeFenceInfoCode(className.charCodeAt(cursor))) {
+			valid = false;
+			break;
+		}
+		if (valid) return className.slice(languageStart, tokenEnd);
+	}
+	return "";
+}
+function parseUnsignedInteger(raw) {
+	if (raw === void 0 || !/^[\t\n\f\r ]*\+?\d+[\t\n\f\r ]*$/.test(raw)) return void 0;
+	const value = Number(raw);
+	return value <= 4294967295 ? value : void 0;
+}
+function lastOutputChar(buffer, end = buffer.length) {
+	for (let index = end - 1; index >= 0; index--) {
+		const fragment = buffer[index];
+		if (fragment.length > 0) return fragment.charCodeAt(fragment.length - 1);
+	}
+	return -1;
+}
+function blockOpenPrefix(buffer, prefix, end = buffer.length) {
+	switch (lastOutputChar(buffer, end)) {
+		case -1: return;
+		case 32: {
+			let fragment = end - 1;
+			let index = buffer[fragment].length;
+			for (;;) {
+				if (index === 0) {
+					if (--fragment < 0) return void 0;
+					index = buffer[fragment].length;
+					continue;
+				}
+				const code = buffer[fragment].charCodeAt(--index);
+				if (code !== 32) return code === 10 || listMarkerLineStart(buffer, fragment, index) ? void 0 : `\n\n${prefix ?? ""}`;
+			}
+		}
+		case 10: return prefix || void 0;
+		default: return `\n\n${prefix ?? ""}`;
+	}
+}
+function figcaptionOwnsBlockSpacing(node, plainText) {
+	let parent = node.parent;
+	while (parent) {
+		if (parent.tagId === 32 || parent.tagId === 31) return false;
+		if (!plainText && parent.tagId !== 37 && parent.tagHandler?.collapsesInnerWhiteSpace) return false;
+		parent = parent.parent;
+	}
+	return true;
+}
+function listMarkerLineStart(buffer, fragmentIndex, markerIndex) {
+	const marker = buffer[fragmentIndex].charCodeAt(markerIndex);
+	const ordered = marker === 46 || marker === 41;
+	if (!ordered && marker !== 45 && marker !== 42 && marker !== 43) return false;
+	let digits = 0;
+	let spaces = 0;
+	let fragment = fragmentIndex;
+	let cursor = markerIndex;
+	for (;;) {
+		if (cursor === 0) {
+			if (--fragment < 0) return !ordered || digits > 0;
+			cursor = buffer[fragment].length;
+			continue;
+		}
+		const code = buffer[fragment].charCodeAt(--cursor);
+		if (ordered && spaces === 0 && code >= 48 && code <= 57) {
+			if (++digits > 9) return false;
+			continue;
+		}
+		if (ordered && digits === 0) return false;
+		if (code === 32) {
+			if (++spaces > 3) return false;
+			continue;
+		}
+		return code === 10;
+	}
+}
+const MAX_ORDERED_START = 999999999;
+function orderedItemNumber(list, index) {
+	const raw = list?.attributes?.start;
+	if (raw === void 0) return index + 1;
+	const start = parseUnsignedInteger(raw);
+	if (start === void 0 || start > MAX_ORDERED_START) return Math.min(1 + index, MAX_ORDERED_START);
+	return Math.min(start + index, MAX_ORDERED_START);
+}
+function numericReplacement(codePoint) {
+	if (codePoint === 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343) return "�";
+	if (codePoint >= 128 && codePoint <= 159) return C1_REPLACEMENTS[codePoint - 128];
+	return String.fromCodePoint(codePoint);
+}
+function isCharacterReferenceTail(text, start) {
+	let index = start;
+	if (text.charCodeAt(index) === 35) {
+		index++;
+		const hex = text.charCodeAt(index) === 120 || text.charCodeAt(index) === 88;
+		if (hex) index++;
+		const digitStart = index;
+		while (index < text.length) {
+			const code = text.charCodeAt(index);
+			if (!(code >= 48 && code <= 57) && !(hex && (code >= 65 && code <= 70 || code >= 97 && code <= 102))) break;
+			index++;
+		}
+		return index > digitStart && text.charCodeAt(index) === 59;
+	}
+	const nameStart = index;
+	while (index < text.length && isAsciiAlphaNumeric(text.charCodeAt(index))) index++;
+	return index > nameStart && text.charCodeAt(index) === 59;
+}
+function decodedReference(replacement, text, next, protectDecodedEntityReferences) {
+	return replacement === "&" && protectDecodedEntityReferences && isCharacterReferenceTail(text, next) ? "\\&" : replacement;
+}
+function decodeHTMLEntities(text, inAttribute = false, protectDecodedEntityReferences = false) {
+	let result = "";
+	let i = 0;
+	const len = text.length;
+	while (i < len) {
+		if (text.charCodeAt(i) !== 38) {
+			const plainStart = i;
+			while (i < len && text.charCodeAt(i) !== 38) i++;
+			result += text.slice(plainStart, i);
+			continue;
+		}
+		if (i + 2 < len && text.charCodeAt(i + 1) === 35) {
+			let end = i + 2;
+			const isHex = text.charCodeAt(end) === 120 || text.charCodeAt(end) === 88;
+			if (isHex) end++;
+			const digitStart = end;
+			let codePoint = 0;
+			while (end < len) {
+				const code = text.charCodeAt(end);
+				let digit = -1;
+				if (code >= 48 && code <= 57) digit = code - 48;
+				else if (isHex && code >= 65 && code <= 70) digit = code - 55;
+				else if (isHex && code >= 97 && code <= 102) digit = code - 87;
+				if (digit < 0) break;
+				codePoint = codePoint * (isHex ? 16 : 10) + digit;
+				end++;
+			}
+			if (end > digitStart) {
+				result += decodedReference(numericReplacement(codePoint), text, text.charCodeAt(end) === 59 ? end + 1 : end, protectDecodedEntityReferences);
+				if (text.charCodeAt(end) === 59) end++;
+				i = end;
+				continue;
+			}
+		}
+		const nameStart = i + 1;
+		let nameEnd = nameStart;
+		const scanEnd = Math.min(len, nameStart + 8);
+		while (nameEnd < scanEnd && isAsciiAlphaNumeric(text.charCodeAt(nameEnd))) nameEnd++;
+		if (nameEnd > nameStart && text.charCodeAt(nameEnd) === 59) {
+			const name = text.slice(nameStart, nameEnd);
+			const direct = HTML_ENTITIES[name];
+			const replacement = typeof direct === "string" ? direct : HTML_ENTITIES[`$${name}`];
+			if (replacement !== void 0) {
+				result += decodedReference(replacement, text, nameEnd + 1, protectDecodedEntityReferences);
+				i = nameEnd + 1;
+				continue;
+			}
+		}
+		let legacyEnd = Math.min(nameEnd, nameStart + 6);
+		let decodedLegacy = false;
+		while (legacyEnd > nameStart) {
+			const name = text.slice(nameStart, legacyEnd);
+			const replacement = HTML_ENTITIES[name];
+			if (typeof replacement === "string") {
+				const next = text.charCodeAt(legacyEnd);
+				if (replacement !== void 0 && !(inAttribute && (next === 61 || isAsciiAlphaNumeric(next)))) {
+					result += decodedReference(replacement, text, legacyEnd, protectDecodedEntityReferences);
+					i = legacyEnd;
+					decodedLegacy = true;
+				}
+				break;
+			}
+			legacyEnd--;
+		}
+		if (decodedLegacy) continue;
+		result += "&";
+		i++;
+	}
+	return result;
+}
+function isInlineNode(node) {
+	const isInline = node.tagHandler?.isInline;
+	return isInline === void 0 ? node.tagId === -1 : isInline;
+}
+function traverseUpToFirstBlockNode(node) {
+	let firstBlockParent = node;
+	const parentsToIncrement = [firstBlockParent];
+	while (isInlineNode(firstBlockParent)) {
+		if (!firstBlockParent.parent) break;
+		firstBlockParent = firstBlockParent.parent;
+		parentsToIncrement.push(firstBlockParent);
+	}
+	return parentsToIncrement;
+}
+function markRenderedChildContent(node) {
+	let parent = node.parent;
+	let anchorInScope = false;
+	while (parent) {
+		parent.childTextNodeIndex = (parent.childTextNodeIndex || 0) + 1;
+		if (parent.tagId === 26) anchorInScope = true;
+		if (!isInlineNode(parent)) break;
+		parent = parent.parent;
+	}
+	if (anchorInScope) return;
+	let anchorFound = false;
+	while (parent?.parent) {
+		parent = parent.parent;
+		if (!anchorFound) {
+			if (parent.tagId !== 26) continue;
+			anchorFound = true;
+		}
+		parent.childTextNodeIndex = (parent.childTextNodeIndex || 0) + 1;
+		if (!isInlineNode(parent)) return;
+	}
+}
+const TRACKING_PARAM_RE = /^(?:utm_|fbclid|gclid|mc_eid|msclkid|oly_)/;
+const URL_SCHEME_RE = /^[A-Z][\dA-Z+.-]*:/i;
+const SLASH_CHAR$1 = 47;
+function stripTrackingParams(url) {
+	const queryStart = url.indexOf("?");
+	const fragmentStart = url.indexOf("#");
+	if (queryStart === -1 || fragmentStart !== -1 && fragmentStart < queryStart) return url;
+	const queryEnd = fragmentStart === -1 ? url.length : fragmentStart;
+	const query = url.slice(queryStart + 1, queryEnd).split("&").filter((parameter) => !TRACKING_PARAM_RE.test(parameter)).join("&");
+	return `${url.slice(0, queryStart)}${query ? `?${query}` : ""}${url.slice(queryEnd)}`;
+}
+function pathEnd(value, from) {
+	const query = value.indexOf("?", from);
+	const fragment = value.indexOf("#", from);
+	if (query === -1) return fragment === -1 ? value.length : fragment;
+	return fragment === -1 ? query : Math.min(query, fragment);
+}
+function hasDotSegment(path) {
+	return path.includes(".") && (path === "." || path === ".." || path.startsWith("./") || path.startsWith("../") || path.includes("/./") || path.includes("/../") || path.endsWith("/.") || path.endsWith("/.."));
+}
+function mergeDotSegments(dir, rest) {
+	let out = dir;
+	let index = 0;
+	for (;;) {
+		let end = rest.indexOf("/", index);
+		const last = end === -1;
+		if (last) end = rest.length;
+		const segment = rest.slice(index, end);
+		if (segment === "..") out = out.slice(0, out.lastIndexOf("/", out.length - 2) + 1);
+		else if (segment !== ".") out += last ? segment : `${segment}/`;
+		if (last) return out;
+		index = end + 1;
+	}
+}
+let baseOrigin;
+let baseRoot = "";
+let basePath = "";
+let baseDir = "";
+function loadBase(origin) {
+	if (origin !== baseOrigin) {
+		baseOrigin = origin;
+		baseRoot = "";
+		const authority = origin.indexOf("://");
+		if (authority !== -1) {
+			const end = pathEnd(origin, authority + 3);
+			const slash = origin.indexOf("/", authority + 3);
+			const rootEnd = slash === -1 || slash > end ? end : slash;
+			baseRoot = origin.slice(0, rootEnd);
+			basePath = origin.slice(rootEnd, end);
+			baseDir = basePath.slice(0, basePath.lastIndexOf("/") + 1) || "/";
+		}
+	}
+	return baseRoot !== "";
+}
+function resolveAgainstBase(origin, url) {
+	if (!loadBase(origin)) {
+		let prefix = origin;
+		while (prefix.endsWith("/")) prefix = prefix.slice(0, -1);
+		const path = url.startsWith("./") ? url.slice(2) : url;
+		return `${prefix}${path.charCodeAt(0) === SLASH_CHAR$1 ? "" : "/"}${path}`;
+	}
+	const end = pathEnd(url, 0);
+	const path = url.slice(0, end);
+	const suffix = end === url.length ? "" : url.slice(end);
+	if (!path) return `${baseRoot}${basePath}${suffix}`;
+	const dot = hasDotSegment(path);
+	if (path.charCodeAt(0) === SLASH_CHAR$1) return `${baseRoot}${dot ? mergeDotSegments("/", path.slice(1)) : path}${suffix}`;
+	return `${baseRoot}${dot ? mergeDotSegments(baseDir, path) : baseDir + path}${suffix}`;
+}
+function resolveUrl(url, origin, clean) {
+	if (!url || url[0] === "#") return url;
+	const isSlash = url.charCodeAt(0) === SLASH_CHAR$1;
+	let resolved = url;
+	if (isSlash && url.charCodeAt(1) === SLASH_CHAR$1) {
+		let scheme = "https";
+		if (origin && loadBase(origin)) scheme = baseRoot.slice(0, baseRoot.indexOf(":"));
+		resolved = `${scheme}:${url}`;
+	} else if (origin && (isSlash || !URL_SCHEME_RE.test(url))) resolved = resolveAgainstBase(origin, url);
+	return (clean === true || !!clean && clean.urls === true) && resolved.includes("?") ? stripTrackingParams(resolved) : resolved;
+}
+function safeAnchorOutput(node, options, entering, protectMarkdown = false) {
+	const href = node.attributes?.href;
+	if (!href || !isSafeHtmlUrl(href)) return;
+	const resolved = resolveUrl(href, options?.origin, options?.clean);
+	if (!isSafeHtmlUrl(resolved)) return;
+	if (!entering) return "</a>";
+	return `<a href="${escapeHtml(resolved, true, protectMarkdown)}"${node.attributes?.title === void 0 ? "" : ` title="${escapeHtml(node.attributes.title, true, protectMarkdown)}"`}>`;
+}
+function serializeMarkdownDestination(destination) {
+	if (!/[\t\n\f\r ()\\<>]/.test(destination)) return destination;
+	return `<${/[\\<>]/.test(destination) ? destination.replace(/[\\<>]/g, "\\$&") : destination}>`;
+}
+function stripsEmptyLink(state, href) {
+	const clean = state.options?.clean;
+	if (!(clean === true || typeof clean === "object" && clean.emptyLinks)) return false;
+	return isEmptyLinkHref(href);
+}
+function serializeMarkdownTitle(title) {
+	return /[\\"]/.test(title) ? title.replace(/[\\"]/g, "\\$&") : title;
+}
+function serializeMarkdownResource(destination, title) {
+	const serializedTitle = title ? ` "${serializeMarkdownTitle(title)}"` : "";
+	return `(${serializeMarkdownDestination(destination)}${serializedTitle})`;
+}
+function serializeImageDescription(alt) {
+	return /[\\[\]*_`~<&]/.test(alt) ? alt.replace(/[\\[\]*_`~<&]/g, "\\$&") : alt;
+}
+function isAutolinkUri(s) {
+	if (!(s.startsWith("http://") || s.startsWith("https://") || s.startsWith("ftp://") || s.startsWith("mailto:"))) return false;
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (c === 32 || c === 60 || c === 62 || c === 10 || c === 13 || c === 9) return false;
+	}
+	return true;
+}
+function renderBreak(node, state) {
+	const depthMap = state.depthMap;
+	if (isInsideTableCell(state) || isInsideRawHtmlBlock(depthMap) || isInsideHeading(depthMap)) return "<br>";
+	if (depthMap[34] || depthMap[23]) return "\n";
+	return `  \n${continuationPrefix(node, state.listIndentWidths || [], !state.bufferedBlockquoteDepth)}`;
+}
+const breakHandler = {
+	enter: ({ node, state }) => renderBreak(node, state),
+	isSelfClosing: true,
+	spacing: NO_SPACING,
+	collapsesInnerWhiteSpace: true,
+	isInline: true
+};
+function escapeTrailingHeadingHashes(buffer) {
+	let index = buffer.length - 1;
+	while (index >= 0 && buffer[index] === "") index--;
+	if (index < 0) return;
+	const entry = buffer[index];
+	let end = entry.length;
+	while (end > 0 && (entry[end - 1] === " " || entry[end - 1] === "	")) end--;
+	let run = end;
+	while (run > 0 && entry[run - 1] === "#") run--;
+	if (run === end) return;
+	const previous = buffer[index - 1];
+	const before = run > 0 ? entry[run - 1] : previous?.charAt(previous.length - 1);
+	if (before !== " " && before !== "	") return;
+	buffer[index] = `${entry.slice(0, run)}\\${entry.slice(run)}`;
+}
+const LINE_FRESH = -1;
+const LINE_OPEN = 0;
+const LINE_ROW = 1;
+const LINE_CONTENT = 2;
+function lineStateBeforeRow(buffer) {
+	let fragment = buffer.length - 1;
+	while (fragment >= 0 && buffer[fragment].length === 0) fragment--;
+	if (fragment < 0) return LINE_OPEN;
+	const tail = buffer[fragment];
+	if (tail.charCodeAt(tail.length - 1) === 10) return LINE_FRESH;
+	let firstNonSpace = -1;
+	let markerFragment = -1;
+	let markerIndex = -1;
+	let cursor = tail.length;
+	for (;;) {
+		if (cursor === 0) {
+			if (--fragment < 0) break;
+			cursor = buffer[fragment].length;
+			continue;
+		}
+		const code = buffer[fragment].charCodeAt(--cursor);
+		if (code === 10) break;
+		if (code !== 32 && code !== 9) {
+			firstNonSpace = code;
+			if (markerFragment < 0) {
+				markerFragment = fragment;
+				markerIndex = cursor;
+			}
+		}
+	}
+	if (firstNonSpace === -1) return LINE_OPEN;
+	if (firstNonSpace === 124) return LINE_ROW;
+	return listMarkerLineStart(buffer, markerFragment, markerIndex) ? LINE_OPEN : LINE_CONTENT;
+}
+function rowMarker(state) {
+	const indent = state.listIndent;
+	const lineState = lineStateBeforeRow(state.buffer);
+	if (!indent) return lineState === LINE_ROW ? "\n| " : lineState === LINE_CONTENT ? "\n\n| " : "| ";
+	switch (lineState) {
+		case LINE_ROW: return `\n${indent}| `;
+		case LINE_CONTENT: return `\n\n${indent}| `;
+		case LINE_FRESH: return `${indent}| `;
+		default: return "| ";
+	}
+}
+const MAX_CELL_SPAN = 64;
+function cellEnter(node, state) {
+	if (node.index === 0) return "";
+	const header = state.tableHeaderCells || 0;
+	return header > 0 && (state.tableCurrentRowCells || 0) >= header ? " " : " | ";
+}
+function cellExit(node, state) {
+	const parsedSpan = parseUnsignedInteger(node.attributes?.colspan);
+	const span = parsedSpan && parsedSpan < 256 ? Math.min(parsedSpan, MAX_CELL_SPAN) : 1;
+	state.tableCurrentRowCells += span;
+	return span > 1 ? " |".repeat(span - 1) : void 0;
+}
+function handleHeading(depth) {
+	return {
+		enter: ({ state }) => {
+			if ((state.depthMap?.[26] || 0) > 0 || isInsideTableCell(state)) return `<h${depth}>`;
+			return `${"#".repeat(depth)} `;
+		},
+		exit: ({ state }) => {
+			if ((state.depthMap?.[26] || 0) > 0 || isInsideTableCell(state)) return `</h${depth}>`;
+			escapeTrailingHeadingHashes(state.buffer);
+		},
+		collapsesInnerWhiteSpace: true
+	};
+}
+const Strong = {
+	enter: ({ state }) => {
+		if ((state.depthMap?.[15] || 0) > 1) return "";
+		return "**";
+	},
+	exit: ({ node, state }) => {
+		if ((state.depthMap?.[15] || 0) + (node.tagId === 15 ? 1 : 0) > 1) return "";
+		return "**";
+	},
+	collapsesInnerWhiteSpace: true,
+	spacing: NO_SPACING,
+	isInline: true
+};
+const Emphasis = {
+	enter: ({ state }) => {
+		if ((state.depthMap?.[17] || 0) > 1) return "";
+		return "*";
+	},
+	exit: ({ node, state }) => {
+		if ((state.depthMap?.[17] || 0) + (node.tagId === 17 ? 1 : 0) > 1) return "";
+		return "*";
+	},
+	collapsesInnerWhiteSpace: true,
+	spacing: NO_SPACING,
+	isInline: true
+};
+const Strikethrough = {
+	enter: () => "~~",
+	exit: () => "~~",
+	collapsesInnerWhiteSpace: true,
+	spacing: NO_SPACING,
+	isInline: true
+};
+const INERT_RAWTEXT = {
+	isNonNesting: true,
+	excludesTextNodes: true,
+	spacing: NO_SPACING
+};
+const tagHandlers = {
+	[1]: {
+		spacing: NO_SPACING,
+		collapsesInnerWhiteSpace: true
+	},
+	[2]: {
+		enter: () => "<details>",
+		exit: ({ state }) => isInsideTableCell(state) ? "</details>" : "</details>\n\n"
+	},
+	[3]: {
+		enter: () => "<summary>",
+		exit: ({ state }) => isInsideTableCell(state) ? "</summary>" : "</summary>\n\n"
+	},
+	[4]: {
+		excludesTextNodes: true,
+		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]: breakHandler,
+	[7]: handleHeading(1),
+	[8]: handleHeading(2),
+	[9]: handleHeading(3),
+	[10]: handleHeading(4),
+	[11]: handleHeading(5),
+	[12]: handleHeading(6),
+	[13]: {
+		enter: ({ node, state }) => {
+			if (isInsideTableCell(state)) return "<hr>";
+			if (!(state.depthMap?.[25] || state.bufferedBlockquoteDepth)) return "---";
+			const prefix = continuationPrefix(node, state.listIndentWidths || [], !state.bufferedBlockquoteDepth);
+			if (!prefix) return "---";
+			if (state.depthMap?.[25]) state.listRulePending = prefix;
+			const open = blockOpenPrefix(state.buffer, prefix);
+			return open === void 0 ? "***" : `${open}---`;
+		},
+		isSelfClosing: true
+	},
+	[14]: Strong,
+	[15]: Strong,
+	[16]: Emphasis,
+	[17]: Emphasis,
+	[18]: Strikethrough,
+	[110]: Strikethrough,
+	[111]: Strikethrough,
+	[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: ({ state }) => {
+			return {
+				_tag: "BlockquoteEnter",
+				output: (state.depthMap?.[25] || 0) > 0 ? "\n" : void 0
+			};
+		},
+		exit: () => ({ _tag: "BlockquoteExit" }),
+		spacing: BLOCKQUOTE_SPACING
+	},
+	[34]: {
+		enter: ({ node, state }) => {
+			if (isInsideTableCell(state)) return "<pre>";
+			return {
+				_tag: "PreEnter",
+				language: getLanguageFromClass(node.attributes?.class)
+			};
+		},
+		exit: ({ state }) => {
+			if (isInsideTableCell(state)) return "</pre>";
+			return { _tag: "PreExit" };
+		}
+	},
+	[23]: {
+		enter: ({ node, state }) => {
+			if ((state.depthMap?.[34] || 0) > 0) {
+				if (isInsideTableCell(state)) return "<code>";
+				if (state.preFenceOpen) return;
+				const language = getLanguageFromClass(node.attributes?.class);
+				if ((state.depthMap?.[25] || 0) > 0) {
+					const indent = state.listIndent;
+					return {
+						_tag: "CodeFenceEnter",
+						language,
+						output: `${blockOpenPrefix(state.buffer, indent) ?? ""}\`\`\`${language}\n`
+					};
+				}
+				return {
+					_tag: "CodeFenceEnter",
+					language,
+					output: `\`\`\`${language}\n`
+				};
+			}
+			if (isInsideRawHtmlBlock(state.depthMap)) return "<code>";
+			if ((state.depthMap?.[25] || 0) > 0) {
+				const lastEntry = state.buffer.at(-1);
+				const lastChar = lastEntry?.charAt(lastEntry.length - 1) || "";
+				if (lastChar && lastChar !== " " && lastChar !== "\n" && lastChar !== "	" && lastChar !== "*" && lastChar !== "_" && lastChar !== "~" && lastChar !== "[" && lastChar !== ">") return {
+					_tag: "CodeSpanEnter",
+					output: ` \``
+				};
+			}
+			return {
+				_tag: "CodeSpanEnter",
+				output: "`"
+			};
+		},
+		exit: ({ state }) => {
+			if ((state.depthMap?.[34] || 0) > 0) {
+				if (isInsideTableCell(state)) return "</code>";
+				return;
+			}
+			if (isInsideRawHtmlBlock(state.depthMap)) return "</code>";
+			return { _tag: "CodeSpanExit" };
+		},
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[24]: {
+		enter: ({ state }) => isInsideTableCell(state) ? "<ul>" : void 0,
+		exit: ({ state }) => isInsideTableCell(state) ? "</ul>" : void 0
+	},
+	[33]: {
+		enter: ({ state }) => isInsideTableCell(state) ? "<ol>" : void 0,
+		exit: ({ state }) => isInsideTableCell(state) ? "</ol>" : void 0
+	},
+	[25]: {
+		enter: ({ node, state }) => {
+			if (isInsideTableCell(state)) return "<li>";
+			const marker = node.parent?.tagId === 33 ? `${orderedItemNumber(node.parent, node.index)}. ` : "- ";
+			return `${state.listIndent}${marker}`;
+		},
+		exit: ({ state }) => isInsideTableCell(state) ? "</li>" : void 0,
+		spacing: LIST_ITEM_SPACING
+	},
+	[26]: {
+		enter: ({ node, state }) => {
+			if (node.attributes?.href !== void 0) {
+				if (stripsEmptyLink(state, node.attributes.href)) return;
+				if (isInsideRawHtmlBlock(state.depthMap)) return safeAnchorOutput(node, state.options, true, true);
+				return "[";
+			}
+		},
+		exit: ({ node, state }) => {
+			if (node.attributes?.href === void 0) return "";
+			if (stripsEmptyLink(state, node.attributes.href)) return "";
+			if (isInsideRawHtmlBlock(state.depthMap) && !node.tagHandler?.literalEnter) return safeAnchorOutput(node, state.options, false, true);
+			const href = resolveUrl(node.attributes.href, state.options?.origin, state.options?.clean);
+			let title = node.attributes?.title;
+			if (state.lastContentCache === title) title = "";
+			if (!title && isAutolinkUri(href)) {
+				const buf = state.buffer;
+				let i = buf.length - 1;
+				let textLen = 0;
+				let captionBracket = -1;
+				let captionTextLen = 0;
+				while (i >= 0) {
+					const entry = buf[i];
+					if (entry === "[") break;
+					if (captionBracket < 0 && state.depthMap?.[106] && entry.endsWith("*[")) {
+						captionBracket = i;
+						captionTextLen = textLen;
+					}
+					textLen += entry.length;
+					i--;
+				}
+				const captionLink = i < 0 && captionBracket >= 0;
+				if (captionLink) {
+					i = captionBracket;
+					textLen = captionTextLen;
+				}
+				if (i >= 0 && textLen === href.length && buf.slice(i + 1).join("") === href) {
+					if (captionLink) buf[i] = buf[i].slice(0, -1);
+					buf.length = i + (captionLink ? 1 : 0);
+					const auto = `<${href}>`;
+					buf.push(auto);
+					state.lastContentCache = auto;
+					return "";
+				}
+			}
+			return `]${serializeMarkdownResource(href, title)}`;
+		},
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[27]: {
+		enter: ({ node, state }) => {
+			const alt = node.attributes?.alt || "";
+			const rawSrc = node.attributes?.src || "";
+			const src = isDataUrl(rawSrc) ? "" : resolveUrl(rawSrc, state.options?.origin, state.options?.clean);
+			const clean = state.options?.clean;
+			if ((clean === true || clean !== void 0 && clean !== false && clean.emptyImages === true) && !alt.trim()) {
+				if (state.depthMap?.[106]) return void 0;
+			} else markRenderedChildContent(node);
+			return `![${serializeImageDescription(alt)}]${serializeMarkdownResource(src, node.attributes?.title)}`;
+		},
+		collapsesInnerWhiteSpace: true,
+		isSelfClosing: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[28]: {
+		enter: ({ state }) => {
+			if (isInsideTableCell(state)) return "<table>";
+			if ((state.depthMap?.[28] || 0) <= 1) state.tableRenderedTable = false;
+			state.tableColumnAlignments = [];
+			state.tableHeaderCells = 0;
+		},
+		exit: ({ state }) => isInsideTableCell(state) ? "</table>" : void 0
+	},
+	[107]: { enter: ({ state }) => {
+		if ((state.depthMap?.[25] || 0) === 0 || isInsideTableCell(state)) return void 0;
+		return blockOpenPrefix(state.buffer, state.listIndent);
+	} },
+	[29]: {
+		enter: ({ state }) => {
+			if (isInsideTableCell(state)) return "<thead>";
+		},
+		exit: ({ state }) => isInsideTableCell(state) ? "</thead>" : void 0,
+		spacing: TABLE_ROW_SPACING,
+		excludesTextNodes: true
+	},
+	[30]: {
+		enter: ({ state }) => {
+			if (isInsideTableCell(state)) return "<tr>";
+			state.tableCurrentRowCells = 0;
+			return rowMarker(state);
+		},
+		exit: ({ state }) => {
+			if (isInsideTableCell(state) || (state.depthMap?.[28] || 0) > 1) return "</tr>";
+			if (!state.tableRenderedTable) {
+				state.tableRenderedTable = true;
+				const alignments = state.tableColumnAlignments;
+				while (alignments.length < state.tableCurrentRowCells) alignments.push("");
+				const alignmentMarkers = alignments.map((align) => {
+					switch (align) {
+						case "left": return ":---";
+						case "center": return ":---:";
+						case "right": return "---:";
+						default: return "---";
+					}
+				});
+				state.tableHeaderCells = alignments.length;
+				return ` |\n${(state.depthMap?.[25] || 0) > 0 ? state.listIndent : ""}| ${alignmentMarkers.join(" | ")} |`;
+			}
+			return " |";
+		},
+		excludesTextNodes: true,
+		spacing: TABLE_ROW_SPACING
+	},
+	[31]: {
+		enter: ({ node, state }) => {
+			if ((state.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 cellEnter(node, state);
+		},
+		exit: ({ node, state }) => {
+			if ((state.depthMap?.[28] || 0) > 1) return "</th>";
+			return cellExit(node, state);
+		},
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING
+	},
+	[32]: {
+		enter: ({ node, state }) => {
+			if ((state.depthMap?.[28] || 0) > 1) return "<td>";
+			return cellEnter(node, state);
+		},
+		exit: ({ node, state }) => {
+			if ((state.depthMap?.[28] || 0) > 1) return "</td>";
+			return cellExit(node, state);
+		},
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING
+	},
+	[35]: { enter: ({ state }) => {
+		if ((state.depthMap?.[25] || 0) > 0 && !isInsideTableCell(state)) {
+			const lastEntry = state.buffer.at(-1);
+			const lastChar = lastEntry?.charAt(lastEntry.length - 1) || "";
+			if (lastChar && lastChar !== " " && lastChar !== "\n") return `\n\n${state.listIndent}`;
+		}
+	} },
+	[36]: {},
+	[37]: {
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[41]: {},
+	[42]: {
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[43]: {
+		collapsesInnerWhiteSpace: true,
+		spacing: NO_SPACING,
+		isInline: true
+	},
+	[44]: { spacing: NO_SPACING },
+	[45]: {
+		enter: ({ state }) => {
+			if ((state.depthMap?.[28] || 0) > 1) return "<center>";
+		},
+		exit: ({ state }) => {
+			if ((state.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]: { spacing: NO_SPACING },
+	[109]: { spacing: NO_SPACING },
+	[68]: { spacing: NO_SPACING },
+	[69]: { spacing: NO_SPACING },
+	[70]: { spacing: NO_SPACING },
+	[71]: { spacing: NO_SPACING },
+	[72]: { spacing: NO_SPACING },
+	[73]: { ...INERT_RAWTEXT },
+	[74]: { spacing: NO_SPACING },
+	[75]: { spacing: NO_SPACING },
+	[76]: { spacing: NO_SPACING },
+	[77]: { spacing: NO_SPACING },
+	[78]: {
+		excludesTextNodes: true,
+		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]: { ...INERT_RAWTEXT },
+	[112]: { ...INERT_RAWTEXT },
+	[108]: {
+		isNonNesting: true,
+		excludesTextNodes: true,
+		spacing: NO_SPACING
+	},
+	[85]: { ...INERT_RAWTEXT },
+	[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]: {
+		exit: () => "*",
+		collapsesInnerWhiteSpace: true,
+		isInline: true
+	}
+};
+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,
+					aliasTagId: targetId
+				});
+			}
+		} 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;
+				handler.literalEnter = true;
+			}
+			if (override.exit !== void 0) {
+				const exitStr = override.exit;
+				handler.exit = () => exitStr;
+				handler.literalExit = true;
+			}
+			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;
+}
+const UNKNOWN_TAG_HANDLER = {
+	isInline: true,
+	spacing: NO_SPACING
+};
+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 QUESTION_CHAR = 63;
+const AMPERSAND_CHAR = 38;
+const DASH_CHAR = 45;
+const SPACE_CHAR = 32;
+const TAB_CHAR = 9;
+const NEWLINE_CHAR = 10;
+const FORM_FEED_CHAR = 12;
+const CARRIAGE_RETURN_CHAR = 13;
+const OPEN_BRACKET_CHAR = 91;
+const ATTRIBUTE_GAP = 0;
+const ATTRIBUTE_NAME = 1;
+const ATTRIBUTE_AFTER_NAME = 2;
+const ATTRIBUTE_BEFORE_VALUE = 3;
+const ATTRIBUTE_QUOTED_VALUE = 4;
+const ATTRIBUTE_UNQUOTED_VALUE = 5;
+function isAsciiAlpha(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function shouldProtectDecodedEntityReferences(state) {
+	const depthMap = state.depthMap;
+	return !state.plainText && !depthMap[34] && !depthMap[23] && !isInsideRawHtmlBlock(depthMap);
+}
+const SCRIPT_DATA = 0;
+const SCRIPT_DATA_ESCAPED = 1;
+const SCRIPT_DATA_ESCAPED_DASH = 2;
+const SCRIPT_DATA_ESCAPED_DASH_DASH = 3;
+const SCRIPT_DATA_DOUBLE_ESCAPED = 4;
+const SCRIPT_DATA_DOUBLE_ESCAPED_DASH = 5;
+const SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH = 6;
+const SCRIPT_SEQUENCE_NO_MATCH = -1;
+const SCRIPT_SEQUENCE_INCOMPLETE = -2;
+const SCRIPT_SCAN_COMPLETE = -1;
+const MAX_ELEMENT_DEPTH = 512;
+const HEAD_CONTENT_TAGS = /* @__PURE__ */ new Set([
+	4,
+	5,
+	54,
+	56,
+	53,
+	52,
+	84,
+	78
+]);
+const CLOSES_P = (() => {
+	const t = /* @__PURE__ */ new Uint8Array(113);
+	for (const id of [
+		36,
+		35,
+		24,
+		33,
+		101,
+		25,
+		98,
+		99,
+		28,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		22,
+		51,
+		50,
+		105,
+		47,
+		41,
+		88,
+		34,
+		13,
+		40,
+		68,
+		102,
+		106,
+		100,
+		104,
+		45,
+		2,
+		3,
+		75
+	]) t[id] = 1;
+	return t;
+})();
+const NEEDS_IMPLIED_END_RECOVERY = (() => {
+	const t = CLOSES_P.slice();
+	for (const id of [
+		26,
+		32,
+		31,
+		30,
+		29,
+		38,
+		39,
+		67,
+		109,
+		65
+	]) t[id] = 1;
+	return t;
+})();
+const P_SCOPE_BOUNDARY = /* @__PURE__ */ new Set([
+	43,
+	32,
+	31,
+	107,
+	28,
+	78,
+	0,
+	24,
+	33,
+	101,
+	25
+]);
+const LI_SCOPE_BOUNDARY = /* @__PURE__ */ new Set([
+	24,
+	33,
+	28,
+	32,
+	31,
+	107,
+	78,
+	0
+]);
+const DL_SCOPE_BOUNDARY = /* @__PURE__ */ new Set([
+	101,
+	24,
+	33,
+	25,
+	28,
+	32,
+	31,
+	107,
+	78,
+	0
+]);
+const CELL_SCOPE_BOUNDARY = /* @__PURE__ */ new Set([
+	30,
+	29,
+	38,
+	39,
+	28,
+	107,
+	78,
+	0
+]);
+const A_SCOPE_BOUNDARY = /* @__PURE__ */ new Set([
+	35,
+	36,
+	25,
+	24,
+	33,
+	101,
+	98,
+	99,
+	28,
+	32,
+	31,
+	30,
+	107,
+	22,
+	51,
+	50,
+	105,
+	47,
+	41,
+	88,
+	104,
+	40,
+	68,
+	102,
+	43,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	78,
+	0
+]);
+const HEADINGS = /* @__PURE__ */ new Set([
+	7,
+	8,
+	9,
+	10,
+	11,
+	12
+]);
+const SINGLE_P = /* @__PURE__ */ new Set([35]);
+const SINGLE_LI = /* @__PURE__ */ new Set([25]);
+const SINGLE_A = /* @__PURE__ */ new Set([26]);
+const DT_DD = /* @__PURE__ */ new Set([99, 98]);
+const TD_TH = /* @__PURE__ */ new Set([32, 31]);
+const TR_CELLS = /* @__PURE__ */ new Set([
+	32,
+	31,
+	30
+]);
+const SECTION_CELLS = /* @__PURE__ */ new Set([
+	32,
+	31,
+	30,
+	29,
+	38,
+	39,
+	107
+]);
+function closeImpliedTo(state, target, boundary, handleEvent) {
+	if (state.flattenedTagName) {
+		const id = state.flattenedTagId;
+		if (id !== void 0 && target.has(id)) {
+			clearFlattenedElements(state);
+			return;
+		}
+		if (id !== void 0 && boundary.has(id)) return;
+	}
+	let found = false;
+	for (let node = state.currentNode; node; node = node.parent) {
+		const id = node.tagId;
+		if (id !== void 0 && target.has(id)) {
+			found = true;
+			break;
+		}
+		if (id !== void 0 && boundary.has(id)) break;
+	}
+	if (!found) return;
+	clearFlattenedElements(state);
+	while (state.currentNode) {
+		const id = state.currentNode.tagId;
+		const isTarget = id !== void 0 && target.has(id);
+		closeNode(state.currentNode, state, handleEvent);
+		if (isTarget) break;
+	}
+}
+function closeTableContext(state, closeable, handleEvent) {
+	if (state.flattenedTagName) {
+		const id = state.flattenedTagId;
+		if (id === void 0 || !closeable.has(id)) return;
+		clearFlattenedElements(state);
+	}
+	let closeCount = 0;
+	let walked = 0;
+	for (let node = state.currentNode; node; node = node.parent) {
+		const id = node.tagId;
+		if (id !== void 0 && closeable.has(id)) {
+			walked++;
+			closeCount = walked;
+		} else if (id === 28 || id === 78 || id === 107) break;
+		else walked++;
+	}
+	for (let i = 0; i < closeCount && state.currentNode; i++) closeNode(state.currentNode, state, handleEvent);
+}
+function closeSelectTo(state, targetId, handleEvent) {
+	if (state.flattenedTagName) {
+		const id = state.flattenedTagId;
+		if (id === targetId) {
+			clearFlattenedElements(state);
+			return true;
+		}
+		if (id === 65 && targetId !== 65 || id === 78) return false;
+	}
+	let target;
+	for (let node = state.currentNode; node; node = node.parent) {
+		if (node.tagId === targetId) {
+			target = node;
+			break;
+		}
+		if (node.tagId === 65 || node.tagId === 78) break;
+	}
+	if (!target) return false;
+	clearFlattenedElements(state);
+	while (state.currentNode && state.currentNode !== target) closeNode(state.currentNode, state, handleEvent);
+	closeNode(target, state, handleEvent);
+	return true;
+}
+function parserTagDepth(state, tagId) {
+	return (state.depthMap[tagId] || 0) + (state.flattenedTagId === tagId ? state.flattenedTagDepth || 0 : 0);
+}
+function parserLastTagId(state) {
+	return state.flattenedTagName ? state.flattenedTagId : state.currentNode?.tagId;
+}
+function popParserTop(state, handleEvent) {
+	if (state.flattenedTagName) clearFlattenedElements(state);
+	else closeNode(state.currentNode, state, handleEvent);
+}
+function findIncompleteTagResidualIndex(leftover) {
+	let index = leftover.indexOf("<");
+	while (index !== -1) {
+		if (index + 1 === leftover.length) return index;
+		const c = leftover.charCodeAt(index + 1);
+		if (isAsciiAlpha(c) || c === SLASH_CHAR || c === EXCLAMATION_CHAR || c === QUESTION_CHAR) return index;
+		index = leftover.indexOf("<", index + 1);
+	}
+	return -1;
+}
+function finalizeParse(leftover, state, handleEvent) {
+	if (state.currentNode && isScriptElement(state.currentNode)) {
+		pushScriptTextChunk(state, leftover);
+		const scriptText = takeScriptText(state);
+		if (scriptText) processTextBuffer(scriptText, state, handleEvent);
+	} else if (leftover.length > 0) {
+		const incompleteTagIndex = findIncompleteTagResidualIndex(leftover);
+		const text = incompleteTagIndex === -1 ? leftover : leftover.slice(0, incompleteTagIndex);
+		if (text) processTextBuffer(text, state, handleEvent);
+	}
+	while (state.currentNode) closeNode(state.currentNode, state, handleEvent);
+}
+const EMPTY_ATTRIBUTES = Object.freeze({});
+var ParsedElementNode = class {
+	type = 1;
+	name;
+	attributes;
+	parent;
+	depth;
+	index;
+	tagId;
+	tagHandler;
+	currentWalkIndex;
+	childTextNodeIndex;
+	containsWhitespace;
+	pluginOutput;
+	context;
+	cachedDepthMap;
+	constructor(name, attributes, parent, depth, index, tagId, tagHandler) {
+		this.name = name;
+		this.attributes = attributes;
+		this.parent = parent;
+		this.depth = depth;
+		this.index = index;
+		this.tagId = tagId;
+		this.tagHandler = tagHandler;
+	}
+	get depthMap() {
+		if (this.cachedDepthMap) return this.cachedDepthMap;
+		const depthMap = /* @__PURE__ */ new Uint16Array(113);
+		if (this.tagId >= 0 && this.tagId < 113) depthMap[this.tagId] = 1;
+		let node = this.parent;
+		while (node) {
+			const tagId = node.tagId;
+			if (tagId !== void 0 && tagId >= 0 && tagId < 113) depthMap[tagId] = (depthMap[tagId] || 0) + 1;
+			node = node.parent;
+		}
+		this.cachedDepthMap = depthMap;
+		return depthMap;
+	}
+};
+function isWhitespace(charCode) {
+	return charCode === SPACE_CHAR || charCode === TAB_CHAR || charCode === NEWLINE_CHAR || charCode === FORM_FEED_CHAR || charCode === CARRIAGE_RETURN_CHAR;
+}
+function scriptSequenceEnd(html, nameStart) {
+	const name = "script";
+	for (let offset = 0; offset < 6; offset++) {
+		const index = nameStart + offset;
+		if (index >= html.length) return SCRIPT_SEQUENCE_INCOMPLETE;
+		if ((html.charCodeAt(index) | 32) !== name.charCodeAt(offset)) return SCRIPT_SEQUENCE_NO_MATCH;
+	}
+	const delimiterIndex = nameStart + 6;
+	if (delimiterIndex >= html.length) return SCRIPT_SEQUENCE_INCOMPLETE;
+	const delimiter = html.charCodeAt(delimiterIndex);
+	return delimiter === GT_CHAR || delimiter === SLASH_CHAR || isWhitespace(delimiter) ? delimiterIndex + 1 : SCRIPT_SEQUENCE_NO_MATCH;
+}
+function isScriptElement(node) {
+	return node.tagId === 52 && node.name === "script";
+}
+function scriptScanResult(parseState, scriptState, result) {
+	parseState.scriptDataState = scriptState;
+	return result;
+}
+function findScriptEndTag(html, start, parseState) {
+	let state = parseState.scriptDataState ?? SCRIPT_DATA;
+	let i = start;
+	while (i < html.length) {
+		const charCode = html.charCodeAt(i);
+		if (charCode === LT_CHAR) {
+			if (i + 1 === html.length) return scriptScanResult(parseState, state, -i - 2);
+			const next = html.charCodeAt(i + 1);
+			if (state === SCRIPT_DATA) {
+				if (next === SLASH_CHAR) {
+					const sequenceEnd = scriptSequenceEnd(html, i + 2);
+					if (sequenceEnd >= 0) return scriptScanResult(parseState, state, i);
+					if (sequenceEnd === SCRIPT_SEQUENCE_INCOMPLETE) return scriptScanResult(parseState, state, -i - 2);
+				} else if (next === EXCLAMATION_CHAR) {
+					const marker = "<!--";
+					const available = Math.min(html.length - i, 4);
+					if (html.startsWith(marker.substring(0, available), i)) {
+						if (available < 4) return scriptScanResult(parseState, state, -i - 2);
+						state = SCRIPT_DATA_ESCAPED_DASH_DASH;
+						i += 4;
+						continue;
+					}
+				}
+			} else {
+				const escaped = state < SCRIPT_DATA_DOUBLE_ESCAPED;
+				state = escaped ? SCRIPT_DATA_ESCAPED : SCRIPT_DATA_DOUBLE_ESCAPED;
+				const isEndTag = next === SLASH_CHAR;
+				if (isEndTag || escaped) {
+					const sequenceEnd = scriptSequenceEnd(html, i + (isEndTag ? 2 : 1));
+					if (sequenceEnd >= 0) {
+						if (isEndTag) {
+							if (escaped) return scriptScanResult(parseState, state, i);
+							state = SCRIPT_DATA_ESCAPED;
+						} else state = SCRIPT_DATA_DOUBLE_ESCAPED;
+						i = sequenceEnd;
+						continue;
+					}
+					if (sequenceEnd === SCRIPT_SEQUENCE_INCOMPLETE) return scriptScanResult(parseState, state, -i - 2);
+				}
+			}
+		} else if (charCode === DASH_CHAR) {
+			if (state === SCRIPT_DATA_ESCAPED || state === SCRIPT_DATA_ESCAPED_DASH) state++;
+			else if (state === SCRIPT_DATA_DOUBLE_ESCAPED || state === SCRIPT_DATA_DOUBLE_ESCAPED_DASH) state++;
+		} else if (state === SCRIPT_DATA_ESCAPED_DASH || state === SCRIPT_DATA_ESCAPED_DASH_DASH) state = charCode === GT_CHAR && state === SCRIPT_DATA_ESCAPED_DASH_DASH ? SCRIPT_DATA : SCRIPT_DATA_ESCAPED;
+		else if (state === SCRIPT_DATA_DOUBLE_ESCAPED_DASH || state === SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH) state = charCode === GT_CHAR && state === SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH ? SCRIPT_DATA : SCRIPT_DATA_DOUBLE_ESCAPED;
+		i++;
+	}
+	return scriptScanResult(parseState, state, SCRIPT_SCAN_COMPLETE);
+}
+function pushScriptTextChunk(state, text) {
+	if (!text) return;
+	(state.scriptTextChunks ??= []).push(text);
+	state.textBufferContainsNonWhitespace = true;
+	state.lastCharWasWhitespace = false;
+	state.justClosedTag = false;
+}
+function scanScriptChunk(html, start, state) {
+	const result = findScriptEndTag(html, start, state);
+	if (result === SCRIPT_SCAN_COMPLETE) pushScriptTextChunk(state, html.substring(start));
+	else if (result <= SCRIPT_SEQUENCE_INCOMPLETE) pushScriptTextChunk(state, html.substring(start, -result - 2));
+	else pushScriptTextChunk(state, html.substring(start, result));
+	return result;
+}
+function takeScriptText(state) {
+	const chunks = state.scriptTextChunks;
+	const text = chunks?.length ? chunks.length === 1 ? chunks[0] : chunks.join("") : "";
+	if (chunks) chunks.length = 0;
+	state.scriptDataState = SCRIPT_DATA;
+	return text;
+}
+function normalizeTagName(tagName) {
+	for (let i = 0; i < tagName.length; i++) {
+		const code = tagName.charCodeAt(i);
+		if (code >= 65 && code <= 90) return tagName.toLowerCase();
+	}
+	return tagName;
+}
+function effectiveTagId(tagName, fallbackTagId, state) {
+	return state.tagOverrideHandlers?.get(tagName)?.aliasTagId ?? fallbackTagId;
+}
+function matchesClosingTag(node, tagName, tagId, closingIsAlias) {
+	if (node.tagId !== tagId) return false;
+	if (tagId === -1) return node.name === tagName;
+	const nodeIsAlias = node.tagHandler?.aliasTagId !== void 0;
+	return node.name === tagName || !nodeIsAlias && !closingIsAlias;
+}
+function parseHtml(html, options = {}) {
+	const events = [];
+	const state = {
+		depthMap: /* @__PURE__ */ new Uint16Array(113),
+		depth: 0,
+		resolvedPlugins: options.resolvedPlugins || []
+	};
+	let remainingHtml = parseHtmlInternal(html, state, (event) => {
+		events.push(event);
+	});
+	if (state.scriptTextChunks?.length) remainingHtml = `${takeScriptText(state)}${remainingHtml}`;
+	return {
+		events,
+		remainingHtml
+	};
+}
+function parseHtmlStream(html, state, onEvent) {
+	return parseHtmlInternal(html, state, onEvent);
+}
+function parseHtmlInternal(htmlChunk, state, handleEvent) {
+	let textBuffer = "";
+	let runStart = 0;
+	state.depthMap ??= /* @__PURE__ */ new Uint16Array(113);
+	state.depth ??= 0;
+	state.lastCharWasWhitespace ??= true;
+	state.justClosedTag ??= false;
+	state.isFirstTextInElement ??= false;
+	state.scriptDataState ??= SCRIPT_DATA;
+	let i = 0;
+	const chunkLength = htmlChunk.length;
+	if (state.currentNode && isScriptElement(state.currentNode)) {
+		const scanResult = scanScriptChunk(htmlChunk, i, state);
+		if (scanResult < 0) return scanResult <= SCRIPT_SEQUENCE_INCOMPLETE ? htmlChunk.substring(-scanResult - 2) : "";
+		textBuffer = takeScriptText(state);
+		i = scanResult;
+	}
+	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) {
+					if (textBuffer.length === 0) runStart = i + 1;
+					i++;
+					continue;
+				}
+				if (inPreTag) textBuffer += htmlChunk[i];
+				else if (currentCharCode === SPACE_CHAR || !state.lastCharWasWhitespace) textBuffer += " ";
+				state.lastCharWasWhitespace = true;
+				state.textBufferContainsWhitespace = true;
+			} else {
+				state.textBufferContainsNonWhitespace = true;
+				state.lastCharWasWhitespace = false;
+				state.justClosedTag = false;
+				textBuffer += htmlChunk[i];
+			}
+			i++;
+			continue;
+		}
+		if (i + 1 >= chunkLength) {
+			textBuffer += htmlChunk[i];
+			break;
+		}
+		const nextCharCode = htmlChunk.charCodeAt(i + 1);
+		if (state.flattenedRawTagName) {
+			if (nextCharCode === SLASH_CHAR) {
+				let peekEnd = i + 2;
+				while (peekEnd < chunkLength) {
+					const c = htmlChunk.charCodeAt(peekEnd);
+					if (c === GT_CHAR || c === SLASH_CHAR || isWhitespace(c)) break;
+					peekEnd++;
+				}
+				if (peekEnd === chunkLength) {
+					textBuffer += htmlChunk.substring(i);
+					break;
+				}
+				if (normalizeTagName(htmlChunk.substring(i + 2, peekEnd)) !== state.flattenedRawTagName) {
+					textBuffer += htmlChunk[i++];
+					continue;
+				}
+			} else {
+				textBuffer += htmlChunk[i++];
+				continue;
+			}
+		}
+		if (nextCharCode === EXCLAMATION_CHAR) {
+			if (htmlChunk.charCodeAt(i + 2) === OPEN_BRACKET_CHAR) {
+				if (htmlChunk.startsWith("<![CDATA[", i)) {
+					const end = htmlChunk.indexOf("]]>", i + 9);
+					if (end === -1) {
+						textBuffer += htmlChunk.substring(i);
+						break;
+					}
+					if (textBuffer.length > 0) {
+						processTextBuffer(textBuffer, state, handleEvent);
+						textBuffer = "";
+						runStart = i;
+					}
+					processCdataSection(htmlChunk.substring(i + 9, end), state, handleEvent);
+					i = end + 3;
+					runStart = i;
+					continue;
+				}
+				if (chunkLength - i < 9 && "<![CDATA[".startsWith(htmlChunk.substring(i))) {
+					textBuffer += htmlChunk.substring(i);
+					break;
+				}
+			}
+			if (textBuffer.length > 0) {
+				processTextBuffer(textBuffer, state, handleEvent);
+				textBuffer = "";
+				runStart = i;
+			}
+			const result = processCommentOrDoctype(htmlChunk, i);
+			if (result.complete) {
+				i = result.newPosition;
+				runStart = i;
+			} else {
+				textBuffer += result.remainingText;
+				break;
+			}
+		} else if (nextCharCode === SLASH_CHAR) {
+			if (state.currentNode?.tagHandler?.isNonNesting) {
+				let peekEnd = i + 2;
+				while (peekEnd < chunkLength) {
+					const c = htmlChunk.charCodeAt(peekEnd);
+					if (c === GT_CHAR || c === SLASH_CHAR || isWhitespace(c)) break;
+					peekEnd++;
+				}
+				const peekTagName = normalizeTagName(htmlChunk.substring(i + 2, peekEnd));
+				const peekHandler = state.tagOverrideHandlers?.get(peekTagName);
+				const peekTagId = effectiveTagId(peekTagName, TagIdMap[peekTagName] ?? -1, state);
+				if (!matchesClosingTag(state.currentNode, peekTagName, peekTagId, peekHandler?.aliasTagId !== void 0)) {
+					textBuffer += htmlChunk[i++];
+					continue;
+				}
+			}
+			if (textBuffer.length > 0) {
+				processTextBuffer(textBuffer, state, handleEvent);
+				textBuffer = "";
+				runStart = i;
+			}
+			const result = processClosingTag(htmlChunk, i, state, handleEvent);
+			if (result.complete) {
+				i = result.newPosition;
+				runStart = i;
+			} else {
+				textBuffer += result.remainingText;
+				break;
+			}
+		} else if (!isAsciiAlpha(nextCharCode) && nextCharCode !== QUESTION_CHAR) {
+			state.textBufferContainsNonWhitespace = true;
+			state.lastCharWasWhitespace = false;
+			state.justClosedTag = false;
+			textBuffer += htmlChunk[i++];
+			continue;
+		} 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 rawTagName = htmlChunk.substring(tagNameStart, tagNameEnd);
+			let tagName = rawTagName;
+			if (typeof TagIdMap[tagName] !== "number") tagName = normalizeTagName(rawTagName);
+			const mappedTagId = TagIdMap[tagName];
+			const tagId = effectiveTagId(tagName, typeof mappedTagId === "number" ? mappedTagId : -1, state);
+			i2 = tagNameEnd;
+			if (state.currentNode?.tagHandler?.isNonNesting) {
+				textBuffer += htmlChunk[i++];
+				continue;
+			}
+			if (!tagName) {
+				state.textBufferContainsNonWhitespace = true;
+				state.lastCharWasWhitespace = false;
+				state.justClosedTag = false;
+				textBuffer += htmlChunk[i++];
+				continue;
+			}
+			if (textBuffer.length > 0) {
+				processTextBuffer(textBuffer, state, handleEvent);
+				textBuffer = "";
+				runStart = i;
+			}
+			const result = processOpeningTag(tagName, tagId, htmlChunk, i2, state, handleEvent);
+			if (result.skip) {
+				i = result.newPosition;
+				runStart = i;
+			} else if (result.complete) {
+				i = result.newPosition;
+				if (!result.selfClosing) {
+					state.isFirstTextInElement = true;
+					if (tagId === 52 && tagName === "script") {
+						const scanResult = scanScriptChunk(htmlChunk, i, state);
+						if (scanResult < 0) {
+							if (scanResult <= SCRIPT_SEQUENCE_INCOMPLETE) {
+								runStart = -scanResult - 2;
+								textBuffer = htmlChunk.substring(runStart);
+							} else textBuffer = "";
+							break;
+						}
+						textBuffer = takeScriptText(state);
+						i = scanResult;
+					}
+				}
+				if (textBuffer.length === 0) runStart = i;
+			} else {
+				textBuffer += result.remainingText;
+				break;
+			}
+		}
+	}
+	const remainingHtml = textBuffer.length > 0 ? htmlChunk.substring(runStart) : "";
+	if (remainingHtml.length > 0 && isWhitespace(remainingHtml.charCodeAt(0))) state.lastCharWasWhitespace = false;
+	return remainingHtml;
+}
+function processTextBuffer(textBuffer, state, handleEvent) {
+	const containsNonWhitespace = state.textBufferContainsNonWhitespace;
+	const containsWhitespace = state.textBufferContainsWhitespace;
+	state.textBufferContainsNonWhitespace = false;
+	state.textBufferContainsWhitespace = false;
+	if (!state.currentNode) {
+		let rootText = textBuffer;
+		if (rootText.length === 0) return;
+		if (state.hasEncodedHtmlEntity) {
+			rootText = decodeHTMLEntities(String(rootText), false, shouldProtectDecodedEntityReferences(state));
+			state.hasEncodedHtmlEntity = false;
+		}
+		const rootTextNode = {
+			type: 2,
+			value: rootText,
+			parent: null,
+			index: 0,
+			depth: state.depth,
+			containsWhitespace,
+			excludedFromMarkdown: false
+		};
+		handleEvent({
+			type: 0,
+			node: rootTextNode
+		});
+		state.lastTextNode = rootTextNode;
+		return;
+	}
+	const excludesTextNodes = (state.flattenedOpaqueDepth || 0) > 0 || state.flattenedRawExcludesText || state.currentNode?.tagHandler?.excludesTextNodes || state.currentNode?.excludedFromMarkdown;
+	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), false, shouldProtectDecodedEntityReferences(state));
+		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;
+}
+function processClosingTag(htmlChunk, position, state, handleEvent) {
+	let i = position + 2;
+	const tagNameStart = i;
+	const chunkLength = htmlChunk.length;
+	let tagNameEnd = -1;
+	let quoteChar = 0;
+	let foundClose = false;
+	while (i < chunkLength) {
+		const charCode = htmlChunk.charCodeAt(i);
+		if (tagNameEnd !== -1) {
+			if (quoteChar) {
+				if (charCode === quoteChar) quoteChar = 0;
+				i++;
+				continue;
+			}
+			if (charCode === QUOTE_CHAR || charCode === APOS_CHAR) {
+				quoteChar = charCode;
+				i++;
+				continue;
+			}
+		}
+		if (charCode === GT_CHAR) {
+			foundClose = true;
+			break;
+		}
+		if (tagNameEnd === -1 && (isWhitespace(charCode) || charCode === SLASH_CHAR)) tagNameEnd = i;
+		i++;
+	}
+	if (!foundClose) return {
+		complete: false,
+		newPosition: position,
+		remainingText: htmlChunk.substring(position)
+	};
+	const rawTagName = htmlChunk.substring(tagNameStart, tagNameEnd === -1 ? i : tagNameEnd);
+	let tagName = rawTagName;
+	if (typeof TagIdMap[tagName] !== "number") tagName = normalizeTagName(rawTagName);
+	const tagHandler = state.tagOverrideHandlers?.get(tagName);
+	const mappedTagId = TagIdMap[tagName];
+	const tagId = effectiveTagId(tagName, typeof mappedTagId === "number" ? mappedTagId : -1, state);
+	const closingIsAlias = tagHandler?.aliasTagId !== void 0;
+	if ((state.flattenedOpaqueDepth || 0) > 0) {
+		if (state.flattenedRawTagName !== void 0) {
+			state.flattenedRawTagName = void 0;
+			state.flattenedRawExcludesText = void 0;
+		}
+		if (tagName === state.flattenedOpaqueTagName) {
+			state.flattenedOpaqueDepth--;
+			if (!state.flattenedOpaqueDepth) {
+				state.flattenedOpaqueTagName = void 0;
+				if (tagName === state.flattenedTagName) {
+					state.flattenedTagDepth--;
+					if (!state.flattenedTagDepth) clearFlattenedElements(state);
+				}
+			}
+		}
+		state.justClosedTag = true;
+		return {
+			complete: true,
+			newPosition: i + 1,
+			remainingText: ""
+		};
+	}
+	const stopAtTemplate = tagId !== 78 && (state.depthMap[78] || 0) > 0;
+	let curr;
+	if (state.flattenedTagName) {
+		const closedRaw = state.flattenedRawTagName !== void 0;
+		if (closedRaw) {
+			state.flattenedRawTagName = void 0;
+			state.flattenedRawExcludesText = void 0;
+		}
+		if (tagName === state.flattenedTagName) {
+			state.flattenedTagDepth--;
+			if (!state.flattenedTagDepth) clearFlattenedElements(state);
+			state.justClosedTag = true;
+			return {
+				complete: true,
+				newPosition: i + 1,
+				remainingText: ""
+			};
+		}
+		if (!closedRaw) {
+			curr = state.currentNode;
+			while (curr && !matchesClosingTag(curr, tagName, tagId, closingIsAlias)) {
+				if (stopAtTemplate && curr.tagId === 78) {
+					curr = null;
+					break;
+				}
+				curr = curr.parent;
+			}
+			if (curr) clearFlattenedElements(state);
+			else {
+				state.justClosedTag = true;
+				return {
+					complete: true,
+					newPosition: i + 1,
+					remainingText: ""
+				};
+			}
+		}
+		if (closedRaw) {
+			state.justClosedTag = true;
+			return {
+				complete: true,
+				newPosition: i + 1,
+				remainingText: ""
+			};
+		}
+	}
+	if (state.currentNode?.tagHandler?.isNonNesting && !matchesClosingTag(state.currentNode, tagName, tagId, closingIsAlias)) return {
+		complete: false,
+		newPosition: position,
+		remainingText: htmlChunk.substring(position)
+	};
+	if (!curr) {
+		curr = state.currentNode;
+		while (curr && !matchesClosingTag(curr, tagName, tagId, closingIsAlias)) {
+			if (stopAtTemplate && curr.tagId === 78) {
+				curr = null;
+				break;
+			}
+			curr = curr.parent;
+		}
+	}
+	if (curr) {
+		while (state.currentNode && state.currentNode !== curr) closeNode(state.currentNode, state, handleEvent);
+		closeNode(curr, state, handleEvent);
+	}
+	state.justClosedTag = true;
+	return {
+		complete: true,
+		newPosition: i + 1,
+		remainingText: ""
+	};
+}
+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;
+		}
+	}
+	const tagId = node.tagId;
+	if (tagId !== void 0 && tagId >= 0 && tagId < 113) state.depthMap[tagId] = Math.max(0, (state.depthMap[tagId] || 0) - 1);
+	state.depth--;
+	handleEvent({
+		type: 1,
+		node
+	});
+	state.currentNode = state.currentNode.parent;
+	state.hasEncodedHtmlEntity = false;
+	state.justClosedTag = true;
+}
+function clearFlattenedElements(state) {
+	state.flattenedTagName = void 0;
+	state.flattenedTagId = void 0;
+	state.flattenedTagDepth = void 0;
+	state.flattenedRawTagName = void 0;
+	state.flattenedRawExcludesText = void 0;
+}
+function startsOpaqueFlattening(state, tagName, tagId, attributes, tagHandler) {
+	if (tagId === 78) return true;
+	const plugins = state.resolvedPlugins;
+	if (!plugins) return false;
+	let node;
+	for (const plugin of plugins) {
+		if (!plugin.excludesOverflowSubtree) continue;
+		node ||= new ParsedElementNode(tagName, attributes, state.currentNode, state.depth + 1, 0, tagId, tagHandler);
+		if (plugin.excludesOverflowSubtree(node)) return true;
+	}
+	return false;
+}
+function enterOpaqueFlattening(state, tagName, tagHandler) {
+	state.flattenedOpaqueTagName = tagName;
+	state.flattenedOpaqueDepth = 1;
+	if (tagHandler?.isNonNesting) {
+		state.flattenedRawTagName = tagName;
+		state.flattenedRawExcludesText = tagHandler.excludesTextNodes;
+	}
+}
+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;
+		if (i < chunkLength && htmlChunk.charCodeAt(i) === GT_CHAR) return {
+			complete: true,
+			newPosition: i + 1,
+			remainingText: ""
+		};
+		if (i + 1 < chunkLength && htmlChunk.charCodeAt(i) === DASH_CHAR && htmlChunk.charCodeAt(i + 1) === GT_CHAR) return {
+			complete: true,
+			newPosition: i + 2,
+			remainingText: ""
+		};
+		while (i + 2 < chunkLength) {
+			const dash = htmlChunk.indexOf("-", i);
+			if (dash < 0 || dash + 2 >= chunkLength) break;
+			i = dash;
+			if (htmlChunk.charCodeAt(i + 1) === DASH_CHAR) {
+				const afterDashes = htmlChunk.charCodeAt(i + 2);
+				if (afterDashes === GT_CHAR) return {
+					complete: true,
+					newPosition: i + 3,
+					remainingText: ""
+				};
+				if (afterDashes === EXCLAMATION_CHAR && i + 3 < chunkLength && htmlChunk.charCodeAt(i + 3) === GT_CHAR) return {
+					complete: true,
+					newPosition: i + 4,
+					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)
+		};
+	}
+}
+function processCdataSection(content, state, handleEvent) {
+	if (!state.tagOverrideHandlers?.has("#cdata-section")) return;
+	const open = processOpeningTag("#cdata-section", -1, ">", 0, state, handleEvent);
+	if (!open.complete || open.selfClosing || open.skip) return;
+	const node = state.currentNode;
+	if (content.length > 0 && !node.tagHandler?.excludesTextNodes) {
+		const textNode = {
+			type: 2,
+			value: content,
+			parent: node,
+			index: node.currentWalkIndex++,
+			depth: state.depth,
+			containsWhitespace: false
+		};
+		for (const parent of traverseUpToFirstBlockNode(node)) parent.childTextNodeIndex = (parent.childTextNodeIndex || 0) + 1;
+		handleEvent({
+			type: 0,
+			node: textNode
+		});
+		state.lastTextNode = textNode;
+	}
+	closeNode(state.currentNode ?? null, state, handleEvent);
+}
+function processOpeningTag(tagName, tagId, htmlChunk, i, state, handleEvent) {
+	tagId = effectiveTagId(tagName, tagId, state);
+	if (state.currentNode?.tagHandler?.isNonNesting) closeNode(state.currentNode, state, handleEvent);
+	const tagHandler = state.tagOverrideHandlers?.get(tagName) ?? (tagId === -1 ? UNKNOWN_TAG_HANDLER : tagHandlers[tagId]);
+	const result = scanTagAttributes(htmlChunk, i, tagHandler);
+	if (result._tag === "incomplete") return {
+		complete: false,
+		newPosition: i,
+		remainingText: `<${tagName}${result.attrBuffer}`,
+		selfClosing: false
+	};
+	if ((state.flattenedOpaqueDepth || 0) > 0) {
+		if (!result.selfClosing && tagName === state.flattenedOpaqueTagName) state.flattenedOpaqueDepth++;
+		if (!result.selfClosing && tagHandler?.isNonNesting) {
+			state.flattenedRawTagName = tagName;
+			state.flattenedRawExcludesText = tagHandler.excludesTextNodes;
+		}
+		return {
+			complete: true,
+			newPosition: result.newPosition,
+			remainingText: "",
+			selfClosing: result.selfClosing,
+			skip: true
+		};
+	}
+	if (!state.flattenedTagName && (state.depthMap[1] || 0) > 0 && (state.depthMap[78] || 0) === 0 && !HEAD_CONTENT_TAGS.has(tagId)) {
+		while (state.currentNode && state.currentNode.tagId !== 1) closeNode(state.currentNode, state, handleEvent);
+		const headNode = state.currentNode;
+		if (headNode && headNode.tagId === 1) closeNode(headNode, state, handleEvent);
+	}
+	if (tagId >= 0 && tagId < 113 && NEEDS_IMPLIED_END_RECOVERY[tagId] === 1) {
+		if (tagId === 65 && parserTagDepth(state, 65) > 0) {
+			if (closeSelectTo(state, 65, handleEvent)) return {
+				complete: true,
+				newPosition: result.newPosition,
+				remainingText: "",
+				selfClosing: false,
+				skip: true
+			};
+		} else if (tagId === 67) {
+			if (parserTagDepth(state, 65) > 0) closeSelectTo(state, 67, handleEvent);
+			else if (parserLastTagId(state) === 67) popParserTop(state, handleEvent);
+		} else if (tagId === 109 && parserTagDepth(state, 65) > 0) {
+			closeSelectTo(state, 67, handleEvent);
+			closeSelectTo(state, 109, handleEvent);
+		} else if (tagId === 26) {
+			if (parserTagDepth(state, 26) > 0) closeImpliedTo(state, SINGLE_A, A_SCOPE_BOUNDARY, handleEvent);
+		} else if (tagId === 32 || tagId === 31 || tagId === 30 || tagId === 29 || tagId === 38 || tagId === 39) {
+			if (parserTagDepth(state, 28) > 0) {
+				if (tagId === 32 || tagId === 31) {
+					if (parserTagDepth(state, 32) > 0 || parserTagDepth(state, 31) > 0) closeImpliedTo(state, TD_TH, CELL_SCOPE_BOUNDARY, handleEvent);
+				} else if (tagId === 30) {
+					if (parserTagDepth(state, 30) > 0) closeTableContext(state, TR_CELLS, handleEvent);
+				} else closeTableContext(state, SECTION_CELLS, handleEvent);
+			}
+		} else {
+			if (parserTagDepth(state, 35) > 0) closeImpliedTo(state, SINGLE_P, P_SCOPE_BOUNDARY, handleEvent);
+			if (HEADINGS.has(tagId)) {
+				const topId = parserLastTagId(state);
+				if (topId !== void 0 && HEADINGS.has(topId)) popParserTop(state, handleEvent);
+			} else if (tagId === 25) {
+				if (parserTagDepth(state, 25) > 0) closeImpliedTo(state, SINGLE_LI, LI_SCOPE_BOUNDARY, handleEvent);
+			} else if (tagId === 99 || tagId === 98) {
+				if (parserTagDepth(state, 99) > 0 || parserTagDepth(state, 98) > 0) closeImpliedTo(state, DT_DD, DL_SCOPE_BOUNDARY, handleEvent);
+			}
+		}
+	}
+	if (state.flattenedTagName && !result.selfClosing) {
+		if (tagName === state.flattenedTagName) state.flattenedTagDepth++;
+		if (startsOpaqueFlattening(state, tagName, tagId, result.attributes, tagHandler)) enterOpaqueFlattening(state, tagName, tagHandler);
+		else if (tagHandler?.isNonNesting) {
+			state.flattenedRawTagName = tagName;
+			state.flattenedRawExcludesText = tagHandler.excludesTextNodes;
+		}
+		return {
+			complete: true,
+			newPosition: result.newPosition,
+			remainingText: "",
+			selfClosing: false,
+			skip: true
+		};
+	}
+	if (!result.selfClosing && state.depth >= MAX_ELEMENT_DEPTH) {
+		state.flattenedTagName = tagName;
+		state.flattenedTagId = tagId;
+		state.flattenedTagDepth = 1;
+		if (startsOpaqueFlattening(state, tagName, tagId, result.attributes, tagHandler)) enterOpaqueFlattening(state, tagName, tagHandler);
+		else if (tagHandler?.isNonNesting) {
+			state.flattenedRawTagName = tagName;
+			state.flattenedRawExcludesText = tagHandler.excludesTextNodes;
+		}
+		return {
+			complete: true,
+			newPosition: result.newPosition,
+			remainingText: "",
+			selfClosing: false,
+			skip: true
+		};
+	}
+	if (tagId >= 0 && tagId < 113) state.depthMap[tagId] = (state.depthMap[tagId] || 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 = new ParsedElementNode(tagName, result.attributes, state.currentNode, state.depth, currentWalkIndex, tagId, tagHandler);
+	if (tagId === 78 || state.currentNode?.excludedFromMarkdown) tag.excludedFromMarkdown = true;
+	state.lastTextNode = tag;
+	handleEvent({
+		type: 0,
+		node: tag
+	});
+	const parentNode = tag;
+	parentNode.currentWalkIndex = 0;
+	state.currentNode = parentNode;
+	state.hasEncodedHtmlEntity = false;
+	if (result.selfClosing) {
+		closeNode(tag, state, handleEvent);
+		state.justClosedTag = true;
+	} else state.justClosedTag = false;
+	return {
+		complete: true,
+		newPosition: i,
+		remainingText: "",
+		selfClosing: result.selfClosing
+	};
+}
+function setAttribute(attributes, rawName, rawValue) {
+	if (!rawName) return attributes;
+	const name = rawName.toLowerCase();
+	if (Object.hasOwn(attributes, name)) return attributes;
+	const result = attributes === EMPTY_ATTRIBUTES ? {} : attributes;
+	result[name] = rawValue.includes("&") ? decodeHTMLEntities(rawValue, true) : rawValue;
+	return result;
+}
+function scanAttributes(source, position, selfClosing, stopAtTagEnd) {
+	const length = source.length;
+	let attributes = EMPTY_ATTRIBUTES;
+	let state = ATTRIBUTE_GAP;
+	let nameStart = 0;
+	let nameEnd = 0;
+	let valueStart = 0;
+	let quoteChar = 0;
+	let newPosition = -1;
+	let valueEnd = length;
+	let i = position;
+	while (i < length) {
+		const charCode = source.charCodeAt(i);
+		if (stopAtTagEnd && state !== ATTRIBUTE_QUOTED_VALUE) {
+			if (state !== ATTRIBUTE_UNQUOTED_VALUE && charCode === SLASH_CHAR && i + 1 < length && source.charCodeAt(i + 1) === GT_CHAR) {
+				selfClosing = true;
+				valueEnd = i;
+				newPosition = i + 2;
+				break;
+			}
+			if (charCode === GT_CHAR) {
+				valueEnd = i;
+				newPosition = i + 1;
+				break;
+			}
+		}
+		const isSpace = isWhitespace(charCode);
+		switch (state) {
+			case ATTRIBUTE_GAP:
+				if (!isSpace) {
+					state = ATTRIBUTE_NAME;
+					nameStart = i;
+				}
+				break;
+			case ATTRIBUTE_NAME:
+				if (charCode === EQUALS_CHAR || isSpace) {
+					nameEnd = i;
+					state = charCode === EQUALS_CHAR ? ATTRIBUTE_BEFORE_VALUE : ATTRIBUTE_AFTER_NAME;
+				}
+				break;
+			case ATTRIBUTE_AFTER_NAME:
+				if (charCode === EQUALS_CHAR) state = ATTRIBUTE_BEFORE_VALUE;
+				else if (!isSpace) {
+					attributes = setAttribute(attributes, source.substring(nameStart, nameEnd), "");
+					state = ATTRIBUTE_NAME;
+					nameStart = i;
+				}
+				break;
+			case ATTRIBUTE_BEFORE_VALUE:
+				if (charCode === QUOTE_CHAR || charCode === APOS_CHAR) {
+					quoteChar = charCode;
+					state = ATTRIBUTE_QUOTED_VALUE;
+					valueStart = i + 1;
+				} else if (!isSpace) {
+					state = ATTRIBUTE_UNQUOTED_VALUE;
+					valueStart = i;
+				}
+				break;
+			case ATTRIBUTE_QUOTED_VALUE:
+				if (charCode === quoteChar) {
+					attributes = setAttribute(attributes, source.substring(nameStart, nameEnd), source.substring(valueStart, i));
+					state = ATTRIBUTE_GAP;
+				}
+				break;
+			case ATTRIBUTE_UNQUOTED_VALUE: if (isSpace || !stopAtTagEnd && charCode === GT_CHAR) {
+				attributes = setAttribute(attributes, source.substring(nameStart, nameEnd), source.substring(valueStart, i));
+				state = ATTRIBUTE_GAP;
+			}
+		}
+		i++;
+	}
+	if (stopAtTagEnd && newPosition === -1) return {
+		_tag: "incomplete",
+		attrBuffer: source.substring(position)
+	};
+	switch (state) {
+		case ATTRIBUTE_NAME:
+			attributes = setAttribute(attributes, source.substring(nameStart, valueEnd), "");
+			break;
+		case ATTRIBUTE_AFTER_NAME:
+		case ATTRIBUTE_BEFORE_VALUE:
+			attributes = setAttribute(attributes, source.substring(nameStart, nameEnd), "");
+			break;
+		case ATTRIBUTE_QUOTED_VALUE:
+		case ATTRIBUTE_UNQUOTED_VALUE: attributes = setAttribute(attributes, source.substring(nameStart, nameEnd), source.substring(valueStart, valueEnd));
+	}
+	return {
+		_tag: "complete",
+		newPosition: stopAtTagEnd ? newPosition : length,
+		attributes,
+		selfClosing
+	};
+}
+function scanTagAttributes(htmlChunk, position, tagHandler) {
+	return scanAttributes(htmlChunk, position, tagHandler?.isSelfClosing || false, true);
+}
+function parseAttributes(attrStr) {
+	if (!attrStr) return EMPTY_ATTRIBUTES;
+	const result = scanAttributes(attrStr, 0, false, false);
+	if (result._tag === "incomplete") throw new Error("Isolated attribute scans always complete at EOF");
+	return result.attributes === EMPTY_ATTRIBUTES ? {} : result.attributes;
+}
+export { blockOpenPrefix, breakHandler, buildTagOverrideHandlers, continuationPrefix, escapeHtml, figcaptionOwnsBlockSpacing, finalizeParse, getLanguageFromClass, isCharacterReferenceTail, isDataUrl, isEmptyLinkHref, isInsideHeading, isInsideTableCell, isSafeHtmlUrl, lastOutputChar, listMarkerLineStart, markRenderedChildContent, orderedItemNumber, parseAttributes, parseHtml, parseHtmlStream, parseUnsignedInteger, renderBreak, resolveUrl, safeAnchorOutput };