nuxt-ai-ready 2.5.2 → 3.0.0

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

@@ -1,2756 +0,0 @@
-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 };