@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/{dom-DG3sPESc.mjs → dom-BmbZv4v9.mjs}

@@ -1,10 +1,17 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/dom/parser.ts
-const RAW_TEXT_ELEMENTS = {
-	script: true,
-	style: true
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/dom/parser.ts
+/** Closing-tag patterns for raw-text elements, reused across parses (callers reset `lastIndex`). */
+const RAW_TEXT_CLOSE = {
+	script: /<\/script\s*>/gi,
+	style: /<\/style\s*>/gi
 };
+const DOCTYPE_PATTERN = /<!doctype\b/iy;
+const TAG_NAME_PATTERN = /[^\s/>]+/y;
+const ATTRIBUTE_NAME_PATTERN = /[^\s=/>]+/y;
+const UNQUOTED_VALUE_PATTERN = /[^\s>]+/y;
+const SVG_NAMESPACE$1 = "http://www.w3.org/2000/svg";
+const HTML_NAMESPACE$1 = "http://www.w3.org/1999/xhtml";
 const VOID_ELEMENTS$1 = {
 	area: true,
 	base: true,
@@ -186,9 +193,11 @@ const NAMED_ENTITIES = {
 	yuml: "ÿ",
 	yen: "¥"
 };
+const ENTITY_PATTERN = /&(#(?:x[0-9a-f]+|\d+)|[a-z][a-z0-9]+);/gi;
 /** Decode common named entities and all valid numeric character references. */
 function decodeEntities(value) {
-	return value.replace(/&(#(?:x[0-9a-f]+|\d+)|[a-z][a-z0-9]+);/gi, (whole, entity) => {
+	if (!value.includes("&")) return value;
+	return value.replace(ENTITY_PATTERN, (whole, entity) => {
 		if (entity[0] !== "#") return NAMED_ENTITIES[entity] ?? NAMED_ENTITIES[entity.toLowerCase()] ?? whole;
 		const hexadecimal = entity[1]?.toLowerCase() === "x";
 		const codePoint = Number.parseInt(entity.slice(hexadecimal ? 2 : 1), hexadecimal ? 16 : 10);
@@ -210,7 +219,8 @@ function findTagEnd(html, start) {
 function parseStartTag(source) {
 	let index = 0;
 	while (/\s/.test(source[index] ?? "")) index++;
-	const nameMatch = /^[^\s/>]+/.exec(source.slice(index));
+	TAG_NAME_PATTERN.lastIndex = index;
+	const nameMatch = TAG_NAME_PATTERN.exec(source);
 	if (!nameMatch) return null;
 	const name = nameMatch[0].toLowerCase();
 	index += nameMatch[0].length;
@@ -222,7 +232,8 @@ function parseStartTag(source) {
 			selfClosing = true;
 			break;
 		}
-		const attributeMatch = /^[^\s=/>]+/.exec(source.slice(index));
+		ATTRIBUTE_NAME_PATTERN.lastIndex = index;
+		const attributeMatch = ATTRIBUTE_NAME_PATTERN.exec(source);
 		if (!attributeMatch) break;
 		const attributeName = attributeMatch[0];
 		index += attributeMatch[0].length;
@@ -243,7 +254,8 @@ function parseStartTag(source) {
 					index = end + 1;
 				}
 			} else {
-				value = /^[^\s>]+/.exec(source.slice(index))?.[0] ?? "";
+				UNQUOTED_VALUE_PATTERN.lastIndex = index;
+				value = UNQUOTED_VALUE_PATTERN.exec(source)?.[0] ?? "";
 				index += value.length;
 			}
 		}
@@ -264,7 +276,8 @@ function closeOptionalElements(stack, incoming) {
 	}
 	if (CLOSE_ON_OPEN[incoming]?.includes(current.localName)) stack.pop();
 }
-function parseInto(html, document, root, contextTag) {
+/** Parse markup, appending the resulting nodes to `root` (a document, fragment, or element). */
+function parseInto(html, document, root) {
 	const stack = [];
 	const xmlLike = root instanceof Document && /^\s*(?:<\?xml[\s\S]*?\?>\s*)?<(?:feed|rss)\b/i.test(html);
 	let parent = root;
@@ -284,7 +297,7 @@ function parseInto(html, document, root, contextTag) {
 			index = end;
 			continue;
 		}
-		if (/^<!doctype\b/i.test(html.slice(index))) {
+		if (html[index + 1] === "!" && isDoctypeAt(html, index)) {
 			const end = html.indexOf(">", index + 2);
 			index = end < 0 ? html.length : end + 1;
 			continue;
@@ -319,7 +332,7 @@ function parseInto(html, document, root, contextTag) {
 		}
 		closeOptionalElements(stack, parsed.name);
 		parent = stack[stack.length - 1] ?? root;
-		const namespace = parent instanceof Element && parent.namespaceURI === "http://www.w3.org/2000/svg" ? "http://www.w3.org/2000/svg" : parsed.name === "svg" ? "http://www.w3.org/2000/svg" : "http://www.w3.org/1999/xhtml";
+		const namespace = parent !== root && parent instanceof Element && parent.namespaceURI === SVG_NAMESPACE$1 || parsed.name === "svg" ? SVG_NAMESPACE$1 : HTML_NAMESPACE$1;
 		const element = document.createElementNS(namespace, parsed.name);
 		for (let attributeIndex = parsed.attributes.length - 1; attributeIndex >= 0; attributeIndex--) {
 			const [name, value] = parsed.attributes[attributeIndex];
@@ -327,8 +340,8 @@ function parseInto(html, document, root, contextTag) {
 		}
 		parent.appendChild(element);
 		index = end + 1;
-		if (RAW_TEXT_ELEMENTS[parsed.name] && !parsed.selfClosing) {
-			const closePattern = new RegExp(`</${parsed.name}\\s*>`, "ig");
+		if (RAW_TEXT_CLOSE[parsed.name] && !parsed.selfClosing) {
+			const closePattern = Object.hasOwn(RAW_TEXT_CLOSE, parsed.name) ? RAW_TEXT_CLOSE[parsed.name] : new RegExp(`</${parsed.name}\\s*>`, "ig");
 			closePattern.lastIndex = index;
 			const match = closePattern.exec(html);
 			const rawEnd = match?.index ?? html.length;
@@ -336,16 +349,20 @@ function parseInto(html, document, root, contextTag) {
 			index = match ? closePattern.lastIndex : html.length;
 			continue;
 		}
-		if (!VOID_ELEMENTS$1[parsed.name] && !(namespace === "http://www.w3.org/2000/svg" && parsed.selfClosing)) {
+		if (!(xmlLike ? parsed.selfClosing : VOID_ELEMENTS$1[parsed.name] || namespace === SVG_NAMESPACE$1 && parsed.selfClosing)) {
 			stack.push(element);
 			parent = element;
 		}
 	}
 }
-/** Parse markup into a document fragment. */
-function parseFragment(html, document, contextTag) {
+function isDoctypeAt(html, index) {
+	DOCTYPE_PATTERN.lastIndex = index;
+	return DOCTYPE_PATTERN.test(html);
+}
+/** Parse markup into a document fragment. `_contextTag` is accepted for compatibility and ignored. */
+function parseFragment(html, document, _contextTag) {
 	const fragment = document.createDocumentFragment();
-	parseInto(html, document, fragment, contextTag);
+	parseInto(html, document, fragment);
 	return fragment;
 }
 /** Parse markup directly into a document. */
@@ -355,7 +372,24 @@ function parseDocument(html) {
 	return document;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/dom/selector.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/dom/selector.ts
+const SUPPORTED_PSEUDOS = {
+	not: true,
+	is: true,
+	where: true,
+	"first-child": true,
+	"last-child": true,
+	"only-child": true,
+	empty: true,
+	root: true,
+	"nth-child": true,
+	"first-of-type": true,
+	"last-of-type": true
+};
+const ATTRIBUTE_PATTERN = /^\s*([^\s~|^$*!=]+)\s*(?:(\^=|\$=|\*=|~=|\|=|=)\s*(?:(["'])(.*?)\3|([^\s]+))\s*([isIS])?)?\s*$/;
+const IDENTIFIER_CHARACTER = /[a-zA-Z0-9_-]/;
+const MAX_CACHED_SELECTORS = 512;
+const compiledSelectors = /* @__PURE__ */ new Map();
 function splitTopLevel(value, delimiter) {
 	const parts = [];
 	let start = 0;
@@ -381,7 +415,7 @@ function splitTopLevel(value, delimiter) {
 	parts.push(value.slice(start).trim());
 	return parts.filter(Boolean);
 }
-function parseComplex(selector) {
+function splitComplex(selector) {
 	const simples = [];
 	const combinators = [];
 	let current = "";
@@ -444,7 +478,7 @@ function readIdentifier(source, start) {
 			index += 2;
 			continue;
 		}
-		if (!/[a-zA-Z0-9_-]/.test(character)) break;
+		if (!IDENTIFIER_CHARACTER.test(character)) break;
 		value += character;
 		index++;
 	}
@@ -466,81 +500,89 @@ function findClosing(source, start, opener, closer) {
 	}
 	return source.length - 1;
 }
-function matchAttribute(element, expression) {
-	const match = /^\s*([^\s~|^$*!=]+)\s*(?:(\^=|\$=|\*=|~=|\|=|=)\s*(?:(["'])(.*?)\3|([^\s]+))\s*([isIS])?)?\s*$/.exec(expression);
-	if (!match) return false;
+function compileAttribute(expression) {
+	const match = ATTRIBUTE_PATTERN.exec(expression);
+	if (!match) return null;
 	const [, name, operator, , quotedValue, bareValue, flag] = match;
-	const actual = element.getAttribute(name);
-	if (!operator) return actual !== null;
-	if (actual === null) return false;
-	let left = actual;
-	let right = (quotedValue ?? bareValue ?? "").replace(/\\(.)/g, "$1");
-	if (flag?.toLowerCase() === "i") {
-		left = left.toLowerCase();
-		right = right.toLowerCase();
-	}
-	switch (operator) {
-		case "=": return left === right;
-		case "^=": return left.startsWith(right);
-		case "$=": return left.endsWith(right);
-		case "*=": return left.includes(right);
-		case "~=": return left.split(/\s+/).includes(right);
-		case "|=": return left === right || left.startsWith(`${right}-`);
-		default: return false;
-	}
+	const ignoreCase = flag?.toLowerCase() === "i";
+	const value = (quotedValue ?? bareValue ?? "").replace(/\\(.)/g, "$1");
+	return {
+		name,
+		operator,
+		value: ignoreCase ? value.toLowerCase() : value,
+		ignoreCase
+	};
 }
-function matchNth(element, expression) {
-	const index = (element.parentElement?.children ?? []).indexOf(element) + 1;
+function compileNth(expression) {
 	const normalized = expression.trim().toLowerCase().replace(/\s+/g, "");
-	if (normalized === "odd") return index % 2 === 1;
-	if (normalized === "even") return index % 2 === 0;
-	if (/^[+-]?\d+$/.test(normalized)) return index === Number(normalized);
+	if (normalized === "odd" || normalized === "even") return { kind: normalized };
+	if (/^[+-]?\d+$/.test(normalized)) return {
+		kind: "index",
+		index: Number(normalized)
+	};
 	const match = /^([+-]?\d*)n([+-]\d+)?$/.exec(normalized);
-	if (!match) return false;
-	const coefficient = match[1] === "" || match[1] === "+" ? 1 : match[1] === "-" ? -1 : Number(match[1]);
-	const offset = Number(match[2] ?? 0);
-	return coefficient === 0 ? index === offset : (index - offset) / coefficient >= 0 && Number.isInteger((index - offset) / coefficient);
+	if (!match) return { kind: "invalid" };
+	return {
+		kind: "formula",
+		coefficient: match[1] === "" || match[1] === "+" ? 1 : match[1] === "-" ? -1 : Number(match[1]),
+		offset: Number(match[2] ?? 0)
+	};
 }
-function matchPseudo(element, name, argument) {
-	switch (name) {
-		case "not": return argument !== void 0 && !matchesSelector(element, argument);
-		case "is":
-		case "where": return argument !== void 0 && matchesSelector(element, argument);
-		case "first-child": return element.parentElement?.firstElementChild === element;
-		case "last-child": return element.parentElement?.lastElementChild === element;
-		case "only-child": return element.parentElement?.children.length === 1;
-		case "empty": return element.childNodes.every((child) => child.nodeType === Node.COMMENT_NODE || child.textContent === "");
-		case "root": return element.ownerDocument?.documentElement === element;
-		case "nth-child": return argument !== void 0 && matchNth(element, argument);
-		case "first-of-type":
-			for (let sibling = element.previousElementSibling; sibling; sibling = sibling.previousElementSibling) if (sibling.tagName === element.tagName) return false;
-			return true;
-		case "last-of-type":
-			for (let sibling = element.nextElementSibling; sibling; sibling = sibling.nextElementSibling) if (sibling.tagName === element.tagName) return false;
-			return true;
-		default: return false;
-	}
+function compilePseudo(name, argument) {
+	if (!SUPPORTED_PSEUDOS[name]) return null;
+	if (name === "not" || name === "is" || name === "where") return argument === void 0 ? null : {
+		name,
+		list: compileSelector(argument),
+		nth: null
+	};
+	if (name === "nth-child") return argument === void 0 ? null : {
+		name,
+		list: null,
+		nth: compileNth(argument)
+	};
+	return {
+		name,
+		list: null,
+		nth: null
+	};
 }
-function matchSimple(element, selector) {
+function compileCompound(selector) {
+	const compound = {
+		tag: null,
+		ids: [],
+		classes: [],
+		attributes: [],
+		pseudos: [],
+		invalid: false,
+		bare: false
+	};
 	let index = 0;
 	if (selector[index] === "*") index++;
 	else if (/[a-zA-Z_]/.test(selector[index] ?? "")) {
 		const tag = readIdentifier(selector, index);
-		if (element.localName !== tag.value.toLowerCase()) return false;
+		compound.tag = tag.value.toLowerCase();
 		index = tag.end;
 	}
 	while (index < selector.length) {
 		const marker = selector[index];
 		if (marker === "#" || marker === ".") {
 			const identifier = readIdentifier(selector, index + 1);
-			if (!identifier.value) return false;
-			if (marker === "#" ? element.id !== identifier.value : !element.classList.contains(identifier.value)) return false;
+			if (!identifier.value) {
+				compound.invalid = true;
+				break;
+			}
+			(marker === "#" ? compound.ids : compound.classes).push(identifier.value);
 			index = identifier.end;
 			continue;
 		}
 		if (marker === "[") {
 			const end = findClosing(selector, index, "[", "]");
-			if (!matchAttribute(element, selector.slice(index + 1, end))) return false;
+			const attribute = compileAttribute(selector.slice(index + 1, end));
+			if (!attribute) {
+				compound.invalid = true;
+				break;
+			}
+			compound.attributes.push(attribute);
 			index = end + 1;
 			continue;
 		}
@@ -553,19 +595,151 @@ function matchSimple(element, selector) {
 				argument = selector.slice(index + 1, end);
 				index = end + 1;
 			}
-			if (!matchPseudo(element, identifier.value.toLowerCase(), argument)) return false;
+			const pseudo = compilePseudo(identifier.value.toLowerCase(), argument);
+			if (!pseudo) {
+				compound.invalid = true;
+				break;
+			}
+			compound.pseudos.push(pseudo);
 			continue;
 		}
-		return false;
+		compound.invalid = true;
+		break;
+	}
+	compound.bare = !compound.invalid && compound.ids.length === 0 && compound.classes.length === 0 && compound.attributes.length === 0 && compound.pseudos.length === 0;
+	return compound;
+}
+function compileSelector(selector) {
+	const cached = compiledSelectors.get(selector);
+	if (cached) return cached;
+	const list = {
+		universal: false,
+		tags: null,
+		complexes: []
+	};
+	for (const part of splitTopLevel(selector, ",")) {
+		const { simples, combinators } = splitComplex(part);
+		if (!simples.length) continue;
+		const compounds = simples.map(compileCompound);
+		const only = compounds[0];
+		if (compounds.length === 1 && only.bare) {
+			if (only.tag === null) list.universal = true;
+			else (list.tags ??= /* @__PURE__ */ new Set()).add(only.tag);
+			continue;
+		}
+		list.complexes.push({
+			compounds,
+			combinators
+		});
 	}
+	if (compiledSelectors.size >= MAX_CACHED_SELECTORS) compiledSelectors.clear();
+	compiledSelectors.set(selector, list);
+	return list;
+}
+function isWhitespace(code) {
+	return code === 32 || code >= 9 && code <= 13 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288 || code === 65279;
+}
+/** Whether a whitespace-separated class string contains a token, without splitting it. */
+function hasClassToken(className, token) {
+	if (!token) return false;
+	for (let index = 0; index < token.length; index++) if (isWhitespace(token.charCodeAt(index))) return false;
+	let from = 0;
+	while (true) {
+		const found = className.indexOf(token, from);
+		if (found < 0) return false;
+		const end = found + token.length;
+		if ((found === 0 || isWhitespace(className.charCodeAt(found - 1))) && (end === className.length || isWhitespace(className.charCodeAt(end)))) return true;
+		from = found + 1;
+	}
+}
+function matchAttribute(element, test) {
+	const actual = element.getAttribute(test.name);
+	if (!test.operator) return actual !== null;
+	if (actual === null) return false;
+	const left = test.ignoreCase ? actual.toLowerCase() : actual;
+	const right = test.value;
+	switch (test.operator) {
+		case "=": return left === right;
+		case "^=": return left.startsWith(right);
+		case "$=": return left.endsWith(right);
+		case "*=": return left.includes(right);
+		case "~=": return left.split(/\s+/).includes(right);
+		case "|=": return left === right || left.startsWith(`${right}-`);
+		default: return false;
+	}
+}
+/** One-based position among element siblings, or 0 without a parent element. */
+function elementIndex(element) {
+	const parent = element.parentElement;
+	if (!parent) return 0;
+	let index = 0;
+	for (const sibling of parent.childNodes) {
+		if (!(sibling instanceof Element)) continue;
+		index++;
+		if (sibling === element) return index;
+	}
+	return 0;
+}
+function matchNth(element, test) {
+	if (test.kind === "invalid") return false;
+	const index = elementIndex(element);
+	switch (test.kind) {
+		case "odd": return index % 2 === 1;
+		case "even": return index % 2 === 0;
+		case "index": return index === test.index;
+		case "formula": return test.coefficient === 0 ? index === test.offset : (index - test.offset) / test.coefficient >= 0 && Number.isInteger((index - test.offset) / test.coefficient);
+	}
+}
+function hasSingleElementChild(parent) {
+	let count = 0;
+	for (const child of parent.childNodes) if (child instanceof Element && ++count > 1) return false;
+	return count === 1;
+}
+function matchPseudo(element, pseudo) {
+	switch (pseudo.name) {
+		case "not": return !matchesList(element, pseudo.list);
+		case "is":
+		case "where": return matchesList(element, pseudo.list);
+		case "first-child": return element.parentElement?.firstElementChild === element;
+		case "last-child": return element.parentElement?.lastElementChild === element;
+		case "only-child": {
+			const parent = element.parentElement;
+			return parent !== null && hasSingleElementChild(parent);
+		}
+		case "empty": return !element.hasChildNodes() || element.childNodes.every((child) => child.nodeType === Node.COMMENT_NODE || child.textContent === "");
+		case "root": return element.ownerDocument?.documentElement === element;
+		case "nth-child": return matchNth(element, pseudo.nth);
+		case "first-of-type":
+			for (let sibling = element.previousElementSibling; sibling; sibling = sibling.previousElementSibling) if (sibling.tagName === element.tagName) return false;
+			return true;
+		case "last-of-type":
+			for (let sibling = element.nextElementSibling; sibling; sibling = sibling.nextElementSibling) if (sibling.tagName === element.tagName) return false;
+			return true;
+		default: return false;
+	}
+}
+function matchCompound(element, compound) {
+	if (compound.invalid) return false;
+	if (compound.tag !== null && element.localName !== compound.tag) return false;
+	if (compound.bare) return true;
+	for (const id of compound.ids) if (element.id !== id) return false;
+	if (compound.classes.length) {
+		const className = element.className;
+		for (const token of compound.classes) if (!hasClassToken(className, token)) return false;
+	}
+	for (const attribute of compound.attributes) if (!matchAttribute(element, attribute)) return false;
+	for (const pseudo of compound.pseudos) if (!matchPseudo(element, pseudo)) return false;
 	return true;
 }
 function matchComplexAt(element, complex, index) {
-	if (!matchSimple(element, complex.simples[index])) return false;
+	if (!matchCompound(element, complex.compounds[index])) return false;
 	if (index === 0) return true;
 	const combinator = complex.combinators[index - 1] ?? " ";
 	if (combinator === ">") return element.parentElement !== null && matchComplexAt(element.parentElement, complex, index - 1);
-	if (combinator === "+") return element.previousElementSibling !== null && matchComplexAt(element.previousElementSibling, complex, index - 1);
+	if (combinator === "+") {
+		const previous = element.previousElementSibling;
+		return previous !== null && matchComplexAt(previous, complex, index - 1);
+	}
 	if (combinator === "~") {
 		for (let sibling = element.previousElementSibling; sibling; sibling = sibling.previousElementSibling) if (matchComplexAt(sibling, complex, index - 1)) return true;
 		return false;
@@ -573,27 +747,52 @@ function matchComplexAt(element, complex, index) {
 	for (let ancestor = element.parentElement; ancestor; ancestor = ancestor.parentElement) if (matchComplexAt(ancestor, complex, index - 1)) return true;
 	return false;
 }
+function matchesList(element, list) {
+	if (list.universal) return true;
+	if (list.tags?.has(element.localName)) return true;
+	for (const complex of list.complexes) if (matchComplexAt(element, complex, complex.compounds.length - 1)) return true;
+	return false;
+}
+function collectMatches(nodes, list, result) {
+	for (let index = 0; index < nodes.length; index++) {
+		const node = nodes[index];
+		if (node instanceof Element && matchesList(node, list)) result.push(node);
+		if (node.hasChildNodes()) collectMatches(node.childNodes, list, result);
+	}
+}
+function findMatch(nodes, list) {
+	for (let index = 0; index < nodes.length; index++) {
+		const node = nodes[index];
+		if (node instanceof Element && matchesList(node, list)) return node;
+		if (node.hasChildNodes()) {
+			const found = findMatch(node.childNodes, list);
+			if (found) return found;
+		}
+	}
+	return null;
+}
 /** Whether an element matches a CSS selector list. */
 function matchesSelector(element, selector) {
-	for (const part of splitTopLevel(selector, ",")) {
-		const complex = parseComplex(part);
-		if (complex.simples.length && matchComplexAt(element, complex, complex.simples.length - 1)) return true;
-	}
-	return false;
+	return matchesList(element, compileSelector(selector));
+}
+/** Nearest inclusive ancestor of an element matching a CSS selector list. */
+function closestMatching(element, selector) {
+	const list = compileSelector(selector);
+	for (let current = element; current; current = current.parentElement) if (matchesList(current, list)) return current;
+	return null;
 }
 /** Query descendants of a node in document order. */
-function querySelectorAllFrom(root, selector, includeRoot) {
+function querySelectorAllFrom(root, selector, _includeRoot) {
 	const result = [];
-	const visit = (node) => {
-		if (node instanceof Element && matchesSelector(node, selector)) result.push(node);
-		for (const child of node.childNodes) visit(child);
-	};
-	if (includeRoot) for (const child of root.childNodes) visit(child);
-	else for (const child of root.childNodes) visit(child);
+	if (root.hasChildNodes()) collectMatches(root.childNodes, compileSelector(selector), result);
 	return result;
 }
+/** First descendant of a node in document order matching a selector, stopping at the first match. */
+function querySelectorFrom(root, selector) {
+	return root.hasChildNodes() ? findMatch(root.childNodes, compileSelector(selector)) : null;
+}
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/dom/core.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/dom/core.ts
 /** Behavior-compatible reimplementation of linkedom's used surface. */
 /** DOM node type constants. */
 let NodeType = /* @__PURE__ */ function(NodeType) {
@@ -649,26 +848,29 @@ var CustomEvent = class extends Event {
 };
 /** Minimal event-target implementation used by DOM nodes and window. */
 var EventTarget = class {
-	#listeners = /* @__PURE__ */ new Map();
+	/** Allocated on the first `addEventListener`; most nodes never get listeners. */
+	#listeners;
 	/** Register an event listener. */
 	addEventListener(type, listener) {
 		if (!listener) return;
-		let listeners = this.#listeners.get(type);
+		const listenerMap = this.#listeners ??= /* @__PURE__ */ new Map();
+		let listeners = listenerMap.get(type);
 		if (!listeners) {
 			listeners = /* @__PURE__ */ new Set();
-			this.#listeners.set(type, listeners);
+			listenerMap.set(type, listeners);
 		}
 		listeners.add(listener);
 	}
 	/** Remove an event listener. */
 	removeEventListener(type, listener) {
-		if (listener) this.#listeners.get(type)?.delete(listener);
+		if (listener) this.#listeners?.get(type)?.delete(listener);
 	}
 	/** Dispatch an event to listeners and optionally through node ancestors. */
 	dispatchEvent(event) {
 		if (!event.target) event.target = this;
 		event.currentTarget = this;
-		for (const listener of Array.from(this.#listeners.get(event.type) ?? [])) {
+		const listeners = this.#listeners?.get(event.type);
+		for (const listener of listeners ? Array.from(listeners) : []) {
 			if (typeof listener === "function") listener.call(this, event);
 			else listener.handleEvent(event);
 			if (event.propagationStopped) break;
@@ -677,6 +879,8 @@ var EventTarget = class {
 		return !event.defaultPrevented;
 	}
 };
+/** Index of a node in its parent's `childNodes`, or -1; bound to Node's private index hint. */
+let indexInParent;
 /** Base class for the implemented DOM tree. */
 var Node = class Node extends EventTarget {
 	static ELEMENT_NODE = 1;
@@ -689,32 +893,108 @@ var Node = class Node extends EventTarget {
 	nodeName;
 	parentNode = null;
 	ownerDocument;
-	childNodes = [];
+	/** Allocated on first access or insertion, so leaf nodes (text, comments, attributes) usually never allocate. */
+	#childNodes;
+	/** Last known index in the parent's `childNodes`; always verified before use, so a stale value only costs a rescan. */
+	#index = 0;
+	static {
+		indexInParent = (node) => {
+			const siblings = node.#siblings();
+			return siblings ? node.#indexIn(siblings) : -1;
+		};
+	}
 	constructor(nodeType, nodeName, ownerDocument = null) {
 		super();
 		this.nodeType = nodeType;
 		this.nodeName = nodeName;
 		this.ownerDocument = ownerDocument;
 	}
+	/** Child nodes in tree order. */
+	get childNodes() {
+		this.#childNodes ??= [];
+		return this.#childNodes;
+	}
+	set childNodes(value) {
+		this.#childNodes = value;
+	}
+	/** Whether this node has any children (without allocating a child list). */
+	hasChildNodes() {
+		return this.#childNodes !== void 0 && this.#childNodes.length > 0;
+	}
 	/** First child node, if present. */
 	get firstChild() {
-		return this.childNodes[0] ?? null;
+		return this.#childNodes?.[0] ?? null;
 	}
 	/** Last child node, if present. */
 	get lastChild() {
-		return this.childNodes[this.childNodes.length - 1] ?? null;
+		const children = this.#childNodes;
+		return children ? children[children.length - 1] ?? null : null;
 	}
 	/** Previous node with the same parent. */
 	get previousSibling() {
-		if (!this.parentNode) return null;
-		const index = this.parentNode.childNodes.indexOf(this);
-		return index > 0 ? this.parentNode.childNodes[index - 1] : null;
+		const siblings = this.#siblings();
+		if (!siblings) return null;
+		const index = this.#indexIn(siblings);
+		return index > 0 ? siblings[index - 1] : null;
 	}
 	/** Next node with the same parent. */
 	get nextSibling() {
-		if (!this.parentNode) return null;
-		const index = this.parentNode.childNodes.indexOf(this);
-		return index >= 0 ? this.parentNode.childNodes[index + 1] ?? null : null;
+		const siblings = this.#siblings();
+		if (!siblings) return null;
+		const index = this.#indexIn(siblings);
+		return index >= 0 ? siblings[index + 1] ?? null : null;
+	}
+	/** The parent's child list, without allocating one. */
+	#siblings() {
+		const parent = this.parentNode;
+		return parent ? parent.#childNodes : void 0;
+	}
+	/** Locate this node in `siblings` via the index hint, re-indexing all siblings on a miss. */
+	#indexIn(siblings) {
+		const hint = this.#index;
+		if (siblings[hint] === this) return hint;
+		if (siblings[hint + 1] === this) return ++this.#index;
+		if (hint > 0 && siblings[hint - 1] === this) return --this.#index;
+		let found = -1;
+		for (let index = 0; index < siblings.length; index++) {
+			const sibling = siblings[index];
+			sibling.#index = index;
+			if (found < 0 && sibling === this) found = index;
+		}
+		if (found >= 0) this.#index = found;
+		return found;
+	}
+	/** Index of a child in this node's `childNodes`, or -1. */
+	#childIndex(child) {
+		const children = this.#childNodes;
+		if (!children) return -1;
+		return child?.parentNode === this ? child.#indexIn(children) : children.indexOf(child);
+	}
+	/** Move every child of a fragment into this node at `index` (append for null). */
+	#adoptChildren(fragment, index) {
+		const moved = fragment.#childNodes;
+		if (!moved?.length) return;
+		if (moved.some((nested) => nested.parentNode !== fragment || nested instanceof DocumentFragment)) {
+			const reference = index === null ? null : this.#childNodes?.[index] ?? null;
+			for (const nested of Array.from(moved)) if (reference === null) this.appendChild(nested);
+			else this.insertBefore(nested, reference);
+			return;
+		}
+		const document = this.documentForCreation();
+		const nodes = moved.slice();
+		moved.length = 0;
+		const children = this.#childNodes ??= [];
+		const tail = index === null ? [] : children.splice(index);
+		for (const node of nodes) {
+			node.parentNode = this;
+			node.setOwnerDocument(document);
+			node.#index = children.length;
+			children.push(node);
+		}
+		for (const node of tail) {
+			node.#index = children.length;
+			children.push(node);
+		}
 	}
 	/** Connectedness to a document. */
 	get isConnected() {
@@ -729,7 +1009,11 @@ var Node = class Node extends EventTarget {
 	set nodeValue(_value) {}
 	/** Text contained by this node. */
 	get textContent() {
-		return this.childNodes.map((child) => child.textContent ?? "").join("");
+		const children = this.#childNodes;
+		if (!children?.length) return "";
+		const only = children[0];
+		if (children.length === 1 && only instanceof Text) return only.data;
+		return collectText(children);
 	}
 	set textContent(value) {
 		this.replaceChildren();
@@ -744,41 +1028,45 @@ var Node = class Node extends EventTarget {
 		const node = child;
 		if (node === this || node.contains(this)) throw new Error("The new child is an ancestor of this node");
 		if (child instanceof DocumentFragment) {
-			for (const nested of Array.from(child.childNodes)) this.appendChild(nested);
+			this.#adoptChildren(child, null);
 			return child;
 		}
 		child.parentNode?.removeChild(child);
 		child.parentNode = this;
 		child.setOwnerDocument(this.documentForCreation());
-		this.childNodes.push(child);
+		const children = this.#childNodes ??= [];
+		node.#index = children.length;
+		children.push(child);
 		return child;
 	}
 	/** Insert a node before a current child, or append for null. */
 	insertBefore(child, reference) {
 		if (reference === null) return this.appendChild(child);
-		const index = this.childNodes.indexOf(reference);
+		const index = this.#childIndex(reference);
 		if (index < 0) throw new Error("The reference node is not a child of this node");
 		if (child instanceof DocumentFragment) {
-			for (const nested of Array.from(child.childNodes)) this.insertBefore(nested, reference);
+			this.#adoptChildren(child, index);
 			return child;
 		}
 		child.parentNode?.removeChild(child);
 		child.parentNode = this;
 		child.setOwnerDocument(this.documentForCreation());
+		const node = child;
+		node.#index = index;
 		this.childNodes.splice(index, 0, child);
 		return child;
 	}
 	/** Replace a current child with another node. */
 	replaceChild(child, previous) {
-		const index = this.childNodes.indexOf(previous);
+		const index = this.#childIndex(previous);
 		if (index < 0) throw new Error("The node to replace is not a child of this node");
 		this.removeChild(previous);
-		this.insertBefore(child, this.childNodes[index] ?? null);
+		this.insertBefore(child, this.#childNodes?.[index] ?? null);
 		return previous;
 	}
 	/** Remove a current child. */
 	removeChild(child) {
-		const index = this.childNodes.indexOf(child);
+		const index = this.#childIndex(child);
 		if (index < 0) throw new Error("The node to remove is not a child of this node");
 		this.childNodes.splice(index, 1);
 		child.parentNode = null;
@@ -786,8 +1074,9 @@ var Node = class Node extends EventTarget {
 	}
 	/** Replace all children with nodes or strings. */
 	replaceChildren(...children) {
-		for (const child of this.childNodes) child.parentNode = null;
-		this.childNodes = [];
+		const previous = this.#childNodes;
+		if (previous) for (const child of previous) child.parentNode = null;
+		this.#childNodes = void 0;
 		this.append(...children);
 	}
 	/** Append nodes or strings. */
@@ -818,7 +1107,7 @@ var Node = class Node extends EventTarget {
 	/** Clone this node, optionally including descendants. */
 	cloneNode(deep = false) {
 		const clone = new Node(this.nodeType, this.nodeName, this.ownerDocument);
-		if (deep) for (const child of this.childNodes) clone.appendChild(child.cloneNode(true));
+		if (deep && this.#childNodes) for (const child of this.#childNodes) clone.appendChild(child.cloneNode(true));
 		return clone;
 	}
 	/** Compare tree position sufficiently for document-order consumers. */
@@ -830,14 +1119,15 @@ var Node = class Node extends EventTarget {
 		const nodes = [];
 		const visit = (node) => {
 			nodes.push(node);
-			for (const child of node.childNodes) visit(child);
+			for (const child of node.#childNodes ?? []) visit(child);
 		};
 		visit(root);
 		return nodes.indexOf(this) < nodes.indexOf(other) ? 4 : 2;
 	}
 	setOwnerDocument(document) {
 		if (this.nodeType !== 9) this.ownerDocument = document;
-		for (const child of this.childNodes) child.setOwnerDocument(document);
+		const children = this.#childNodes;
+		if (children) for (const child of children) child.setOwnerDocument(document);
 	}
 	documentForCreation() {
 		if (this instanceof Document) return this;
@@ -924,7 +1214,11 @@ var NamedNodeMap = class extends Array {
 	/** Find an attribute case-insensitively. */
 	getNamedItem(name) {
 		const normalized = name.toLowerCase();
-		return this.find((attr) => attr.name.toLowerCase() === normalized) ?? null;
+		for (let index = 0; index < this.length; index++) {
+			const attr = this[index];
+			if (attr.name === normalized || attr.name.toLowerCase() === normalized) return attr;
+		}
+		return null;
 	}
 	/** Set an attribute object and return the prior one. */
 	setNamedItem(attr) {
@@ -975,7 +1269,7 @@ var DOMTokenList = class {
 	}
 	/** Whether a class token exists. */
 	contains(token) {
-		return this.#tokens().includes(token);
+		return hasClassToken(this.#element.className, token);
 	}
 	/** Toggle a class token. */
 	toggle(token, force) {
@@ -1007,13 +1301,18 @@ var DOMTokenList = class {
 };
 /** Mutable inline style declaration. */
 var CSSStyleDeclaration = class {
-	#values = /* @__PURE__ */ new Map();
+	/** Allocated on the first non-empty declaration. */
+	#values;
+	/** Serialized declarations; `undefined` after a change until the next read. */
+	#cssText = "";
 	/** Serialized declarations. */
 	get cssText() {
-		return [...this.#values].map(([name, value]) => `${name}: ${value};`).join(" ");
+		this.#cssText ??= this.#values ? [...this.#values].map(([name, value]) => `${name}: ${value};`).join(" ") : "";
+		return this.#cssText;
 	}
 	set cssText(value) {
-		this.#values.clear();
+		this.#values?.clear();
+		this.#cssText = void 0;
 		for (const declaration of value.split(";")) {
 			const colon = declaration.indexOf(":");
 			if (colon > 0) this.setProperty(declaration.slice(0, colon).trim(), declaration.slice(colon + 1).trim());
@@ -1021,31 +1320,42 @@ var CSSStyleDeclaration = class {
 	}
 	/** Read a CSS property. */
 	getPropertyValue(name) {
-		return this.#values.get(name) ?? "";
+		return this.#values?.get(name) ?? "";
 	}
 	/** Set a CSS property. */
 	setProperty(name, value, _priority) {
-		if (value === null || value === "") this.#values.delete(name);
-		else this.#values.set(name, String(value));
+		if (value === null || value === "") {
+			if (this.#values?.delete(name)) this.#cssText = void 0;
+			return;
+		}
+		this.#values ??= /* @__PURE__ */ new Map();
+		this.#values.set(name, String(value));
+		this.#cssText = void 0;
 	}
 	/** Remove and return a CSS property. */
 	removeProperty(name) {
 		const value = this.getPropertyValue(name);
-		this.#values.delete(name);
+		if (this.#values?.delete(name)) this.#cssText = void 0;
 		return value;
 	}
 };
 const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
 const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+/** An element's inline style when one has been created; bound to Element's private field. */
+let inlineStyleOf;
 /** DOM element with attributes, selectors, and HTML serialization. */
 var Element = class Element extends Node {
 	localName;
 	tagName;
 	namespaceURI;
 	qualifiedName;
-	attributes = new NamedNodeMap();
-	classList;
-	style = new CSSStyleDeclaration();
+	/** Attribute, class-list and style objects are created on first use. */
+	#attributes;
+	#classList;
+	#style;
+	static {
+		inlineStyleOf = (element) => element.#style;
+	}
 	constructor(tagName, ownerDocument = null, namespaceURI = HTML_NAMESPACE) {
 		const localName = tagName.toLowerCase();
 		const qualified = namespaceURI === HTML_NAMESPACE ? localName.toUpperCase() : tagName;
@@ -1054,29 +1364,58 @@ var Element = class Element extends Node {
 		this.tagName = qualified;
 		this.qualifiedName = tagName;
 		this.namespaceURI = namespaceURI;
-		this.classList = new DOMTokenList(this);
+	}
+	/** Attribute collection. */
+	get attributes() {
+		this.#attributes ??= new NamedNodeMap();
+		return this.#attributes;
+	}
+	/** Class token list over the `class` attribute. */
+	get classList() {
+		this.#classList ??= new DOMTokenList(this);
+		return this.#classList;
+	}
+	/** Inline style declaration. */
+	get style() {
+		this.#style ??= new CSSStyleDeclaration();
+		return this.#style;
+	}
+	/** Whether the element has any attribute objects (without allocating the collection). */
+	hasAttributes() {
+		return this.#attributes !== void 0 && this.#attributes.length > 0;
 	}
 	/** Element children. */
 	get children() {
-		return this.childNodes.filter((child) => child instanceof Element);
+		return childElements(this);
 	}
 	/** First element child. */
 	get firstElementChild() {
-		return this.children[0] ?? null;
+		return firstElementIn(this);
 	}
 	/** Last element child. */
 	get lastElementChild() {
-		const children = this.children;
-		return children[children.length - 1] ?? null;
+		return lastElementIn(this);
 	}
 	/** Previous sibling that is an element. */
 	get previousElementSibling() {
-		for (let node = this.previousSibling; node; node = node.previousSibling) if (node instanceof Element) return node;
+		const index = indexInParent(this);
+		if (index < 0) return null;
+		const siblings = this.parentNode.childNodes;
+		for (let position = index - 1; position >= 0; position--) {
+			const sibling = siblings[position];
+			if (sibling instanceof Element) return sibling;
+		}
 		return null;
 	}
 	/** Next sibling that is an element. */
 	get nextElementSibling() {
-		for (let node = this.nextSibling; node; node = node.nextSibling) if (node instanceof Element) return node;
+		const index = indexInParent(this);
+		if (index < 0) return null;
+		const siblings = this.parentNode.childNodes;
+		for (let position = index + 1; position < siblings.length; position++) {
+			const sibling = siblings[position];
+			if (sibling instanceof Element) return sibling;
+		}
 		return null;
 	}
 	/** Attribute-backed element id. */
@@ -1120,11 +1459,11 @@ var Element = class Element extends Node {
 	get text() {}
 	/** HTML contained inside this element. */
 	get innerHTML() {
-		return this.childNodes.map(serializeNode).join("");
+		return serializeChildren(this);
 	}
 	set innerHTML(value) {
 		this.replaceChildren();
-		for (const child of parseFragment(value, this.documentForCreation(), this.localName).childNodes.slice()) this.appendChild(child);
+		parseInto(value, this.documentForCreation(), this);
 	}
 	/** Serialized element and descendants. */
 	get outerHTML() {
@@ -1133,30 +1472,34 @@ var Element = class Element extends Node {
 	set outerHTML(value) {
 		const parent = this.parentNode;
 		if (!parent) return;
-		const fragment = parseFragment(value, this.documentForCreation(), this.parentElement?.localName);
-		for (const child of Array.from(fragment.childNodes)) parent.insertBefore(child, this);
+		parent.insertBefore(parseFragment(value, this.documentForCreation()), this);
 		parent.removeChild(this);
 	}
 	/** Read an attribute. */
 	getAttribute(name) {
-		if (name.toLowerCase() === "style" && this.style.cssText) return this.style.cssText;
-		return this.attributes.getNamedItem(name)?.value ?? null;
+		const style = this.#style;
+		if (style && name.toLowerCase() === "style") {
+			const cssText = style.cssText;
+			if (cssText) return cssText;
+		}
+		return this.#attributes?.getNamedItem(name)?.value ?? null;
 	}
 	/** Read an attribute object. */
 	getAttributeNode(name) {
-		return this.attributes.getNamedItem(name);
+		return this.#attributes?.getNamedItem(name) ?? null;
 	}
 	/** Whether an attribute exists. */
 	hasAttribute(name) {
-		return this.attributes.getNamedItem(name) !== null || name.toLowerCase() === "style" && Boolean(this.style.cssText);
+		return (this.#attributes?.getNamedItem(name) ?? null) !== null || this.#style !== void 0 && name.toLowerCase() === "style" && Boolean(this.#style.cssText);
 	}
 	/** Set an attribute. */
 	setAttribute(name, value) {
 		const normalized = name.toLowerCase();
 		if (normalized === "style") this.style.cssText = String(value);
-		const existing = this.attributes.getNamedItem(normalized);
+		const attributes = this.attributes;
+		const existing = attributes.getNamedItem(normalized);
 		if (existing) existing.value = String(value);
-		else this.attributes.unshift(new Attr(name, String(value), this.ownerDocument));
+		else attributes.unshift(new Attr(name, String(value), this.ownerDocument));
 	}
 	/** Set a namespaced attribute. */
 	setAttributeNS(_namespace, name, value) {
@@ -1164,13 +1507,14 @@ var Element = class Element extends Node {
 	}
 	/** Remove an attribute. */
 	removeAttribute(name) {
-		const existing = this.attributes.getNamedItem(name);
-		if (existing) this.attributes.splice(this.attributes.indexOf(existing), 1);
-		if (name.toLowerCase() === "style") this.style.cssText = "";
+		const attributes = this.#attributes;
+		const existing = attributes?.getNamedItem(name);
+		if (attributes && existing) attributes.splice(attributes.indexOf(existing), 1);
+		if (this.#style && name.toLowerCase() === "style") this.#style.cssText = "";
 	}
 	/** Find the first descendant matching a selector. */
 	querySelector(selector) {
-		return querySelectorAllFrom(this, selector, false)[0] ?? null;
+		return querySelectorFrom(this, selector);
 	}
 	/** Find all descendants matching a selector. */
 	querySelectorAll(selector) {
@@ -1182,8 +1526,7 @@ var Element = class Element extends Node {
 	}
 	/** Find the nearest matching ancestor including this element. */
 	closest(selector) {
-		for (let element = this; element; element = element.parentElement) if (element.matches(selector)) return element;
-		return null;
+		return closestMatching(this, selector);
 	}
 	/** Descendant elements with a tag name. */
 	getElementsByTagName(tagName) {
@@ -1192,7 +1535,10 @@ var Element = class Element extends Node {
 	/** Descendant elements containing all requested class tokens. */
 	getElementsByClassName(classNames) {
 		const tokens = classNames.trim().split(/\s+/).filter(Boolean);
-		return querySelectorAllFrom(this, "*", false).filter((element) => tokens.every((token) => element.classList.contains(token)));
+		return querySelectorAllFrom(this, "*", false).filter((element) => {
+			const className = element.className;
+			return tokens.every((token) => hasClassToken(className, token));
+		});
 	}
 	/**
 	* Return a zero-sized rectangle because this parser DOM has no layout.
@@ -1229,11 +1575,12 @@ var Element = class Element extends Node {
 	}
 	cloneNode(deep = false) {
 		const clone = this.ownerDocument?.createElementNS(this.namespaceURI, this.qualifiedName) ?? new Element(this.qualifiedName, null, this.namespaceURI);
-		for (let index = this.attributes.length - 1; index >= 0; index--) {
-			const attr = this.attributes[index];
+		const attributes = this.#attributes;
+		if (attributes) for (let index = attributes.length - 1; index >= 0; index--) {
+			const attr = attributes[index];
 			clone.setAttribute(attr.name, attr.value);
 		}
-		if (deep) for (const child of this.childNodes) clone.appendChild(child.cloneNode(true));
+		if (deep && this.hasChildNodes()) for (const child of this.childNodes) clone.appendChild(child.cloneNode(true));
 		return clone;
 	}
 };
@@ -1301,20 +1648,19 @@ var DocumentFragment = class DocumentFragment extends Node {
 	}
 	/** Element children. */
 	get children() {
-		return this.childNodes.filter((child) => child instanceof Element);
+		return childElements(this);
 	}
 	/** First element child. */
 	get firstElementChild() {
-		return this.children[0] ?? null;
+		return firstElementIn(this);
 	}
 	/** Last element child. */
 	get lastElementChild() {
-		const children = this.children;
-		return children[children.length - 1] ?? null;
+		return lastElementIn(this);
 	}
 	/** First matching descendant. */
 	querySelector(selector) {
-		return querySelectorAllFrom(this, selector, false)[0] ?? null;
+		return querySelectorFrom(this, selector);
 	}
 	/** All matching descendants. */
 	querySelectorAll(selector) {
@@ -1334,11 +1680,11 @@ var HTMLTemplateElement = class HTMLTemplateElement extends HTMLElement {
 		this.content = new DocumentFragment(ownerDocument);
 	}
 	get innerHTML() {
-		return this.content.childNodes.map(serializeNode).join("");
+		return serializeChildren(this.content);
 	}
 	set innerHTML(value) {
 		this.content.replaceChildren();
-		for (const child of parseFragment(value, this.documentForCreation(), "template").childNodes.slice()) this.content.appendChild(child);
+		parseInto(value, this.documentForCreation(), this.content);
 	}
 	get textContent() {
 		return this.content.textContent ?? "";
@@ -1379,28 +1725,28 @@ var Document = class Document extends Node {
 	}
 	/** Root element of the document. */
 	get documentElement() {
-		return this.children[0] ?? null;
+		return firstElementIn(this);
 	}
 	/** Element children. */
 	get children() {
-		return this.childNodes.filter((child) => child instanceof Element);
+		return childElements(this);
 	}
 	/** HTML body, or a detached empty body when absent like linkedom. */
 	get body() {
-		const body = this.querySelector("body");
+		const body = querySelectorFrom(this, "body");
 		return body instanceof HTMLElement ? body : this.createElement("body");
 	}
 	/** HTML head, or a detached empty head when absent. */
 	get head() {
-		const head = this.querySelector("head");
+		const head = querySelectorFrom(this, "head");
 		return head instanceof HTMLElement ? head : this.createElement("head");
 	}
 	/** Document title text. */
 	get title() {
-		return this.querySelector("title")?.textContent ?? "";
+		return querySelectorFrom(this, "title")?.textContent ?? "";
 	}
 	set title(value) {
-		let title = this.querySelector("title");
+		let title = querySelectorFrom(this, "title");
 		if (!title) {
 			title = this.createElement("title");
 			this.head.appendChild(title);
@@ -1444,12 +1790,12 @@ var Document = class Document extends Node {
 	}
 	/** Find the first element by id. */
 	getElementById(id) {
-		const element = this.querySelector(`#${cssEscapeIdentifier(id)}`);
+		const element = SELECTOR_SAFE_ID.test(id) ? findElementById(this, id) : querySelectorFrom(this, `#${cssEscapeIdentifier(id)}`);
 		return element instanceof HTMLElement ? element : null;
 	}
 	/** Find the first matching descendant. */
 	querySelector(selector) {
-		return querySelectorAllFrom(this, selector, true)[0] ?? null;
+		return querySelectorFrom(this, selector);
 	}
 	/** Find all matching descendants. */
 	querySelectorAll(selector) {
@@ -1462,7 +1808,10 @@ var Document = class Document extends Node {
 	/** Descendant elements containing all class tokens. */
 	getElementsByClassName(classNames) {
 		const tokens = classNames.trim().split(/\s+/).filter(Boolean);
-		return this.querySelectorAll("*").filter((element) => tokens.every((token) => element.classList.contains(token)));
+		return this.querySelectorAll("*").filter((element) => {
+			const className = element.className;
+			return tokens.every((token) => hasClassToken(className, token));
+		});
 	}
 	/** Adopt a node into this document. */
 	adoptNode(node) {
@@ -1581,31 +1930,98 @@ const BOOLEAN_ATTRIBUTES = {
 	reversed: true,
 	selected: true
 };
+const TEXT_ESCAPE_PATTERN = /[&\u00a0<>]/;
+/** Ids whose escaped `#id` selector parses as one plain id compound (no combinators, lists, quotes or groups). */
+const SELECTOR_SAFE_ID = /^[^\s,>+~"'[\]()\\]+$/;
 function escapeText(value) {
-	return value.replace(/&/g, "&amp;").replace(/ /g, "&#160;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	if (!TEXT_ESCAPE_PATTERN.test(value)) return value;
+	return value.replace(/&/g, "&amp;").replace(/\u00a0/g, "&#160;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function escapeAttribute(value) {
-	return value.replace(/"/g, "&quot;");
+	return value.includes("\"") ? value.replace(/"/g, "&quot;") : value;
+}
+/** Serialize a node's children; `raw` emits text data unescaped (script/style content). */
+function serializeChildren(parent, raw = false) {
+	if (!parent.hasChildNodes()) return "";
+	let html = "";
+	for (const child of parent.childNodes) html += raw && child instanceof Text ? child.data : serializeNode(child);
+	return html;
 }
 /** Serialize a DOM node as HTML. */
 function serializeNode(node) {
 	if (node instanceof Comment) return `<!--${node.data}-->`;
 	if (node instanceof Text) return node.serializeRaw ? node.data : escapeText(node.data);
-	if (node instanceof Document || node instanceof DocumentFragment) return node.childNodes.map(serializeNode).join("");
+	if (node instanceof Document || node instanceof DocumentFragment) return serializeChildren(node);
 	if (!(node instanceof Element)) return "";
-	const attributes = node.attributes.map((attr) => attr.value === "" && BOOLEAN_ATTRIBUTES[attr.name.toLowerCase()] ? ` ${attr.name}` : ` ${attr.name}="${escapeAttribute(attr.value)}"`).join("");
-	const style = node.style.cssText && !node.attributes.getNamedItem("style") ? ` style="${escapeAttribute(node.style.cssText)}"` : "";
-	const opening = `<${node.qualifiedName}${attributes}${style}>`;
+	let opening = `<${node.qualifiedName}`;
+	const hasAttributes = node.hasAttributes();
+	if (hasAttributes) for (const attr of node.attributes) opening += attr.value === "" && BOOLEAN_ATTRIBUTES[attr.name.toLowerCase()] ? ` ${attr.name}` : ` ${attr.name}="${escapeAttribute(attr.value)}"`;
+	const cssText = inlineStyleOf(node)?.cssText;
+	if (cssText && !(hasAttributes && node.attributes.getNamedItem("style"))) opening += ` style="${escapeAttribute(cssText)}"`;
+	opening += ">";
 	if (VOID_ELEMENTS[node.localName]) return opening;
 	const raw = node.localName === "script" || node.localName === "style";
-	const childNodes = node instanceof HTMLTemplateElement ? node.content.childNodes : node.childNodes;
-	return `${opening}${raw ? childNodes.map((child) => child instanceof Text ? child.data : serializeNode(child)).join("") : childNodes.map(serializeNode).join("")}</${node.qualifiedName}>`;
+	const content = serializeChildren(node instanceof HTMLTemplateElement ? node.content : node, raw);
+	return `${opening}${content}</${node.qualifiedName}>`;
+}
+function childElements(parent) {
+	return parent.hasChildNodes() ? parent.childNodes.filter((child) => child instanceof Element) : [];
+}
+function firstElementIn(parent) {
+	if (!parent.hasChildNodes()) return null;
+	for (const child of parent.childNodes) if (child instanceof Element) return child;
+	return null;
+}
+function lastElementIn(parent) {
+	if (!parent.hasChildNodes()) return null;
+	const children = parent.childNodes;
+	for (let index = children.length - 1; index >= 0; index--) {
+		const child = children[index];
+		if (child instanceof Element) return child;
+	}
+	return null;
+}
+/** First descendant element in document order whose `id` equals `id`. */
+function findElementById(parent, id) {
+	if (!parent.hasChildNodes()) return null;
+	for (const child of parent.childNodes) {
+		if (child instanceof Element && child.id === id) return child;
+		const found = findElementById(child, id);
+		if (found) return found;
+	}
+	return null;
+}
+/**
+* Concatenate descendant text iteratively, mirroring each node type's `textContent`: character data and
+* attributes contribute their value, documents nothing, templates their content fragment.
+*/
+function collectText(children) {
+	let text = "";
+	const pending = [];
+	for (let index = children.length - 1; index >= 0; index--) pending.push(children[index]);
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (node instanceof Text) {
+			text += node.data;
+			continue;
+		}
+		if (node instanceof Attr) {
+			text += node.value;
+			continue;
+		}
+		if (node instanceof Document) continue;
+		const owner = node instanceof HTMLTemplateElement ? node.content : node;
+		if (!owner.hasChildNodes()) continue;
+		const nested = owner.childNodes;
+		for (let index = nested.length - 1; index >= 0; index--) pending.push(nested[index]);
+	}
+	return text;
 }
 function cssEscapeIdentifier(value) {
 	return value.replace(/([^a-zA-Z0-9_-])/g, "\\$1");
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/node_modules/@oh-my-pi/pi-utils/src/dom.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.12.6/node_modules/@oh-my-pi/pi-utils/src/dom.ts
 /** Behavior-compatible reimplementation of linkedom's used surface. */
 /** Parse HTML or XML-like markup into a lightweight window and document. */
 function parseHTML(html) {