@linxiraos/pi-utils 1.0.0

package/src/dom/parser.ts

@@ -0,0 +1,370 @@
+import { Document, type DocumentFragment, Element, Text } from "./core";
+
+const RAW_TEXT_ELEMENTS: Record<string, true> = { script: true, style: true };
+const VOID_ELEMENTS: Record<string, true> = {
+	area: true,
+	base: true,
+	br: true,
+	col: true,
+	embed: true,
+	hr: true,
+	img: true,
+	input: true,
+	link: true,
+	meta: true,
+	param: true,
+	source: true,
+	track: true,
+	wbr: true,
+};
+const CLOSE_ON_OPEN: Record<string, readonly string[]> = {
+	li: ["li"],
+	dt: ["dt", "dd"],
+	dd: ["dt", "dd"],
+	tr: ["tr"],
+	th: ["th", "td"],
+	td: ["th", "td"],
+	option: ["option"],
+	thead: ["thead", "tbody", "tfoot"],
+	tbody: ["thead", "tbody", "tfoot"],
+	tfoot: ["thead", "tbody", "tfoot"],
+};
+const P_CLOSERS: Record<string, true> = {
+	address: true,
+	article: true,
+	aside: true,
+	blockquote: true,
+	div: true,
+	dl: true,
+	fieldset: true,
+	footer: true,
+	form: true,
+	h1: true,
+	h2: true,
+	h3: true,
+	h4: true,
+	h5: true,
+	h6: true,
+	header: true,
+	hr: true,
+	menu: true,
+	nav: true,
+	ol: true,
+	p: true,
+	pre: true,
+	section: true,
+	table: true,
+	ul: true,
+};
+
+const NAMED_ENTITIES: Record<string, string> = {
+	AElig: "Æ",
+	Aacute: "Á",
+	Acirc: "Â",
+	Agrave: "À",
+	Aring: "Å",
+	Atilde: "Ã",
+	Auml: "Ä",
+	Ccedil: "Ç",
+	ETH: "Ð",
+	Eacute: "É",
+	Ecirc: "Ê",
+	Egrave: "È",
+	Euml: "Ë",
+	Iacute: "Í",
+	Icirc: "Î",
+	Igrave: "Ì",
+	Iuml: "Ï",
+	Ntilde: "Ñ",
+	Oacute: "Ó",
+	Ocirc: "Ô",
+	Ograve: "Ò",
+	Oslash: "Ø",
+	Otilde: "Õ",
+	Ouml: "Ö",
+	THORN: "Þ",
+	Uacute: "Ú",
+	Ucirc: "Û",
+	Ugrave: "Ù",
+	Uuml: "Ü",
+	Yacute: "Ý",
+	aacute: "á",
+	acirc: "â",
+	aelig: "æ",
+	agrave: "à",
+	aring: "å",
+	atilde: "ã",
+	auml: "ä",
+	amp: "&",
+	apos: "'",
+	bull: "•",
+	brvbar: "¦",
+	ccedil: "ç",
+	cedil: "¸",
+	cent: "¢",
+	copy: "©",
+	deg: "°",
+	curren: "¤",
+	divide: "÷",
+	emsp: " ",
+	ensp: " ",
+	euro: "€",
+	eacute: "é",
+	ecirc: "ê",
+	egrave: "è",
+	eth: "ð",
+	euml: "ë",
+	frac12: "½",
+	frac14: "¼",
+	frac34: "¾",
+	gt: ">",
+	iacute: "í",
+	icirc: "î",
+	iexcl: "¡",
+	igrave: "ì",
+	iquest: "¿",
+	iuml: "ï",
+	hellip: "…",
+	laquo: "«",
+	ldquo: "“",
+	lsquo: "‘",
+	lt: "<",
+	mdash: "—",
+	macr: "¯",
+	micro: "µ",
+	middot: "·",
+	nbsp: " ",
+	ndash: "–",
+	ntilde: "ñ",
+	oacute: "ó",
+	ocirc: "ô",
+	ograve: "ò",
+	ordf: "ª",
+	ordm: "º",
+	oslash: "ø",
+	otilde: "õ",
+	ouml: "ö",
+	para: "¶",
+	pound: "£",
+	plusmn: "±",
+	quot: '"',
+	raquo: "»",
+	rdquo: "”",
+	reg: "®",
+	rsquo: "’",
+	sect: "§",
+	shy: "­",
+	szlig: "ß",
+	thorn: "þ",
+	sup1: "¹",
+	sup2: "²",
+	sup3: "³",
+	thinsp: " ",
+	times: "×",
+	trade: "™",
+	uacute: "ú",
+	ucirc: "û",
+	ugrave: "ù",
+	uml: "¨",
+	uuml: "ü",
+	yacute: "ý",
+	yuml: "ÿ",
+	yen: "¥",
+};
+
+/** Decode common named entities and all valid numeric character references. */
+export function decodeEntities(value: string): string {
+	return value.replace(/&(#(?:x[0-9a-f]+|\d+)|[a-z][a-z0-9]+);/gi, (whole, entity: string) => {
+		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);
+		if (
+			!Number.isFinite(codePoint) ||
+			codePoint <= 0 ||
+			codePoint > 0x10ffff ||
+			(codePoint >= 0xd800 && codePoint <= 0xdfff)
+		) {
+			return "�";
+		}
+		return String.fromCodePoint(codePoint);
+	});
+}
+
+function findTagEnd(html: string, start: number): number {
+	let quote = "";
+	for (let index = start; index < html.length; index++) {
+		const character = html[index];
+		if (quote) {
+			if (character === quote) quote = "";
+		} else if (character === '"' || character === "'") {
+			quote = character;
+		} else if (character === ">") {
+			return index;
+		}
+	}
+	return html.length - 1;
+}
+
+function parseStartTag(
+	source: string,
+): { name: string; attributes: Array<[string, string]>; selfClosing: boolean } | null {
+	let index = 0;
+	while (/\s/.test(source[index] ?? "")) index++;
+	const nameMatch = /^[^\s/>]+/.exec(source.slice(index));
+	if (!nameMatch) return null;
+	const name = nameMatch[0].toLowerCase();
+	index += nameMatch[0].length;
+	const attributes: Array<[string, string]> = [];
+	let selfClosing = false;
+	while (index < source.length) {
+		while (/\s/.test(source[index] ?? "")) index++;
+		if (source[index] === "/") {
+			selfClosing = true;
+			break;
+		}
+		const attributeMatch = /^[^\s=/>]+/.exec(source.slice(index));
+		if (!attributeMatch) break;
+		const attributeName = attributeMatch[0];
+		index += attributeMatch[0].length;
+		while (/\s/.test(source[index] ?? "")) index++;
+		let value = "";
+		if (source[index] === "=") {
+			index++;
+			while (/\s/.test(source[index] ?? "")) index++;
+			const quote = source[index];
+			if (quote === '"' || quote === "'") {
+				index++;
+				const end = source.indexOf(quote, index);
+				if (end < 0) {
+					value = source.slice(index);
+					index = source.length;
+				} else {
+					value = source.slice(index, end);
+					index = end + 1;
+				}
+			} else {
+				const valueMatch = /^[^\s>]+/.exec(source.slice(index));
+				value = valueMatch?.[0] ?? "";
+				index += value.length;
+			}
+		}
+		if (!attributes.some(([existing]) => existing.toLowerCase() === attributeName.toLowerCase())) {
+			attributes.push([attributeName, decodeEntities(value)]);
+		}
+	}
+	return { name, attributes, selfClosing };
+}
+
+function closeOptionalElements(stack: Element[], incoming: string): void {
+	const current = stack[stack.length - 1];
+	if (!current) return;
+	if (current.localName === "p" && P_CLOSERS[incoming]) {
+		stack.pop();
+		return;
+	}
+	const closeable = CLOSE_ON_OPEN[incoming];
+	if (closeable?.includes(current.localName)) stack.pop();
+}
+
+function parseInto(html: string, document: Document, root: Document | DocumentFragment, contextTag?: string): void {
+	const stack: Element[] = [];
+	const xmlLike = root instanceof Document && /^\s*(?:<\?xml[\s\S]*?\?>\s*)?<(?:feed|rss)\b/i.test(html);
+	let parent: Document | DocumentFragment | Element = root;
+	let index = 0;
+	while (index < html.length) {
+		if (html.startsWith("<!--", index)) {
+			const end = html.indexOf("-->", index + 4);
+			const contentEnd = end < 0 ? html.length : end;
+			parent.appendChild(document.createComment(html.slice(index + 4, contentEnd)));
+			index = end < 0 ? html.length : end + 3;
+			continue;
+		}
+		if (html[index] !== "<") {
+			const next = html.indexOf("<", index);
+			const end = next < 0 ? html.length : next;
+			parent.appendChild(new Text(decodeEntities(html.slice(index, end)), document, xmlLike));
+			index = end;
+			continue;
+		}
+		if (/^<!doctype\b/i.test(html.slice(index))) {
+			const end = html.indexOf(">", index + 2);
+			index = end < 0 ? html.length : end + 1;
+			continue;
+		}
+		if (html.startsWith("<![CDATA[", index)) {
+			const end = html.indexOf("]]>", index + 9);
+			const contentEnd = end < 0 ? html.length : end;
+			parent.appendChild(new Text(html.slice(index + 9, contentEnd), document, xmlLike));
+			index = end < 0 ? html.length : end + 3;
+			continue;
+		}
+		if (html[index + 1] === "/") {
+			const end = findTagEnd(html, index + 2);
+			const closingName = html
+				.slice(index + 2, end)
+				.trim()
+				.split(/\s/, 1)[0]
+				.toLowerCase();
+			const matchIndex = stack.findLastIndex(element => element.localName === closingName);
+			if (matchIndex >= 0) stack.length = matchIndex;
+			parent = stack[stack.length - 1] ?? root;
+			index = end + 1;
+			continue;
+		}
+		if (html[index + 1] === "!" || html[index + 1] === "?") {
+			const end = html.indexOf(">", index + 2);
+			index = end < 0 ? html.length : end + 1;
+			continue;
+		}
+		const end = findTagEnd(html, index + 1);
+		const parsed = parseStartTag(html.slice(index + 1, end));
+		if (!parsed) {
+			parent.appendChild(document.createTextNode("<"));
+			index++;
+			continue;
+		}
+		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 element = document.createElementNS(namespace, parsed.name);
+		for (let attributeIndex = parsed.attributes.length - 1; attributeIndex >= 0; attributeIndex--) {
+			const [name, value] = parsed.attributes[attributeIndex];
+			element.setAttribute(name, value);
+		}
+		parent.appendChild(element);
+		index = end + 1;
+		if (RAW_TEXT_ELEMENTS[parsed.name] && !parsed.selfClosing) {
+			const closePattern = new RegExp(`</${parsed.name}\\s*>`, "ig");
+			closePattern.lastIndex = index;
+			const match = closePattern.exec(html);
+			const rawEnd = match?.index ?? html.length;
+			element.appendChild(new Text(html.slice(index, rawEnd), document));
+			index = match ? closePattern.lastIndex : html.length;
+			continue;
+		}
+		if (!VOID_ELEMENTS[parsed.name] && !(namespace === "http://www.w3.org/2000/svg" && parsed.selfClosing)) {
+			stack.push(element);
+			parent = element;
+		}
+	}
+	void contextTag;
+}
+
+/** Parse markup into a document fragment. */
+export function parseFragment(html: string, document: Document, contextTag?: string): DocumentFragment {
+	const fragment = document.createDocumentFragment();
+	parseInto(html, document, fragment, contextTag);
+	return fragment;
+}
+
+/** Parse markup directly into a document. */
+export function parseDocument(html: string): Document {
+	const document = new Document();
+	parseInto(html, document, document);
+	return document;
+}

package/src/dom/selector.ts

@@ -0,0 +1,290 @@
+import { type Document, type DocumentFragment, Element, Node } from "./core";
+
+interface ComplexSelector {
+	simples: string[];
+	combinators: string[];
+}
+
+function splitTopLevel(value: string, delimiter: string): string[] {
+	const parts: string[] = [];
+	let start = 0;
+	let brackets = 0;
+	let parentheses = 0;
+	let quote = "";
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (quote) {
+			if (character === quote && value[index - 1] !== "\\") quote = "";
+			continue;
+		}
+		if (character === '"' || character === "'") quote = character;
+		else if (character === "[") brackets++;
+		else if (character === "]") brackets--;
+		else if (character === "(") parentheses++;
+		else if (character === ")") parentheses--;
+		else if (character === delimiter && brackets === 0 && parentheses === 0) {
+			parts.push(value.slice(start, index).trim());
+			start = index + 1;
+		}
+	}
+	parts.push(value.slice(start).trim());
+	return parts.filter(Boolean);
+}
+
+function parseComplex(selector: string): ComplexSelector {
+	const simples: string[] = [];
+	const combinators: string[] = [];
+	let current = "";
+	let brackets = 0;
+	let parentheses = 0;
+	let quote = "";
+	for (let index = 0; index < selector.length; index++) {
+		const character = selector[index];
+		if (quote) {
+			current += character;
+			if (character === quote && selector[index - 1] !== "\\") quote = "";
+			continue;
+		}
+		if (character === '"' || character === "'") {
+			quote = character;
+			current += character;
+			continue;
+		}
+		if (character === "[") brackets++;
+		else if (character === "]") brackets--;
+		else if (character === "(") parentheses++;
+		else if (character === ")") parentheses--;
+		if (brackets || parentheses) {
+			current += character;
+			continue;
+		}
+		if (character === ">" || character === "+" || character === "~") {
+			if (current.trim()) simples.push(current.trim());
+			current = "";
+			combinators.push(character);
+			while (/\s/.test(selector[index + 1] ?? "")) index++;
+			continue;
+		}
+		if (/\s/.test(character)) {
+			while (/\s/.test(selector[index + 1] ?? "")) index++;
+			const next = selector[index + 1];
+			if (current.trim()) {
+				simples.push(current.trim());
+				current = "";
+				if (next !== ">" && next !== "+" && next !== "~" && next !== undefined) combinators.push(" ");
+			}
+			continue;
+		}
+		current += character;
+	}
+	if (current.trim()) simples.push(current.trim());
+	while (combinators.length >= simples.length) combinators.pop();
+	return { simples, combinators };
+}
+
+function readIdentifier(source: string, start: number): { value: string; end: number } {
+	let value = "";
+	let index = start;
+	while (index < source.length) {
+		const character = source[index];
+		if (character === "\\" && index + 1 < source.length) {
+			value += source[index + 1];
+			index += 2;
+			continue;
+		}
+		if (!/[a-zA-Z0-9_-]/.test(character)) break;
+		value += character;
+		index++;
+	}
+	return { value, end: index };
+}
+
+function findClosing(source: string, start: number, opener: string, closer: string): number {
+	let depth = 1;
+	let quote = "";
+	for (let index = start + 1; index < source.length; index++) {
+		const character = source[index];
+		if (quote) {
+			if (character === quote && source[index - 1] !== "\\") quote = "";
+		} else if (character === '"' || character === "'") quote = character;
+		else if (character === opener) depth++;
+		else if (character === closer && --depth === 0) return index;
+	}
+	return source.length - 1;
+}
+
+function matchAttribute(element: Element, expression: string): boolean {
+	const match = /^\s*([^\s~|^$*!=]+)\s*(?:(\^=|\$=|\*=|~=|\|=|=)\s*(?:(["'])(.*?)\3|([^\s]+))\s*([isIS])?)?\s*$/.exec(
+		expression,
+	);
+	if (!match) return false;
+	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;
+	}
+}
+
+function matchNth(element: Element, expression: string): boolean {
+	const siblings = element.parentElement?.children ?? [];
+	const index = siblings.indexOf(element) + 1;
+	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);
+	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);
+}
+
+function matchPseudo(element: Element, name: string, argument: string | undefined): boolean {
+	switch (name) {
+		case "not":
+			return argument !== undefined && !matchesSelector(element, argument);
+		case "is":
+		case "where":
+			return argument !== undefined && 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 !== undefined && 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 matchSimple(element: Element, selector: string): boolean {
+	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;
+		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;
+			index = identifier.end;
+			continue;
+		}
+		if (marker === "[") {
+			const end = findClosing(selector, index, "[", "]");
+			if (!matchAttribute(element, selector.slice(index + 1, end))) return false;
+			index = end + 1;
+			continue;
+		}
+		if (marker === ":") {
+			const identifier = readIdentifier(selector, index + 1);
+			let argument: string | undefined;
+			index = identifier.end;
+			if (selector[index] === "(") {
+				const end = findClosing(selector, index, "(", ")");
+				argument = selector.slice(index + 1, end);
+				index = end + 1;
+			}
+			if (!matchPseudo(element, identifier.value.toLowerCase(), argument)) return false;
+			continue;
+		}
+		return false;
+	}
+	return true;
+}
+
+function matchComplexAt(element: Element, complex: ComplexSelector, index: number): boolean {
+	if (!matchSimple(element, complex.simples[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 === "~") {
+		for (let sibling = element.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {
+			if (matchComplexAt(sibling, complex, index - 1)) return true;
+		}
+		return false;
+	}
+	for (let ancestor = element.parentElement; ancestor; ancestor = ancestor.parentElement) {
+		if (matchComplexAt(ancestor, complex, index - 1)) return true;
+	}
+	return false;
+}
+
+/** Whether an element matches a CSS selector list. */
+export function matchesSelector(element: Element, selector: string): boolean {
+	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;
+}
+
+/** Query descendants of a node in document order. */
+export function querySelectorAllFrom(
+	root: Document | DocumentFragment | Element,
+	selector: string,
+	includeRoot: boolean,
+): Element[] {
+	const result: Element[] = [];
+	const visit = (node: Node): void => {
+		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);
+	}
+	return result;
+}

package/src/dom.ts

@@ -0,0 +1,33 @@
+/** Behavior-compatible reimplementation of linkedom's used surface. */
+
+import { DOMWindow } from "./dom/core";
+import { parseDocument } from "./dom/parser";
+
+export {
+	Attr,
+	Comment,
+	CSSStyleDeclaration,
+	CustomEvent,
+	DOMTokenList,
+	DOMWindow,
+	Document,
+	DocumentFragment,
+	Element,
+	Event,
+	EventTarget,
+	HTMLElement,
+	HTMLIFrameElement,
+	HTMLMetaElement,
+	HTMLTemplateElement,
+	NamedNodeMap,
+	Node,
+	NodeType,
+	SVGElement,
+	serializeNode,
+	Text,
+} from "./dom/core";
+
+/** Parse HTML or XML-like markup into a lightweight window and document. */
+export function parseHTML(html: string): DOMWindow {
+	return new DOMWindow(parseDocument(html));
+}