@meridianlabs/log-viewer 0.3.282 → 0.3.284

package/lib/{markdownPipeline-C_z-iU9a.js → markdownPipeline-D23f-WkE.js}

@@ -1,5 +1,4 @@
 import { n as __exportAll$1 } from "./rolldown-runtime-B-lAHAz2.js";
-import "./src-s8Cexy_j.js";
 import { d as parseDataUri, n as escapeHtmlCharacters, o as canonicalImageSource, r as simpleMarkdownTruncate, t as defaultMarkdownRenderer, u as parseAbsoluteHttpUrl } from "./markdownText-z5R6PHwt.js";
 //#region ../../node_modules/.pnpm/mdurl@2.1.0/node_modules/mdurl/lib/decode.mjs
 var decodeCache = {};
@@ -1743,8 +1742,8 @@ var punycode = {
 	"toUnicode": toUnicode
 };
 //#endregion
-//#region ../../node_modules/.pnpm/markdown-it@15.0.2/node_modules/markdown-it/dist/markdown-it.mjs
-/*! markdown-it 15.0.2 https://github.com/markdown-it/markdown-it @license MIT */
+//#region ../../node_modules/.pnpm/markdown-it@15.0.3/node_modules/markdown-it/dist/markdown-it.mjs
+/*! markdown-it 15.0.3 https://github.com/markdown-it/markdown-it @license MIT */
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -3106,12 +3105,14 @@ var StateBlock = class {
 		const s = this.src;
 		for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {
 			const ch = s.charCodeAt(pos);
-			if (!indent_found) if (isSpace(ch)) {
-				indent++;
-				if (ch === 9) offset += 4 - offset % 4;
-				else offset++;
-				continue;
-			} else indent_found = true;
+			if (!indent_found) {
+				if (isSpace(ch)) {
+					indent++;
+					if (ch === 9) offset += 4 - offset % 4;
+					else offset++;
+					continue;
+				} else indent_found = true;
+			}
 			if (ch === 10 || pos === len - 1) {
 				if (ch !== 10) pos++;
 				this.bMarks.push(start);
@@ -3178,9 +3179,10 @@ var StateBlock = class {
 			else last = this.eMarks[line];
 			while (first < last && lineIndent < indent) {
 				const ch = this.src.charCodeAt(first);
-				if (isSpace(ch)) if (ch === 9) lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
-				else lineIndent++;
-				else if (first - lineStart < this.tShift[line]) lineIndent++;
+				if (isSpace(ch)) {
+					if (ch === 9) lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;
+					else lineIndent++;
+				} else if (first - lineStart < this.tShift[line]) lineIndent++;
 				else break;
 				first++;
 			}
@@ -3205,13 +3207,15 @@ function escapedSplit(str) {
 	let lastPos = 0;
 	let current = "";
 	while (pos < max) {
-		if (ch === 124) if (!isEscaped) {
-			result.push(current + str.substring(lastPos, pos));
-			current = "";
-			lastPos = pos + 1;
-		} else {
-			current += str.substring(lastPos, pos - 1);
-			lastPos = pos;
+		if (ch === 124) {
+			if (!isEscaped) {
+				result.push(current + str.substring(lastPos, pos));
+				current = "";
+				lastPos = pos + 1;
+			} else {
+				current += str.substring(lastPos, pos - 1);
+				lastPos = pos;
+			}
 		}
 		isEscaped = ch === 92;
 		pos++;
@@ -3243,8 +3247,10 @@ function table(state, startLine, endLine, silent) {
 	const aligns = [];
 	for (let i = 0; i < columns.length; i++) {
 		const t = columns[i].trim();
-		if (!t) if (i === 0 || i === columns.length - 1) continue;
-		else return false;
+		if (!t) {
+			if (i === 0 || i === columns.length - 1) continue;
+			else return false;
+		}
 		if (!/^:?-+:?$/.test(t)) return false;
 		if (t.charCodeAt(t.length - 1) === 58) aligns.push(t.charCodeAt(0) === 58 ? "center" : "right");
 		else if (t.charCodeAt(0) === 58) aligns.push("left");
@@ -3431,9 +3437,10 @@ function blockquote(state, startLine, endLine, silent) {
 			state.bMarks[nextLine] = pos;
 			while (pos < max) {
 				const ch = state.src.charCodeAt(pos);
-				if (isSpace(ch)) if (ch === 9) offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
-				else offset++;
-				else break;
+				if (isSpace(ch)) {
+					if (ch === 9) offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;
+					else offset++;
+				} else break;
 				pos++;
 			}
 			lastLineEmpty = pos >= max;
@@ -3660,129 +3667,141 @@ function list(state, startLine, endLine, silent) {
 	if (tight) markTightParagraphs(state, listTokIdx);
 	return true;
 }
+var MAX_LABEL_LENGTH = 999;
+function countCodePoints(str) {
+	let length = str.length;
+	for (let i = 0; i < str.length - 1; i++) {
+		const high = str.charCodeAt(i);
+		if (high < 55296 || high > 56319) continue;
+		const low = str.charCodeAt(i + 1);
+		if (low >= 56320 && low <= 57343) {
+			length--;
+			i++;
+		}
+	}
+	return length;
+}
+function lineEnd(state, line) {
+	return Math.min(state.eMarks[line] + 1, state.src.length);
+}
+function getNextLinePos(state, nextLine) {
+	const endLine = state.lineMax;
+	if (nextLine >= endLine || state.isEmpty(nextLine)) return -1;
+	let isContinuation = false;
+	if (state.sCount[nextLine] - state.blkIndent > 3) isContinuation = true;
+	if (state.sCount[nextLine] < 0) isContinuation = true;
+	if (!isContinuation) {
+		const terminatorRules = state.md.block.ruler.getRules("reference");
+		const oldParentType = state.parentType;
+		state.parentType = "reference";
+		let terminate = false;
+		for (let i = 0, l = terminatorRules.length; i < l; i++) if (terminatorRules[i](state, nextLine, endLine, true)) {
+			terminate = true;
+			break;
+		}
+		state.parentType = oldParentType;
+		if (terminate) return -1;
+	}
+	return state.bMarks[nextLine] + state.tShift[nextLine];
+}
 function reference(state, startLine, _endLine, silent) {
+	const src = state.src;
 	let pos = state.bMarks[startLine] + state.tShift[startLine];
-	let max = state.eMarks[startLine];
 	let nextLine = startLine + 1;
 	if (state.sCount[startLine] - state.blkIndent >= 4) return false;
-	if (state.src.charCodeAt(pos) !== 91) return false;
-	function getNextLine(nextLine) {
-		const endLine = state.lineMax;
-		if (nextLine >= endLine || state.isEmpty(nextLine)) return null;
-		let isContinuation = false;
-		if (state.sCount[nextLine] - state.blkIndent > 3) isContinuation = true;
-		if (state.sCount[nextLine] < 0) isContinuation = true;
-		if (!isContinuation) {
-			const terminatorRules = state.md.block.ruler.getRules("reference");
-			const oldParentType = state.parentType;
-			state.parentType = "reference";
-			let terminate = false;
-			for (let i = 0, l = terminatorRules.length; i < l; i++) if (terminatorRules[i](state, nextLine, endLine, true)) {
-				terminate = true;
-				break;
-			}
-			state.parentType = oldParentType;
-			if (terminate) return null;
-		}
-		const pos = state.bMarks[nextLine] + state.tShift[nextLine];
-		const max = state.eMarks[nextLine];
-		return state.src.slice(pos, max + 1);
-	}
-	let str = state.src.slice(pos, max + 1);
-	max = str.length;
+	if (src.charCodeAt(pos) !== 91) return false;
+	let max = lineEnd(state, startLine);
+	let rawLabel = "";
 	let labelEnd = -1;
-	for (pos = 1; pos < max; pos++) {
-		const ch = str.charCodeAt(pos);
+	let segmentStart = ++pos;
+	while (pos < max) {
+		if (rawLabel.length + pos - segmentStart > MAX_LABEL_LENGTH * 2) return false;
+		let ch = src.charCodeAt(pos);
 		if (ch === 91) return false;
-		else if (ch === 93) {
+		if (ch === 93) {
 			labelEnd = pos;
 			break;
-		} else if (ch === 10) {
-			const lineContent = getNextLine(nextLine);
-			if (lineContent !== null) {
-				str += lineContent;
-				max = str.length;
-				nextLine++;
-			}
-		} else if (ch === 92) {
-			pos++;
-			if (pos < max && str.charCodeAt(pos) === 10) {
-				const lineContent = getNextLine(nextLine);
-				if (lineContent !== null) {
-					str += lineContent;
-					max = str.length;
-					nextLine++;
-				}
-			}
 		}
+		if (ch === 92) ch = src.charCodeAt(++pos);
+		if (ch === 10 && pos < max) {
+			const nextPos = getNextLinePos(state, nextLine);
+			if (nextPos < 0) return false;
+			rawLabel += src.slice(segmentStart, max);
+			pos = segmentStart = nextPos;
+			max = lineEnd(state, nextLine++);
+			continue;
+		}
+		pos++;
 	}
-	if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 58) return false;
-	for (pos = labelEnd + 2; pos < max; pos++) {
-		const ch = str.charCodeAt(pos);
+	if (labelEnd < 0 || src.charCodeAt(labelEnd + 1) !== 58) return false;
+	rawLabel += src.slice(segmentStart, labelEnd);
+	if (rawLabel.length > MAX_LABEL_LENGTH && countCodePoints(rawLabel) > MAX_LABEL_LENGTH) return false;
+	pos = labelEnd + 2;
+	while (pos < max) {
+		const ch = src.charCodeAt(pos);
 		if (ch === 10) {
-			const lineContent = getNextLine(nextLine);
-			if (lineContent !== null) {
-				str += lineContent;
-				max = str.length;
-				nextLine++;
-			}
-		} else if (isSpace(ch)) {} else break;
-	}
-	const destRes = state.md.helpers.parseLinkDestination(str, pos, max);
+			const nextPos = getNextLinePos(state, nextLine);
+			if (nextPos < 0) break;
+			pos = nextPos;
+			max = lineEnd(state, nextLine++);
+		} else if (isSpace(ch)) pos++;
+		else break;
+	}
+	const destRes = state.md.helpers.parseLinkDestination(src, pos, max);
 	if (!destRes.ok) return false;
 	const href = state.md.normalizeLink(destRes.str);
 	if (!state.md.validateLink(href)) return false;
 	pos = destRes.pos;
 	const destEndPos = pos;
+	const destEndMax = max;
 	const destEndLineNo = nextLine;
-	const start = pos;
-	for (; pos < max; pos++) {
-		const ch = str.charCodeAt(pos);
+	while (pos < max) {
+		const ch = src.charCodeAt(pos);
 		if (ch === 10) {
-			const lineContent = getNextLine(nextLine);
-			if (lineContent !== null) {
-				str += lineContent;
-				max = str.length;
-				nextLine++;
-			}
-		} else if (isSpace(ch)) {} else break;
-	}
-	let titleRes = state.md.helpers.parseLinkTitle(str, pos, max);
+			const nextPos = getNextLinePos(state, nextLine);
+			if (nextPos < 0) break;
+			pos = nextPos;
+			max = lineEnd(state, nextLine++);
+		} else if (isSpace(ch)) pos++;
+		else break;
+	}
+	const titleStart = pos;
+	let titleRes = state.md.helpers.parseLinkTitle(src, pos, max);
 	while (titleRes.can_continue) {
-		const lineContent = getNextLine(nextLine);
-		if (lineContent === null) break;
-		str += lineContent;
-		pos = max;
-		max = str.length;
-		nextLine++;
-		titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes);
+		const nextPos = getNextLinePos(state, nextLine);
+		if (nextPos < 0) break;
+		pos = nextPos;
+		max = lineEnd(state, nextLine++);
+		titleRes = state.md.helpers.parseLinkTitle(src, pos, max, titleRes);
 	}
 	let title;
-	if (pos < max && start !== pos && titleRes.ok) {
+	if (titleStart !== destEndPos && titleRes.ok) {
 		title = titleRes.str;
 		pos = titleRes.pos;
 	} else {
 		title = "";
 		pos = destEndPos;
+		max = destEndMax;
 		nextLine = destEndLineNo;
 	}
 	while (pos < max) {
-		if (!isSpace(str.charCodeAt(pos))) break;
+		if (!isSpace(src.charCodeAt(pos))) break;
 		pos++;
 	}
-	if (pos < max && str.charCodeAt(pos) !== 10) {
+	if (pos < max && src.charCodeAt(pos) !== 10) {
 		if (title) {
 			title = "";
 			pos = destEndPos;
+			max = destEndMax;
 			nextLine = destEndLineNo;
 			while (pos < max) {
-				if (!isSpace(str.charCodeAt(pos))) break;
+				if (!isSpace(src.charCodeAt(pos))) break;
 				pos++;
 			}
 		}
 	}
-	if (pos < max && str.charCodeAt(pos) !== 10) return false;
-	const label = normalizeReference(str.slice(1, labelEnd));
+	if (pos < max && src.charCodeAt(pos) !== 10) return false;
+	const label = normalizeReference(rawLabel);
 	if (!label) return false;
 	/* istanbul ignore if */
 	if (silent) return true;
@@ -3866,7 +3885,7 @@ var html_blocks_default = [
 ];
 var open_tag = `<[A-Za-z][A-Za-z0-9\\-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^"'=<>\`\\x00-\\x20]+|'[^']*'|"[^"]*"))?)*\\s*\\/?>`;
 var close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
-var HTML_TAG_RE = new RegExp(`^(?:${open_tag}|${close_tag}|<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->|<[?][\\s\\S]*?[?]>|<![A-Za-z][^>]*>|<!\\[CDATA\\[[\\s\\S]*?\\]\\]>)`);
+new RegExp(`^(?:${open_tag}|${close_tag}|<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->|<[?][\\s\\S]*?[?]>|<![A-Za-z][^>]*>|<!\\[CDATA\\[[\\s\\S]*?\\]\\]>)`);
 var HTML_OPEN_CLOSE_TAG_RE = new RegExp(`^(?:${open_tag}|${close_tag})`);
 var HTML_SEQUENCES = [
 	[
@@ -4180,6 +4199,7 @@ var StateInline = class {
 		_defineProperty(this, "cache", {});
 		_defineProperty(this, "backticks", {});
 		_defineProperty(this, "backticksScanned", false);
+		_defineProperty(this, "skipHtmlSpecial", false);
 		_defineProperty(this, "linkLevel", 0);
 		_defineProperty(this, "delimiters", []);
 		_defineProperty(this, "_prev_delimiters", []);
@@ -4340,16 +4360,19 @@ function newline(state, silent) {
 	if (state.src.charCodeAt(pos) !== 10) return false;
 	const pmax = state.pending.length - 1;
 	const max = state.posMax;
-	if (!silent) if (pmax >= 0 && state.pending.charCodeAt(pmax) === 32) if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 32) {
-		let ws = pmax - 1;
-		while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 32) ws--;
-		state.pending = state.pending.slice(0, ws);
-		state.push("hardbreak", "br", 0);
-	} else {
-		state.pending = state.pending.slice(0, -1);
-		state.push("softbreak", "br", 0);
+	if (!silent) {
+		if (pmax >= 0 && state.pending.charCodeAt(pmax) === 32) {
+			if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 32) {
+				let ws = pmax - 1;
+				while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 32) ws--;
+				state.pending = state.pending.slice(0, ws);
+				state.push("hardbreak", "br", 0);
+			} else {
+				state.pending = state.pending.slice(0, -1);
+				state.push("softbreak", "br", 0);
+			}
+		} else state.push("softbreak", "br", 0);
 	}
-	else state.push("softbreak", "br", 0);
 	pos++;
 	while (pos < max && isSpace(state.src.charCodeAt(pos))) pos++;
 	state.pos = pos;
@@ -4822,22 +4845,53 @@ function isLetter(ch) {
 	const lc = ch | 32;
 	return lc >= 97 && lc <= 122;
 }
+function scanSpecial(state, pos) {
+	const src = state.src;
+	let start;
+	let terminator;
+	if (src.startsWith("<!--", pos)) {
+		if (src.startsWith(">", pos + 4)) return pos + 5;
+		if (src.startsWith("->", pos + 4)) return pos + 6;
+		start = pos + 4;
+		terminator = "-->";
+	} else if (src.startsWith("<![CDATA[", pos)) {
+		start = pos + 9;
+		terminator = "]]>";
+	} else if (src.charCodeAt(pos + 1) === 63) {
+		start = pos + 2;
+		terminator = "?>";
+	} else if (isLetter(src.charCodeAt(pos + 2))) {
+		start = pos + 3;
+		terminator = ">";
+	} else return -1;
+	if (state.skipHtmlSpecial) return -1;
+	const end = src.indexOf(terminator, start);
+	if (end < 0) {
+		state.skipHtmlSpecial = true;
+		return -1;
+	}
+	return end + terminator.length;
+}
 function html_inline(state, silent) {
 	if (!state.md.options.html) return false;
 	const max = state.posMax;
 	const pos = state.pos;
 	if (state.src.charCodeAt(pos) !== 60 || pos + 2 >= max) return false;
+	let end;
 	const ch = state.src.charCodeAt(pos + 1);
-	if (ch !== 33 && ch !== 63 && ch !== 47 && !isLetter(ch)) return false;
-	const match = state.src.slice(pos).match(HTML_TAG_RE);
-	if (!match) return false;
+	if (ch === 33 || ch === 63) end = scanSpecial(state, pos);
+	else if (ch === 47 || isLetter(ch)) {
+		const match = state.src.slice(pos).match(HTML_OPEN_CLOSE_TAG_RE);
+		end = match ? pos + match[0].length : -1;
+	} else return false;
+	if (end < 0) return false;
 	if (!silent) {
 		const token = state.push("html_inline", "", 0);
-		token.content = match[0];
+		token.content = state.src.slice(pos, end);
 		if (isLinkOpen(token.content)) state.linkLevel++;
 		if (isLinkClose(token.content)) state.linkLevel--;
 	}
-	state.pos += match[0].length;
+	state.pos = end;
 	return true;
 }
 var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
@@ -5520,6 +5574,8 @@ var getMathjaxPlugin = () => {
 	}
 	return mathjaxPluginPromise;
 };
+var MATHJAX_STYLE = /^(\s*<span id="mjx-[a-f0-9]+">\s*)<style>[\s\S]*?<\/style>/i;
+var withoutMathJaxStyle = (html) => html.replace(MATHJAX_STYLE, "$1");
 var hasMathContent = (text) => text.includes("$") || text.includes("\\(") || text.includes("\\[");
 var mdInstanceCache = {};
 /** Unescape HTML entities within math token content before MathJax processing.
@@ -5570,12 +5626,12 @@ var getMarkdownInstance = async (renderer, contentHasMath) => {
 		if (origInline) md.renderer.rules.math_inline = (tokens, idx, options, env, self) => {
 			const token = tokens[idx];
 			if (token) token.content = unescapeHtmlForMath(token.content);
-			return origInline(tokens, idx, options, env, self);
+			return withoutMathJaxStyle(origInline(tokens, idx, options, env, self));
 		};
 		if (origBlock) md.renderer.rules.math_block = (tokens, idx, options, env, self) => {
 			const token = tokens[idx];
 			if (token) token.content = unescapeHtmlForMath(token.content);
-			return origBlock(tokens, idx, options, env, self);
+			return withoutMathJaxStyle(origBlock(tokens, idx, options, env, self));
 		};
 	}
 	mdInstanceCache[cacheKey] = md;
@@ -5843,8 +5899,8 @@ function hasLinkSyntax(text) {
 	return substr;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/dompurify@3.4.16/node_modules/dompurify/dist/purify.es.mjs
-/*! @license DOMPurify 3.4.16 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.16/LICENSE */
+//#region ../../node_modules/.pnpm/dompurify@3.4.17/node_modules/dompurify/dist/purify.es.mjs
+/*! @license DOMPurify 3.4.17 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.17/LICENSE */
 function _OverloadYield(e, d) {
 	this.v = e, this.k = d;
 }
@@ -5968,9 +6024,12 @@ Array.prototype.indexOf;
 var arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
 var arrayPop = unapply(Array.prototype.pop);
 var arrayPush = unapply(Array.prototype.push);
-Array.prototype.slice;
+var arraySlice = unapply(Array.prototype.slice);
 var arraySplice = unapply(Array.prototype.splice);
 var arrayIsArray = Array.isArray;
+var setCreate = unconstruct(Set);
+var setAdd = unapply(Set.prototype.add);
+var setHas = unapply(Set.prototype.has);
 var stringToLowerCase = unapply(String.prototype.toLowerCase);
 var stringToString = unapply(String.prototype.toString);
 var stringMatch = unapply(String.prototype.match);
@@ -6115,6 +6174,25 @@ function lookupGetter(object, prop) {
 	}
 	return fallbackValue;
 }
+/**
+* Like lookupGetter, but for accessor properties only, and returns null
+* instead of a null-returning fallback when no getter exists on the chain.
+* Lets a caller fall back to a direct property read in environments that
+* lack the getter, where a fallback returning null would be indistinguishable
+* from a legitimate null value (e.g. namespaceURI of a no-namespace element).
+*
+* @param object - The object (usually a prototype) to start the lookup at.
+* @param prop - The accessor property name.
+* @returns The unapplied getter, or null if none was found.
+*/
+function lookupAccessor(object, prop) {
+	while (object !== null) {
+		const desc = getOwnPropertyDescriptor(object, prop);
+		if (desc) return desc.get ? unapply(desc.get) : null;
+		object = getPrototypeOf(object);
+	}
+	return null;
+}
 function isRegex(value) {
 	try {
 		regExpTest(value, "");
@@ -6799,7 +6877,7 @@ var NODE_TYPE = {
 	documentFragment: 11,
 	notation: 12
 };
-var LITERAL_TEXT_ELEMENT_NAMES = [
+var LITERAL_TEXT_ELEMENTS = freeze(addToSet({}, [
 	"style",
 	"script",
 	"xmp",
@@ -6808,15 +6886,7 @@ var LITERAL_TEXT_ELEMENT_NAMES = [
 	"noframes",
 	"plaintext",
 	"noscript"
-];
-var LITERAL_TEXT_ELEMENTS = freeze(addToSet({}, LITERAL_TEXT_ELEMENT_NAMES));
-var LITERAL_TEXT_CLOSE = function() {
-	const map = {};
-	arrayForEach(LITERAL_TEXT_ELEMENT_NAMES, (name) => {
-		map[name] = seal(new RegExp("</" + name + "(?=[\\t\\n\\f\\r />])", "i"));
-	});
-	return freeze(map);
-}();
+]));
 var getGlobal = function getGlobal() {
 	return typeof window === "undefined" ? null : window;
 };
@@ -6894,7 +6964,7 @@ var _resolveObjectOption = function _resolveObjectOption(cfg, key, makeFallback)
 function createDOMPurify() {
 	let window = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
 	const DOMPurify = (root) => createDOMPurify(root);
-	DOMPurify.version = "3.4.16";
+	DOMPurify.version = "3.4.17";
 	DOMPurify.removed = [];
 	if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
 		DOMPurify.isSupported = false;
@@ -6926,6 +6996,10 @@ function createDOMPurify() {
 	const _readNodeName = function _readNodeName(node) {
 		return getNodeName ? getNodeName(node) : node.nodeName;
 	};
+	const getNamespaceURI = lookupAccessor(ElementPrototype, "namespaceURI");
+	const _readNamespaceURI = function _readNamespaceURI(element) {
+		return getNamespaceURI ? getNamespaceURI(element) : element.namespaceURI;
+	};
 	if (typeof HTMLTemplateElement === "function") {
 		const template = document.createElement("template");
 		if (template.content && template.content.ownerDocument) document = template.content.ownerDocument;
@@ -7046,6 +7120,7 @@ function createDOMPurify() {
 	const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
 	let KEEP_CONTENT = true;
 	let IN_PLACE = false;
+	let IN_PLACE_VISITED = null;
 	let USE_PROFILES = {};
 	let FORBID_CONTENTS = null;
 	const DEFAULT_FORBID_CONTENTS = addToSet({}, [
@@ -7319,18 +7394,23 @@ function createDOMPurify() {
 	*  return. Return true otherwise.
 	*/
 	const _checkValidNamespace = function _checkValidNamespace(element) {
-		let parent = getParentNode(element);
-		if (!parent || !parent.tagName) parent = {
-			namespaceURI: NAMESPACE,
-			tagName: "template"
-		};
-		const tagName = stringToLowerCase(element.tagName);
-		const parentTagName = stringToLowerCase(parent.tagName);
-		if (!ALLOWED_NAMESPACES[element.namespaceURI]) return false;
-		if (element.namespaceURI === SVG_NAMESPACE) return _checkSvgNamespace(tagName, parent, parentTagName);
-		if (element.namespaceURI === MATHML_NAMESPACE) return _checkMathMlNamespace(tagName, parent, parentTagName);
-		if (element.namespaceURI === HTML_NAMESPACE) return _checkHtmlNamespace(tagName, parent, parentTagName);
-		if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) return true;
+		const elementNamespace = _readNamespaceURI(element);
+		const tagName = stringToLowerCase(_readNodeName(element));
+		const parentNode = getParentNode(element);
+		let parent;
+		let parentTagName;
+		if (parentNode && _readNodeType(parentNode) === NODE_TYPE.element) {
+			parent = { namespaceURI: _readNamespaceURI(parentNode) };
+			parentTagName = stringToLowerCase(_readNodeName(parentNode));
+		} else {
+			parent = { namespaceURI: NAMESPACE };
+			parentTagName = "template";
+		}
+		if (!ALLOWED_NAMESPACES[elementNamespace]) return false;
+		if (elementNamespace === SVG_NAMESPACE) return _checkSvgNamespace(tagName, parent, parentTagName);
+		if (elementNamespace === MATHML_NAMESPACE) return _checkMathMlNamespace(tagName, parent, parentTagName);
+		if (elementNamespace === HTML_NAMESPACE) return _checkHtmlNamespace(tagName, parent, parentTagName);
+		if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[elementNamespace]) return true;
 		return false;
 	};
 	/**
@@ -7374,36 +7454,21 @@ function createDOMPurify() {
 		}
 	};
 	/**
-	* _neutralizeRoot
-	*
-	* Fail-closed teardown of an in-place root after the sanitize walk aborts
-	* (campaign-3 F2). An internal throw mid-walk — e.g. a page-registered
-	* custom element's reaction detaches a node so `_forceRemove`'s deliberate
-	* parentless guard throws, or any other re-entrant engine mutation — would
-	* otherwise leave the caller's *live* tree half-sanitized, with everything
-	* after the abort point still carrying its handlers. There is no safe way
-	* to resume the walk (the tree mutated under us), so we strip the root bare:
-	* remove every child and every attribute, then let the caller's catch see
-	* the original error. Clobber-safe (cached `remove`/`childNodes`/`attributes`
-	* getters; the root was already clobber-pre-flighted at the IN_PLACE entry).
+	* Fail-closed teardown of an in-place root: strip every disallowed attribute
+	* in the subtree first, so nothing armed is left behind, then remove all
+	* children and the root's own attributes.
 	*
 	* @param root the in-place root to empty
 	*/
 	const _neutralizeRoot = function _neutralizeRoot(root) {
 		_neutralizeSubtree(root);
 		const childNodes = getChildNodes(root);
-		if (childNodes) {
-			const snapshot = [];
-			arrayForEach(childNodes, (child) => {
-				arrayPush(snapshot, child);
-			});
-			arrayForEach(snapshot, (child) => {
-				try {
-					remove(child);
-				} catch (_) {}
-			});
-		}
-		const attributes = getAttributes(root);
+		if (childNodes) arrayForEach(arraySlice(childNodes), (child) => {
+			try {
+				remove(child);
+			} catch (_) {}
+		});
+		const attributes = _readNodeType(root) === NODE_TYPE.element ? getAttributes(root) : null;
 		if (attributes) for (let i = attributes.length - 1; i >= 0; --i) {
 			const attribute = attributes[i];
 			const name = attribute && attribute.name;
@@ -7411,18 +7476,9 @@ function createDOMPurify() {
 		}
 	};
 	/**
-	* _removeAttribute
-	*
-	* Name-based getAttributeNode()/removeAttribute() ASCII-lowercase their
-	* lookup key for HTML elements in an HTML document, so they silently miss an
-	* attribute whose stored qualified name still contains uppercase ASCII
-	* letters. That happens when the node came from a case-preserving source
-	* (an XML/XHTML document imported via importNode(), or createAttributeNS()),
-	* where e.g. `ONERROR` survives the walk: the policy check lowercases to
-	* `onerror` and rejects it, but `removeAttribute('ONERROR')` looks up
-	* `onerror` and finds nothing. Remove the exact Attr node instead, which is
-	* case- and namespace-exact, and fall back to name-based removal only when
-	* the caller could not supply the node.
+	* Removes an attribute, preferably as its exact Attr node: name-based
+	* removal lowercases the name in HTML documents and misses case-preserved
+	* names, e.g. from imported XHTML.
 	*
 	* @param name an Attribute name
 	* @param element a DOM node
@@ -7456,12 +7512,8 @@ function createDOMPurify() {
 		}
 	};
 	/**
-	* _stripDisallowedAttributes
-	*
-	* Removes every attribute the active configuration does not allow from a
-	* single element, using the same allowlist as the main attribute pass (so
-	* `on*` handlers go, but no `/^on/` blocklist is introduced). Used only to
-	* neutralise nodes that are being discarded from an in-place tree.
+	* Removes every attribute the configuration does not allow. Used to
+	* neutralize nodes discarded from an in-place tree.
 	*
 	* @param element the element to strip
 	*/
@@ -7476,77 +7528,158 @@ function createDOMPurify() {
 		}
 	};
 	/**
-	* _neutralizeSubtree
-	*
-	* Completes the audit-5 F1 fix across every removal path. The KEEP_CONTENT
-	* move-hoist neutralises only disallowed-tag removals; clobber, mXSS-canary,
-	* namespace, comment, processing-instruction and KEEP_CONTENT:false removals
-	* all drop their subtree wholesale via `_forceRemove`. On the IN_PLACE path
-	* those dropped nodes are detached from the caller's LIVE tree but a
-	* handler-bearing original among them (an `<img onerror>`/`<video>` that was
-	* loading) keeps its queued resource event, which fires in page scope after
-	* sanitize returns. This walks a removed subtree and strips every attribute
-	* the active configuration does not allow — so `on*` handlers are cancelled
-	* through the SAME allowlist that governs kept nodes, not a separate `/^on/`
-	* blocklist. Run synchronously before sanitize returns, i.e. before any
-	* queued event can fire. Hook-free by design: these nodes leave the output,
-	* so firing attribute hooks for them would be surprising. Clobber-safe reads;
-	* a doomed clobbered node may shadow `removeAttribute` (its own attributes are
-	* irrelevant — it is discarded — while its non-clobbered descendants, e.g.
-	* the `<img>`, are reached and scrubbed).
+	* Iterative depth-first walk, so deep trees cannot overflow the call stack,
+	* reading through the cached getters, so clobbering cannot hide children.
+	* When `visit` returns false, the node's children are skipped. With
+	* `intoShadow`, open shadow roots are walked after their host's children.
 	*
-	* @param root the root of a removed subtree to neutralise
+	* @param root where to start
+	* @param visit called for every node
+	* @param intoShadow whether to enter open shadow roots
 	*/
-	const _neutralizeSubtree = function _neutralizeSubtree(root) {
+	const _walkTree = function _walkTree(root, visit) {
+		let intoShadow = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
 		const stack = [root];
 		while (stack.length > 0) {
 			const node = stack.pop();
-			if (_readNodeType(node) === NODE_TYPE.element) _stripDisallowedAttributes(node);
+			if (visit(node) === false) continue;
+			if (intoShadow && _readNodeType(node) === NODE_TYPE.element) {
+				const shadowRoot = getShadowRoot(node);
+				if (_isDocumentFragment(shadowRoot)) stack.push(shadowRoot);
+			}
 			const childNodes = getChildNodes(node);
 			if (childNodes) for (let i = childNodes.length - 1; i >= 0; --i) stack.push(childNodes[i]);
 		}
 	};
 	/**
-	* _neutralizePatchLinkage
+	* Strips disallowed attributes from every element of a discarded subtree,
+	* so a handler that is already queued (a loading image) cannot fire.
+	*
+	* @param root the root of a removed subtree
+	*/
+	const _neutralizeSubtree = function _neutralizeSubtree(root) {
+		_walkTree(root, (node) => {
+			if (_readNodeType(node) === NODE_TYPE.element) _stripDisallowedAttributes(node);
+		});
+	};
+	/**
+	* All nodes under `root`, root first, including open shadow roots. Template
+	* content is not entered, it is inert.
 	*
-	* IN_PLACE entry pre-pass (declarative-partial-updates / streaming
-	* hardening, https://github.com/WICG/declarative-partial-updates).
+	* @param root the in-place root
+	* @return the nodes
+	*/
+	const _collectLiveNodes = function _collectLiveNodes(root) {
+		const nodes = [];
+		_walkTree(root, (node) => {
+			nodes.push(node);
+		}, true);
+		return nodes;
+	};
+	/**
+	* Strips disallowed attributes from every element that was under the
+	* in-place root when the call started and no longer is, whatever removed
+	* or moved it.
 	*
-	* The main walk strips patch linkage (`for`/`patchsrc`) and removes range
-	* markers (PIs / markup comments) node-by-node, in document order, AS it
-	* reaches each node. On a live in-place root that leaves a window: from the
-	* moment the root is connected until the walk arrives at a given node, that
-	* node's linkage is live. A patch applied on connection/stream can fire as
-	* a microtask during the walk and inject or teleport an unsanitized DOM
-	* range into a region the iterator has already passed and will not revisit,
-	* so the post-return "tree is sanitized" contract is violated. Sweep the
-	* whole tree once up front and sever every linkage before the walk begins,
-	* closing that window.
+	* @param root the in-place root
+	* @param before the root's nodes, collected before the walk
+	*/
+	const _neutralizeEscapedElements = function _neutralizeEscapedElements(root, before) {
+		const reachable = setCreate();
+		arrayForEach(_collectLiveNodes(root), (node) => {
+			if (_readNodeType(node) === NODE_TYPE.element) setAdd(reachable, node);
+		});
+		arrayForEach(before, (node) => {
+			if (_readNodeType(node) === NODE_TYPE.element && !setHas(reachable, node)) _stripDisallowedAttributes(node);
+		});
+	};
+	/**
+	* Neutralizes everything that left the in-place tree during the call: what
+	* DOMPurify removed, and what hooks or custom elements removed or moved out.
 	*
-	* This CANNOT undo a patch that already fired before sanitize ran — that is
-	* the irreducible "do not IN_PLACE a live-connected attacker tree" caveat —
-	* but it closes everything from sanitize-start onward. Gated on SAFE_FOR_XML
-	* to group with the rest of the declarative-partial-updates handling and
-	* stay overridable, consistent with the codebase.
+	* @param root the in-place root
+	* @param before the root's nodes, collected before the walk
+	* @return true if the root itself was removed
+	*/
+	const _neutralizeDiscarded = function _neutralizeDiscarded(root, before) {
+		let rootRemoved = false;
+		arrayForEach(DOMPurify.removed, (entry) => {
+			if (entry.element) {
+				rootRemoved = rootRemoved || entry.element === root;
+				_neutralizeSubtree(entry.element);
+			}
+		});
+		_neutralizeEscapedElements(root, before);
+		return rootRemoved;
+	};
+	const MAX_UNVISITED_ROUNDS = 8;
+	/**
+	* The walk only moves forward, so a node moved to a position it already
+	* passed is never visited. Give every original node that is still in the
+	* tree but unvisited the normal treatment, hooks included. Nodes created
+	* during the call are left alone. Fails closed if the tree keeps changing.
 	*
-	* Clobber-safe traversal (cached childNodes getter); per-node try/catch so a
-	* clobbered root cannot defeat the sweep of its non-clobbered descendants.
+	* @param root the in-place root
+	* @param before the root's nodes, collected before the walk
+	*/
+	const _sanitizeUnvisitedNodes = function _sanitizeUnvisitedNodes(root, before) {
+		const visited = IN_PLACE_VISITED;
+		let original = null;
+		const getOriginal = () => {
+			if (!original) {
+				original = setCreate();
+				arrayForEach(before, (beforeNode) => {
+					setAdd(original, beforeNode);
+				});
+			}
+			return original;
+		};
+		for (let round = 0;; round++) {
+			const live = _collectLiveNodes(root);
+			const containers = [root];
+			let pending = false;
+			arrayForEach(live, (node) => {
+				if (_readNodeType(node) === NODE_TYPE.documentFragment) arrayPush(containers, node);
+				else if (!pending && !setHas(visited, node)) pending = setHas(getOriginal(), node);
+			});
+			if (!pending) return;
+			if (round >= MAX_UNVISITED_ROUNDS) throw typeErrorCreate("the tree kept changing during in-place sanitization; refusing to return it");
+			arrayForEach(containers, (container, index) => {
+				_sanitizeUnvisitedIn(container, index > 0, root, getOriginal());
+			});
+		}
+	};
+	/**
+	* One _sanitizeUnvisitedNodes pass over the root or an open shadow root.
 	*
-	* NOTE (pending real-Chrome confirmation, see test/declarative-patch-probe
-	* .html Q1): this mirrors the existing policy of keeping `for` on
-	* <label>/<output>. If the shipping feature can drive a patch through a
-	* surviving `for`-on-label/output + `id` pair, this pre-pass and the
-	* attribute check at _isBasicCustomElement's caller must additionally drop
-	* that pair on the IN_PLACE path. Left as-is until the taxonomy is verified.
+	* @param container the root or an open shadow root
+	* @param inShadow whether container is a shadow root
+	* @param root the in-place root
+	* @param original the root's nodes collected before the walk, as a set
+	*/
+	const _sanitizeUnvisitedIn = function _sanitizeUnvisitedIn(container, inShadow, root, original) {
+		const iterator = _createNodeIterator(container);
+		let node;
+		while (node = iterator.nextNode()) {
+			if (!setHas(original, node) || setHas(IN_PLACE_VISITED, node)) continue;
+			if (inShadow) _executeHooks(hooks.uponSanitizeShadowNode, node, null);
+			_sanitizeElements(node, root);
+			_sanitizeAttributes(node, root);
+			if (_isDocumentFragment(node.content)) _sanitizeShadowDOM2(node.content);
+		}
+	};
+	/**
+	* Records that _sanitizeElements processed `node`. No-op outside IN_PLACE.
 	*
-	* @param root the in-place root to sweep
+	* @param node the node being processed
 	*/
+	const _markVisited = function _markVisited(node) {
+		if (IN_PLACE_VISITED) setAdd(IN_PLACE_VISITED, node);
+	};
 	/**
-	* Central policy for declarative-partial-updates patch-linkage attributes,
-	* shared by the _neutralizePatchLinkage pre-pass and _isValidAttribute so
-	* the two sites cannot drift: `patchsrc` always links, `for` links
-	* everywhere except on <label>/<output>, and the whole policy is gated on
-	* SAFE_FOR_XML (see the rationale block in _isValidAttribute).
+	* Patch-linkage attributes (declarative partial updates): `patchsrc`
+	* always, `for` everywhere except on <label> and <output>. Gated on
+	* SAFE_FOR_XML. Shared by the IN_PLACE pre-pass and _isValidAttribute.
 	*
 	* @param lcName the transformCaseFunc'd attribute name
 	* @param lcTag the transformCaseFunc'd tag name of the carrying element
@@ -7557,17 +7690,26 @@ function createDOMPurify() {
 		if (lcName === "patchsrc") return true;
 		return lcName === "for" && lcTag !== "label" && lcTag !== "output";
 	};
+	/**
+	* IN_PLACE pre-pass: sever all patch linkage before the walk, so no patch
+	* can fire mid-walk into a part of the tree the walker already passed.
+	* Removes range markers (processing instructions, comments with markup)
+	* and strips linkage attributes. It cannot undo a patch that already fired.
+	*
+	* TODO: if the shipped feature can patch through `for` on <label>/<output>,
+	* drop that pair here too (see test/declarative-patch-probe.html).
+	*
+	* @param root the in-place root to sweep
+	*/
 	const _neutralizePatchLinkage = function _neutralizePatchLinkage(root) {
 		if (!SAFE_FOR_XML) return;
-		const stack = [root];
-		while (stack.length > 0) {
-			const node = stack.pop();
+		_walkTree(root, (node) => {
 			const nodeType = _readNodeType(node);
 			if (nodeType === NODE_TYPE.processingInstruction || nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, node.data)) {
 				try {
 					remove(node);
 				} catch (_) {}
-				continue;
+				return false;
 			}
 			if (nodeType === NODE_TYPE.element) {
 				const element = node;
@@ -7577,9 +7719,8 @@ function createDOMPurify() {
 					if (element.hasAttribute && element.hasAttribute("for") && _isPatchLinkageAttribute("for", lcTag)) element.removeAttribute("for");
 				} catch (_) {}
 			}
-			const childNodes = getChildNodes(node);
-			if (childNodes) for (let i = childNodes.length - 1; i >= 0; --i) stack.push(childNodes[i]);
-		}
+			return true;
+		});
 	};
 	/**
 	* _initDocument
@@ -7656,6 +7797,27 @@ function createDOMPurify() {
 	*/
 	const _scrubTemplateExpressions2 = function _scrubTemplateExpressions(node) {
 		var _node$querySelectorAl;
+		_scrubOwnCharacterData(node);
+		const templates = (_node$querySelectorAl = node.querySelectorAll) === null || _node$querySelectorAl === void 0 ? void 0 : _node$querySelectorAl.call(node, "template");
+		if (templates) arrayForEach(templates, (tmpl) => {
+			if (_isDocumentFragment(tmpl.content)) _scrubTemplateExpressions2(tmpl.content);
+		});
+	};
+	/**
+	* _scrubOwnCharacterData
+	*
+	* Non-recursive core of _scrubTemplateExpressions: normalize `node` and
+	* strip template expressions from its own character data only. Does not
+	* enter <template>.content or attached shadow roots (NodeIterator never
+	* does). Used by _sanitizeShadowDOM, where every nested template content
+	* and shadow root is already walked - and therefore scrubbed - by its own
+	* recursive _sanitizeShadowDOM call; recursing here as well would rescrub
+	* each nested fragment once per ancestor, which is quadratic in nesting
+	* depth.
+	*
+	* @param node The root whose own character data should be scrubbed.
+	*/
+	const _scrubOwnCharacterData = function _scrubOwnCharacterData(node) {
 		node.normalize();
 		const doc = getOwnerDocument ? getOwnerDocument(node) : node.ownerDocument;
 		const walker = createNodeIterator.call(doc || node, node, NodeFilter.SHOW_TEXT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_CDATA_SECTION | NodeFilter.SHOW_PROCESSING_INSTRUCTION, null);
@@ -7664,10 +7826,6 @@ function createDOMPurify() {
 			currentNode.data = _stripTemplateExpressions(currentNode.data);
 			currentNode = walker.nextNode();
 		}
-		const templates = (_node$querySelectorAl = node.querySelectorAll) === null || _node$querySelectorAl === void 0 ? void 0 : _node$querySelectorAl.call(node, "template");
-		if (templates) arrayForEach(templates, (tmpl) => {
-			if (_isDocumentFragment(tmpl.content)) _scrubTemplateExpressions2(tmpl.content);
-		});
 	};
 	/**
 	* _isClobbered
@@ -7743,7 +7901,7 @@ function createDOMPurify() {
 	*/
 	const _isUnsafeNode = function _isUnsafeNode(currentNode, tagName) {
 		if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.textContent) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.innerHTML)) return true;
-		if (SAFE_FOR_XML && currentNode.namespaceURI === HTML_NAMESPACE && LITERAL_TEXT_ELEMENTS[tagName] && (_isNode(currentNode.firstElementChild) || typeof currentNode.textContent === "string" && regExpTest(LITERAL_TEXT_CLOSE[tagName], currentNode.textContent))) return true;
+		if (SAFE_FOR_XML && LITERAL_TEXT_ELEMENTS[tagName] && _readNodeType(currentNode) === NODE_TYPE.element && _readNamespaceURI(currentNode) === HTML_NAMESPACE && (_isNode(currentNode.firstElementChild) || typeof currentNode.textContent === "string" && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.textContent))) return true;
 		if (currentNode.nodeType === NODE_TYPE.processingInstruction) return true;
 		if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, currentNode.data)) return true;
 		return false;
@@ -7787,7 +7945,7 @@ function createDOMPurify() {
 	*/
 	const _sanitizeDisallowedNode = function _sanitizeDisallowedNode(currentNode, tagName, root) {
 		if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName) && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) return false;
-		if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+		if (KEEP_CONTENT && !FORBID_CONTENTS[tagName] && !FORBID_CONTENTS[stringToLowerCase(tagName)]) {
 			const parentNode = getParentNode(currentNode);
 			const childNodes = getChildNodes(currentNode);
 			if (childNodes && parentNode) {
@@ -7820,35 +7978,13 @@ function createDOMPurify() {
 		return set === defaultSet || set === setConfigSet ? clone(set) : set;
 	};
 	/**
-	* Shared guard for a node that a hook has detached from the walk tree,
-	* used after each element-hook site in _sanitizeElements. Detaching is a
-	* long-standing user pattern (issue #469; draw.io-style foreignObject
-	* filtering). Per the cached, unclobberable parentNode getter the node is
-	* genuinely out of the tree, so it can reach neither the serialized
-	* output nor an IN_PLACE live tree; treat it as removed and stop
-	* processing it. Without this guard, the unsafe-node / namespace checks
-	* would call _forceRemove on a parentless node and hit the REPORT-3
-	* fail-closed throw — which exists for nodes DOMPurify wants gone but
-	* *cannot* detach (clobbered / parentless roots), the opposite of a node
-	* that is already safely gone. The walk root is exempt: a detached
-	* IN_PLACE root is legitimate input and must still be fully sanitized,
-	* and a kill-decision on it must keep hitting the REPORT-3 throw.
-	*
-	* Nodes detached by hooks stay the hook's responsibility for placement:
-	* they are not recorded in DOMPurify.removed, so the post-walk IN_PLACE
-	* pass (which iterates DOMPurify.removed) does not reach them. But a
-	* hook-detached subtree can still hold a queued resource-event handler -
-	* e.g. an <img onload> that began loading when the caller built the live
-	* tree - which fires in page scope after sanitize returns even though the
-	* handler never reached the returned tree. That is the audit-5 F1 hazard,
-	* and the documented node.remove() hook pattern walks straight into it.
-	* So on the IN_PLACE path we neutralize the detached subtree inline,
-	* stripping its non-allow-listed attributes before returning, exactly as
-	* the post-walk pass does for _forceRemove'd subtrees.
+	* A hook may have detached the node it was called for. If so, treat it as
+	* removed and stop processing it; the walk root is exempt. On the IN_PLACE
+	* path the detached subtree is neutralized right away.
 	*
 	* @param currentNode the node a hook may have detached
 	* @param root the current walk root
-	* @return true if the node is detached and now handled, false otherwise
+	* @return true if the node was detached
 	*/
 	const _handleHookDetachedNode = function _handleHookDetachedNode(currentNode, root) {
 		if (currentNode === root || getParentNode(currentNode) !== null) return false;
@@ -7865,6 +8001,7 @@ function createDOMPurify() {
 	* @return true if node was killed, false if left alive
 	*/
 	const _sanitizeElements = function _sanitizeElements(currentNode, root) {
+		_markVisited(currentNode);
 		_executeHooks(hooks.beforeSanitizeElements, currentNode, null);
 		if (_handleHookDetachedNode(currentNode, root)) return true;
 		if (_isClobbered(currentNode)) {
@@ -8008,6 +8145,22 @@ function createDOMPurify() {
 		}
 	};
 	/**
+	* _isUnsafeAttributeValue
+	*
+	* Value-based attribute checks that the attribute walk applies before any
+	* hook can force-keep an attribute, shared with the public
+	* isValidAttribute() so that it never approves a value sanitize() would
+	* strip.
+	*
+	* @param name the attribute name as found on the node (case preserved)
+	* @param value the attribute value
+	* @returns true if the attribute must be removed because of its value
+	*/
+	const _isUnsafeAttributeValue = function _isUnsafeAttributeValue(name, value) {
+		if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) return true;
+		return stringToLowerCase(name) === "attributename" && stringMatch(value, "href") !== null;
+	};
+	/**
 	* _sanitizeAttributes
 	*
 	* @protect attributes
@@ -8051,11 +8204,7 @@ function createDOMPurify() {
 				value = SANITIZE_NAMED_PROPS_PREFIX + value;
 				recreatedNamedProp = true;
 			}
-			if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) {
-				_removeAttribute(name, currentNode, attr);
-				continue;
-			}
-			if (lcName === "attributename" && stringMatch(value, "href")) {
+			if (_isUnsafeAttributeValue(name, value)) {
 				_removeAttribute(name, currentNode, attr);
 				continue;
 			}
@@ -8103,24 +8252,13 @@ function createDOMPurify() {
 				}
 			}
 		}
+		if (SAFE_FOR_TEMPLATES) _scrubOwnCharacterData(fragment);
 		_executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
 	};
 	/**
-	* _sanitizeAttachedShadowRoots
-	*
-	* Walks `root` and feeds every attached shadow root we encounter into
-	* the existing _sanitizeShadowDOM pipeline. The default node iterator
-	* does not descend into shadow trees, so nodes inside an attached
-	* shadow root would otherwise be skipped entirely.
-	*
-	* Two real input paths put attached shadow roots in front of us:
-	*   1. IN_PLACE on a DOM node that already has shadow roots attached.
-	*   2. DOM-node input where importNode(dirty, true) deep-clones the
-	*      shadow root because it was created with `clonable: true`.
-	*
-	* This pass runs once, up front, so the main iteration loop (and the
-	* existing _sanitizeShadowDOM template-content recursion) stay
-	* untouched — string-input paths are not affected.
+	* Sanitizes every attached shadow root under `root`, since the node
+	* iterator does not enter shadow trees. Needed for IN_PLACE input and for
+	* DOM input whose clonable shadow roots were copied by importNode().
 	*
 	* @param root the subtree root to walk for attached shadow roots
 	*/
@@ -8185,6 +8323,8 @@ function createDOMPurify() {
 		if (hooks.uponSanitizeAttribute.length > 0) ALLOWED_ATTR = clone(ALLOWED_ATTR);
 		DOMPurify.removed = [];
 		const inPlace = IN_PLACE && typeof dirty !== "string" && _isNode(dirty);
+		let inPlaceNodes = [];
+		const outerVisited = IN_PLACE_VISITED;
 		if (inPlace) {
 			_neutralizePatchLinkage(dirty);
 			const nn = _readNodeName(dirty);
@@ -8199,12 +8339,8 @@ function createDOMPurify() {
 				_neutralizeRoot(dirty);
 				throw typeErrorCreate("root node is clobbered and cannot be sanitized in-place");
 			}
-			try {
-				_sanitizeAttachedShadowRoots(dirty);
-			} catch (error) {
-				_neutralizeRoot(dirty);
-				throw error;
-			}
+			inPlaceNodes = _collectLiveNodes(dirty);
+			IN_PLACE_VISITED = setCreate();
 		} else if (_isNode(dirty)) {
 			body = _initDocument("<!---->");
 			importedNode = body.ownerDocument.importNode(dirty, true);
@@ -8220,30 +8356,25 @@ function createDOMPurify() {
 		if (body && FORCE_BODY) _forceRemove(body.firstChild);
 		const walkRoot = inPlace ? dirty : body;
 		try {
+			if (inPlace) _sanitizeAttachedShadowRoots(dirty);
 			const nodeIterator = _createNodeIterator(walkRoot);
 			while (currentNode = nodeIterator.nextNode()) {
 				_sanitizeElements(currentNode, walkRoot);
 				_sanitizeAttributes(currentNode, walkRoot);
 				if (_isDocumentFragment(currentNode.content)) _sanitizeShadowDOM2(currentNode.content);
 			}
+			if (inPlace) _sanitizeUnvisitedNodes(dirty, inPlaceNodes);
 		} catch (error) {
 			if (inPlace) {
 				_neutralizeRoot(dirty);
-				arrayForEach(DOMPurify.removed, (entry) => {
-					if (entry.element) _neutralizeSubtree(entry.element);
-				});
+				_neutralizeDiscarded(dirty, inPlaceNodes);
 			}
 			throw error;
+		} finally {
+			IN_PLACE_VISITED = outerVisited;
 		}
 		if (inPlace) {
-			let rootWasRemoved = false;
-			arrayForEach(DOMPurify.removed, (entry) => {
-				if (entry.element) {
-					if (entry.element === dirty) rootWasRemoved = true;
-					_neutralizeSubtree(entry.element);
-				}
-			});
-			if (rootWasRemoved) throw typeErrorCreate("a node selected for removal could not be safely returned; refusing to sanitize in place");
+			if (_neutralizeDiscarded(dirty, inPlaceNodes)) throw typeErrorCreate("a node selected for removal could not be safely returned; refusing to sanitize in place");
 			if (SAFE_FOR_TEMPLATES) _scrubTemplateExpressions2(dirty);
 			return dirty;
 		}
@@ -8280,6 +8411,7 @@ function createDOMPurify() {
 		if (!CONFIG) _parseConfig({});
 		const lcTag = transformCaseFunc(tag);
 		const lcName = transformCaseFunc(attr);
+		if (typeof value === "string" && (_isUnsafeAttributeValue(attr, value) || !ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(SELF_CLOSING_TAG, value))) return false;
 		return _isValidAttribute(lcTag, lcName, value);
 	};
 	DOMPurify.addHook = function(entryPoint, hookFunction) {
@@ -8306,93 +8438,6 @@ function createDOMPurify() {
 }
 var purify_default = createDOMPurify();
 //#endregion
-//#region ../../packages/react/src/components/mathjaxStyles.ts
-var MATHJAX_STYLES = `
-:scope {
-  display: contents;
-}
-:scope mjx-container[jax="SVG"] {
-  direction: ltr;
-  position: relative;
-}
-:scope mjx-container[jax="SVG"] > svg {
-  /* WebKit ignores overflow-clip-margin and clips at the SVG box. */
-  overflow: clip;
-  overflow-clip-margin: 1em;
-  min-height: 1px;
-  min-width: 1px;
-}
-:scope mjx-container[jax="SVG"] > svg a {
-  fill: blue;
-  stroke: blue;
-}
-:scope mjx-assistive-mml {
-  top: 0px;
-  left: 0px;
-  clip: rect(1px, 1px, 1px, 1px) !important;
-  user-select: text !important;
-  position: absolute !important;
-  padding: 1px 0px 0px !important;
-  border: 0px !important;
-  display: block !important;
-  width: auto !important;
-  overflow: hidden !important;
-}
-:scope mjx-assistive-mml[display="block"] {
-  width: 100% !important;
-}
-:scope mjx-container[jax="SVG"][display="true"] {
-  display: block;
-  text-align: center;
-  margin: 1em 0px;
-}
-:scope mjx-container[jax="SVG"][display="true"][width="full"] {
-  display: flex;
-}
-:scope mjx-container[jax="SVG"][justify="left"] {
-  text-align: left;
-}
-:scope mjx-container[jax="SVG"][justify="right"] {
-  text-align: right;
-}
-:scope g[data-mml-node="merror"] > g {
-  fill: red;
-  stroke: red;
-}
-:scope g[data-mml-node="merror"] > rect[data-background] {
-  fill: yellow;
-  stroke: none;
-}
-:scope g[data-mml-node="mtable"] > line[data-line], :scope svg[data-table] > g > line[data-line] {
-  stroke-width: 70px;
-  fill: none;
-}
-:scope g[data-mml-node="mtable"] > rect[data-frame], :scope svg[data-table] > g > rect[data-frame] {
-  stroke-width: 70px;
-  fill: none;
-}
-:scope g[data-mml-node="mtable"] > .mjx-dashed, :scope svg[data-table] > g > .mjx-dashed {
-  stroke-dasharray: 140;
-}
-:scope g[data-mml-node="mtable"] > .mjx-dotted, :scope svg[data-table] > g > .mjx-dotted {
-  stroke-linecap: round;
-  stroke-dasharray: 0, 140;
-}
-:scope g[data-mml-node="mtable"] > g > svg {
-  overflow: visible;
-}
-:scope g[data-mml-node="maction"][data-toggle] {
-  cursor: pointer;
-}
-:scope mjx-container[jax="SVG"] path[data-c], :scope mjx-container[jax="SVG"] use[data-c] {
-  stroke-width: 3;
-}
-:scope g[data-mml-node="xypic"] path {
-  stroke-width: inherit;
-}
-`;
-var mathJaxStyles = (scopeId) => MATHJAX_STYLES.replaceAll(":scope", `#${scopeId}`).trim();
-//#endregion
 //#region ../../packages/react/src/components/renderedHtmlSanitizer.ts
 var FORBIDDEN_TAGS = [
 	"animate",
@@ -8417,15 +8462,12 @@ var FORBIDDEN_TAGS = [
 	"select",
 	"set",
 	"source",
+	"style",
 	"textarea",
 	"track",
 	"video"
 ];
-var MATHJAX_TAGS = [
-	"mjx-assistive-mml",
-	"mjx-container",
-	"style"
-];
+var MATHJAX_TAGS = ["mjx-assistive-mml", "mjx-container"];
 var MATHJAX_ATTRS = [
 	"display",
 	"focusable",
@@ -8501,7 +8543,6 @@ var SAFE_CSS_FUNCTIONS = /* @__PURE__ */ new Set([
 ]);
 var UNSAFE_CSS_PATTERN = /@import|behavior\s*:|binding\s*:|expression\s*\(|javascript\s*:|vbscript\s*:|url\s*\(/i;
 var RAW_CSS_REJECT_PATTERN = /[\\@<]/;
-var MATHJAX_WRAPPER_ID = /^mjx-[a-f0-9]+$/i;
 var PURIFY_CONFIG = {
 	ADD_ATTR: [...MATHJAX_ATTRS, "target"],
 	ADD_DATA_URI_TAGS: ["img"],
@@ -8537,12 +8578,6 @@ var getPurify = () => {
 var installHooks = (purify) => {
 	if (hooksInstalled) return;
 	hooksInstalled = true;
-	purify.addHook("uponSanitizeElement", (node, hookEvent) => {
-		if (hookEvent.tagName !== "style" || !(node instanceof Element)) return;
-		const css = sanitizeMathJaxStyleElement(node);
-		if (css) node.textContent = css;
-		else node.remove();
-	});
 	purify.addHook("uponSanitizeAttribute", (node, hookEvent) => {
 		if (hookEvent.attrName === "style") {
 			if (node.tagName.toLowerCase() === "mjx-assistive-mml") {
@@ -8629,13 +8664,7 @@ var isSafeStyleValue = (property, value) => {
 	if (property.startsWith("margin") && /(?:^|\s)-/.test(value)) return false;
 	return true;
 };
-var sanitizeMathJaxStyleElement = (element) => {
-	const parent = element.parentElement;
-	const scopeId = parent?.getAttribute("id") ?? "";
-	if (parent?.tagName.toLowerCase() !== "span" || !MATHJAX_WRAPPER_ID.test(scopeId)) return "";
-	return mathJaxStyles(scopeId);
-};
 //#endregion
 export { renderMarkdown, sanitizeRenderedHtml, truncateMarkdown };
 
-//# sourceMappingURL=markdownPipeline-C_z-iU9a.js.map
+//# sourceMappingURL=markdownPipeline-D23f-WkE.js.map