netscape-bookmark-parser 1.2.2 → 1.2.3

package/dist/index.js

@@ -1,8 +1,4186 @@
-import { DOMParser } from "@b-fuze/deno-dom";
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/build/deno-wasm/deno-wasm.js
+function prepareExports(wasmImports) {
+	const { memory, __wbindgen_export_0, __wbindgen_malloc, __wbindgen_realloc, __wbindgen_free, parse_wasm, parse_frag_wasm } = wasmImports;
+	{
+		const table = __wbindgen_export_0;
+		const offset = table.grow(4);
+		table.set(0, void 0);
+		table.set(offset + 0, void 0);
+		table.set(offset + 1, null);
+		table.set(offset + 2, true);
+		table.set(offset + 3, false);
+	}
+	let WASM_VECTOR_LEN = 0;
+	let cachedUint8ArrayMemory0 = null;
+	function getUint8ArrayMemory0() {
+		if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) cachedUint8ArrayMemory0 = new Uint8Array(memory.buffer);
+		return cachedUint8ArrayMemory0;
+	}
+	const cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
+		throw Error("TextEncoder not available");
+	} };
+	const encodeString = function(arg, view) {
+		return cachedTextEncoder.encodeInto(arg, view);
+	};
+	function passStringToWasm0(arg, malloc, realloc) {
+		if (realloc === void 0) {
+			const buf = cachedTextEncoder.encode(arg);
+			const ptr = malloc(buf.length, 1) >>> 0;
+			getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+			WASM_VECTOR_LEN = buf.length;
+			return ptr;
+		}
+		let len = arg.length;
+		let ptr = malloc(len, 1) >>> 0;
+		const mem = getUint8ArrayMemory0();
+		let offset = 0;
+		for (; offset < len; offset++) {
+			const code = arg.charCodeAt(offset);
+			if (code > 127) break;
+			mem[ptr + offset] = code;
+		}
+		if (offset !== len) {
+			if (offset !== 0) arg = arg.slice(offset);
+			ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+			const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+			const ret = encodeString(arg, view);
+			offset += ret.written;
+			ptr = realloc(ptr, len, offset, 1) >>> 0;
+		}
+		WASM_VECTOR_LEN = offset;
+		return ptr;
+	}
+	const cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", {
+		ignoreBOM: true,
+		fatal: true
+	}) : { decode: () => {
+		throw Error("TextDecoder not available");
+	} };
+	if (typeof TextDecoder !== "undefined") cachedTextDecoder.decode();
+	function getStringFromWasm0(ptr, len) {
+		ptr = ptr >>> 0;
+		return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+	}
+	/**
+	* @param {string} html
+	* @returns {string}
+	*/
+	function parse(html) {
+		let deferred2_0;
+		let deferred2_1;
+		try {
+			const ptr0 = passStringToWasm0(html, __wbindgen_malloc, __wbindgen_realloc);
+			const ret = parse_wasm(ptr0, WASM_VECTOR_LEN);
+			deferred2_0 = ret[0];
+			deferred2_1 = ret[1];
+			return getStringFromWasm0(ret[0], ret[1]);
+		} finally {
+			__wbindgen_free(deferred2_0, deferred2_1, 1);
+		}
+	}
+	/**
+	* @param {string} html
+	* @param {string} context_local_name
+	* @returns {string}
+	*/
+	function parse_frag(html, context_local_name) {
+		let deferred3_0;
+		let deferred3_1;
+		try {
+			const ptr0 = passStringToWasm0(html, __wbindgen_malloc, __wbindgen_realloc);
+			const len0 = WASM_VECTOR_LEN;
+			const ptr1 = passStringToWasm0(context_local_name, __wbindgen_malloc, __wbindgen_realloc);
+			const ret = parse_frag_wasm(ptr0, len0, ptr1, WASM_VECTOR_LEN);
+			deferred3_0 = ret[0];
+			deferred3_1 = ret[1];
+			return getStringFromWasm0(ret[0], ret[1]);
+		} finally {
+			__wbindgen_free(deferred3_0, deferred3_1, 1);
+		}
+	}
+	return {
+		parse,
+		parse_frag
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/build/deno-wasm/deno-wasm-dynamic.js
+function hasSuitableDenoVersion(version) {
+	const [major, minor] = version.split(".").map(Number);
+	return major >= 2 && minor >= 1;
+}
+const { parse: parse$1, parse_frag } = prepareExports(await (async () => {
+	let moduleImports;
+	if (typeof Deno === "object" && hasSuitableDenoVersion(Deno.version?.deno || "0.0.0")) moduleImports = await import("./deno-wasm_bg-Brhw7cJv.js");
+	else moduleImports = (await import("./deno-wasm_bg-wasm-BfK4r2Sm.js")).default;
+	const { parse, parse_frag, ...remappedImports } = moduleImports;
+	remappedImports.parse_wasm = parse;
+	remappedImports.parse_frag_wasm = parse_frag;
+	return remappedImports;
+})());
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/parser.js
+/**
+* Parser interface
+*/ let parse = (_html) => {
+	console.error("Error: deno-dom: No parser registered");
+	Deno.exit(1);
+};
+let parseFrag = (_html, _contextLocalName) => {
+	console.error("Error: deno-dom: No parser registered");
+	Deno.exit(1);
+};
+const originalParse = parse;
+function register(func, fragFunc) {
+	if (parse !== originalParse) return;
+	parse = func;
+	parseFrag = fragFunc;
+}
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/constructor-lock.js
+/**
+* Used to enforce illegal constructors
+*/ const CTOR_KEY = Symbol("CTOR_KEY");
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/html-collection.js
+const HTMLCollectionMutatorSym = Symbol("HTMLCollectionMutatorSym");
+const HTMLCollectionClass = (() => {
+	class HTMLCollection extends Array {
+		forEach(cb, thisArg) {
+			super.forEach(cb, thisArg);
+		}
+		item(index) {
+			return this[index] ?? null;
+		}
+		[HTMLCollectionMutatorSym]() {
+			return {
+				push: Array.prototype.push.bind(this),
+				splice: Array.prototype.splice.bind(this),
+				indexOf: Array.prototype.indexOf.bind(this)
+			};
+		}
+		toString() {
+			return "[object HTMLCollection]";
+		}
+	}
+	return HTMLCollection;
+})();
+for (const staticMethod of [
+	"from",
+	"isArray",
+	"of"
+]) HTMLCollectionClass[staticMethod] = void 0;
+for (const instanceMethod of [
+	"concat",
+	"copyWithin",
+	"every",
+	"fill",
+	"filter",
+	"find",
+	"findIndex",
+	"flat",
+	"flatMap",
+	"includes",
+	"indexOf",
+	"join",
+	"lastIndexOf",
+	"map",
+	"pop",
+	"push",
+	"reduce",
+	"reduceRight",
+	"reverse",
+	"shift",
+	"slice",
+	"some",
+	"sort",
+	"splice",
+	"toLocaleString",
+	"unshift",
+	"entries",
+	"forEach",
+	"keys",
+	"values"
+]) HTMLCollectionClass.prototype[instanceMethod] = void 0;
+const HTMLCollection = HTMLCollectionClass;
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/node-list.js
+const nodeListMutatorSym = Symbol("nodeListMutatorSym");
+const nodeListCachedMutator = Symbol("nodeListCachedMutator");
+const { push, splice, slice, indexOf, filter } = Array.prototype;
+var NodeListMutatorImpl = class {
+	arrayInstance;
+	elementViews;
+	constructor(arrayInstance) {
+		this.arrayInstance = arrayInstance;
+		this.elementViews = [];
+	}
+	push(...items) {
+		for (const view of this.elementViews) for (const item of items) if (item.nodeType === Node.ELEMENT_NODE) push.call(view, item);
+		return push.call(this.arrayInstance, ...items);
+	}
+	splice(index, deleteCount = 0, ...items) {
+		for (const view of this.elementViews) {
+			const toDelete = filter.call(slice.call(this.arrayInstance, index, index + deleteCount), (item) => item.nodeType === Node.ELEMENT_NODE);
+			const toInsert = items.filter((item) => item.nodeType === Node.ELEMENT_NODE);
+			let elementViewSpliceIndex = -1;
+			for (let idx = index; idx < this.arrayInstance.length; idx++) {
+				const item = this.arrayInstance[idx];
+				if (item.nodeType === Node.ELEMENT_NODE) {
+					elementViewSpliceIndex = indexOf.call(view, item);
+					break;
+				}
+			}
+			if (elementViewSpliceIndex === -1) elementViewSpliceIndex = view.length;
+			if (toDelete.length) splice.call(view, elementViewSpliceIndex, toDelete.length);
+			splice.call(view, elementViewSpliceIndex, 0, ...toInsert);
+		}
+		return splice.call(this.arrayInstance, index, deleteCount, ...items);
+	}
+	indexOf(item, fromIndex = 0) {
+		return indexOf.call(this.arrayInstance, item, fromIndex);
+	}
+	indexOfElementsView(item, fromIndex = 0) {
+		return indexOf.call(this.elementsView(), item, fromIndex);
+	}
+	elementsView() {
+		let view = this.elementViews[0];
+		if (!view) {
+			view = new HTMLCollection();
+			this.elementViews.push(view);
+			push.call(view, ...filter.call(this.arrayInstance, (item) => item.nodeType === Node.ELEMENT_NODE));
+		}
+		return view;
+	}
+};
+const NodeListClass = (() => {
+	class NodeList extends Array {
+		forEach(cb, thisArg) {
+			super.forEach(cb, thisArg);
+		}
+		item(index) {
+			return this[index] ?? null;
+		}
+		[nodeListMutatorSym]() {
+			const cachedMutator = this[nodeListCachedMutator];
+			if (cachedMutator) return cachedMutator;
+			else {
+				const cachedMutator = new NodeListMutatorImpl(this);
+				this[nodeListCachedMutator] = cachedMutator;
+				return cachedMutator;
+			}
+		}
+		toString() {
+			return "[object NodeList]";
+		}
+	}
+	return NodeList;
+})();
+for (const staticMethod of [
+	"from",
+	"isArray",
+	"of"
+]) NodeListClass[staticMethod] = void 0;
+for (const instanceMethod of [
+	"concat",
+	"copyWithin",
+	"every",
+	"fill",
+	"filter",
+	"find",
+	"findIndex",
+	"flat",
+	"flatMap",
+	"includes",
+	"indexOf",
+	"join",
+	"lastIndexOf",
+	"map",
+	"pop",
+	"push",
+	"reduce",
+	"reduceRight",
+	"reverse",
+	"shift",
+	"slice",
+	"some",
+	"sort",
+	"splice",
+	"toLocaleString",
+	"unshift"
+]) NodeListClass.prototype[instanceMethod] = void 0;
+const NodeList = NodeListClass;
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/utils-types.js
+/**
+* Ugly solution to circular imports... FIXME: Make this better
+*/ var utils_types_default = {
+	Element: null,
+	Document: null,
+	DocumentFragment: null
+};
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/utils.js
+const upperCaseCharRe = /[A-Z]/;
+const lowerCaseCharRe = /[a-z]/;
+/**
+* Convert JS property name to dataset attribute name without
+* validation
+*/ function getDatasetHtmlAttrName(name) {
+	let attributeName = "data-";
+	for (const char of name) if (upperCaseCharRe.test(char)) attributeName += "-" + char.toLowerCase();
+	else attributeName += char;
+	return attributeName;
+}
+function getDatasetJavascriptName(name) {
+	let javascriptName = "";
+	let prevChar = "";
+	for (const char of name.slice(5)) if (prevChar === "-" && lowerCaseCharRe.test(char)) {
+		javascriptName += char.toUpperCase();
+		prevChar = "";
+	} else {
+		javascriptName += prevChar;
+		prevChar = char;
+	}
+	return javascriptName + prevChar;
+}
+function getElementsByClassName(element, classNames, search) {
+	for (const child of element.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+		let matchesCount = 0;
+		for (const singleClassName of classNames) if (child.classList.contains(singleClassName)) matchesCount++;
+		if (matchesCount === classNames.length) search.push(child);
+		getElementsByClassName(child, classNames, search);
+	}
+	return search;
+}
+function getOuterHTMLOpeningTag(parentElement) {
+	return "<" + parentElement.localName + getElementAttributesString(parentElement) + ">";
+}
+const voidElements = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+/**
+* .innerHTML/.outerHTML implementation without recursion to avoid stack
+* overflows
+*/ function getOuterOrInnerHtml(parentElement, asOuterHtml) {
+	let outerHTMLOpeningTag = "";
+	let outerHTMLClosingTag = "";
+	let innerHTML = "";
+	if (asOuterHtml) {
+		outerHTMLOpeningTag = getOuterHTMLOpeningTag(parentElement);
+		outerHTMLClosingTag = `</${parentElement.localName}>`;
+		if (voidElements.has(parentElement.localName)) return outerHTMLOpeningTag;
+	}
+	const childNodeDepth = [parentElement.localName === "template" ? parentElement.content.childNodes : parentElement.childNodes];
+	const indexDepth = [0];
+	const closingTagDepth = [outerHTMLClosingTag];
+	let depth = 0;
+	depthLoop: while (depth > -1) {
+		const child = childNodeDepth[depth][indexDepth[depth]];
+		if (child) switch (child.nodeType) {
+			case NodeType.ELEMENT_NODE: {
+				innerHTML += getOuterHTMLOpeningTag(child);
+				const childLocalName = child.localName;
+				if (!voidElements.has(childLocalName)) {
+					if (childLocalName === "template") childNodeDepth.push(child.content.childNodes);
+					else childNodeDepth.push(child.childNodes);
+					indexDepth.push(0);
+					closingTagDepth.push(`</${childLocalName}>`);
+					depth++;
+					continue depthLoop;
+				}
+				break;
+			}
+			case NodeType.COMMENT_NODE:
+				innerHTML += `<!--${child.data}-->`;
+				break;
+			case NodeType.TEXT_NODE: switch (child.parentNode.localName) {
+				case "style":
+				case "script":
+				case "xmp":
+				case "iframe":
+				case "noembed":
+				case "noframes":
+				case "plaintext":
+					innerHTML += child.data;
+					break;
+				case "noscript":
+					innerHTML += child.data;
+					break;
+				default: innerHTML += child.data.replace(/&/g, "&amp;").replace(/\xA0/g, "&nbsp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+			}
+		}
+		else {
+			depth--;
+			indexDepth.pop();
+			childNodeDepth.pop();
+			innerHTML += closingTagDepth.pop();
+		}
+		indexDepth[depth]++;
+	}
+	return outerHTMLOpeningTag + innerHTML;
+}
+function getElementAttributesString(element) {
+	let out = "";
+	for (const attribute of element.getAttributeNames()) {
+		out += ` ${attribute}`;
+		out += `="${element.getAttribute(attribute).replace(/&/g, "&amp;").replace(/\xA0/g, "&nbsp;").replace(/"/g, "&quot;")}"`;
+	}
+	return out;
+}
+function insertBeforeAfter(node, nodes, before) {
+	const parentNode = node.parentNode;
+	const mutator = parentNode._getChildNodesMutator();
+	let viablePrevNextSibling = null;
+	{
+		const difference = before ? -1 : 1;
+		for (let i = mutator.indexOf(node) + difference; 0 <= i && i < parentNode.childNodes.length; i += difference) if (!nodes.includes(parentNode.childNodes[i])) {
+			viablePrevNextSibling = parentNode.childNodes[i];
+			break;
+		}
+	}
+	nodes = nodesAndTextNodes(nodes, parentNode);
+	let index;
+	if (viablePrevNextSibling) index = mutator.indexOf(viablePrevNextSibling) + (before ? 1 : 0);
+	else index = before ? 0 : parentNode.childNodes.length;
+	mutator.splice(index, 0, ...nodes);
+}
+function isDocumentFragment(node) {
+	let obj = node;
+	if (!(obj && typeof obj === "object")) return false;
+	while (true) switch (obj.constructor) {
+		case utils_types_default.DocumentFragment: return true;
+		case Node:
+		case utils_types_default.Element: return false;
+		case Object:
+		case null:
+		case void 0: return false;
+		default: obj = Reflect.getPrototypeOf(obj);
+	}
+}
+/**
+* Sets the new parent for the children via _setParent() on all
+* the child nodes and removes them from the DocumentFragment's
+* childNode list.
+*
+* A helper function for appendChild, etc. It should be called
+* _after_ the children are already pushed onto the new parent's
+* childNodes.
+*/ function moveDocumentFragmentChildren(fragment, newParent) {
+	const childCount = fragment.childNodes.length;
+	for (const child of fragment.childNodes) child._setParent(newParent);
+	fragment._getChildNodesMutator().splice(0, childCount);
+}
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/node.js
+var NodeType = /*#__PURE__*/ function(NodeType) {
+	NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+	NodeType[NodeType["ATTRIBUTE_NODE"] = 2] = "ATTRIBUTE_NODE";
+	NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
+	NodeType[NodeType["CDATA_SECTION_NODE"] = 4] = "CDATA_SECTION_NODE";
+	NodeType[NodeType["ENTITY_REFERENCE_NODE"] = 5] = "ENTITY_REFERENCE_NODE";
+	NodeType[NodeType["ENTITY_NODE"] = 6] = "ENTITY_NODE";
+	NodeType[NodeType["PROCESSING_INSTRUCTION_NODE"] = 7] = "PROCESSING_INSTRUCTION_NODE";
+	NodeType[NodeType["COMMENT_NODE"] = 8] = "COMMENT_NODE";
+	NodeType[NodeType["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
+	NodeType[NodeType["DOCUMENT_TYPE_NODE"] = 10] = "DOCUMENT_TYPE_NODE";
+	NodeType[NodeType["DOCUMENT_FRAGMENT_NODE"] = 11] = "DOCUMENT_FRAGMENT_NODE";
+	NodeType[NodeType["NOTATION_NODE"] = 12] = "NOTATION_NODE";
+	return NodeType;
+}({});
+/**
+* Throws if any of the nodes are an ancestor
+* of `parentNode`
+*/ function nodesAndTextNodes(nodes, parentNode) {
+	return nodes.flatMap((n) => {
+		if (isDocumentFragment(n)) {
+			const children = Array.from(n.childNodes);
+			moveDocumentFragmentChildren(n, parentNode);
+			return children;
+		} else {
+			const node = n instanceof Node ? n : new Text(String(n));
+			if (n === node && parentNode) parentNode._assertNotAncestor(node);
+			node._remove(true);
+			node._setParent(parentNode, true);
+			return [node];
+		}
+	});
+}
+var Node = class Node extends EventTarget {
+	nodeName;
+	nodeType;
+	#nodeValue;
+	parentNode;
+	#ownerDocument;
+	get parentElement() {
+		if (this.parentNode?.nodeType === NodeType.ELEMENT_NODE) return this.parentNode;
+		return null;
+	}
+	static ELEMENT_NODE = NodeType.ELEMENT_NODE;
+	static ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE;
+	static TEXT_NODE = NodeType.TEXT_NODE;
+	static CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE;
+	static ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE;
+	static ENTITY_NODE = NodeType.ENTITY_NODE;
+	static PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE;
+	static COMMENT_NODE = NodeType.COMMENT_NODE;
+	static DOCUMENT_NODE = NodeType.DOCUMENT_NODE;
+	static DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE;
+	static DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE;
+	static NOTATION_NODE = NodeType.NOTATION_NODE;
+	constructor(nodeName, nodeType, parentNode, key) {
+		if (key !== CTOR_KEY) throw new TypeError("Illegal constructor.");
+		super(), this.nodeName = nodeName, this.nodeType = nodeType, this.#nodeValue = null, this.parentNode = null, this.#ownerDocument = null, this.#childNodes = null;
+		this.#nodeValue = null;
+		if (parentNode) parentNode.appendChild(this);
+	}
+	#childNodes;
+	get childNodes() {
+		return this.#childNodes || (this.#childNodes = new NodeList());
+	}
+	_getChildNodesMutator() {
+		return this.childNodes[nodeListMutatorSym]();
+	}
+	_hasInitializedChildNodes() {
+		return Boolean(this.#childNodes);
+	}
+	/**
+	* Update ancestor chain & owner document for this child
+	* and all its children.
+	*/ _setParent(newParent, force = false) {
+		const sameParent = this.parentNode === newParent;
+		const shouldUpdateParentAndAncestors = !sameParent || force;
+		if (shouldUpdateParentAndAncestors) {
+			this.parentNode = newParent;
+			if (newParent) {
+				if (!sameParent) this._setOwnerDocument(newParent.#ownerDocument);
+			}
+			if (this._hasInitializedChildNodes()) for (const child of this.childNodes) child._setParent(this, shouldUpdateParentAndAncestors);
+		}
+	}
+	_assertNotAncestor(child) {
+		if (child.contains(this)) throw new DOMException("The new child is an ancestor of the parent");
+	}
+	_setOwnerDocument(document) {
+		if (this.#ownerDocument !== document) {
+			this.#ownerDocument = document;
+			if (this._hasInitializedChildNodes()) for (const child of this.childNodes) child._setOwnerDocument(document);
+		}
+	}
+	contains(child) {
+		let node = child;
+		while (node) {
+			if (node === this) return true;
+			node = node.parentNode;
+		}
+		return false;
+	}
+	get ownerDocument() {
+		return this.#ownerDocument;
+	}
+	get nodeValue() {
+		return this.#nodeValue;
+	}
+	set nodeValue(value) {}
+	get textContent() {
+		let out = "";
+		for (const child of this.childNodes) switch (child.nodeType) {
+			case NodeType.TEXT_NODE:
+				out += child.nodeValue;
+				break;
+			case NodeType.ELEMENT_NODE: out += child.textContent;
+		}
+		return out;
+	}
+	set textContent(content) {
+		for (const child of this.childNodes) child._setParent(null);
+		this._getChildNodesMutator().splice(0, this.childNodes.length);
+		this.appendChild(new Text(content));
+	}
+	get firstChild() {
+		if (!this._hasInitializedChildNodes()) return null;
+		return this.childNodes[0] || null;
+	}
+	get lastChild() {
+		if (!this._hasInitializedChildNodes()) return null;
+		return this.childNodes[this.childNodes.length - 1] || null;
+	}
+	hasChildNodes() {
+		return this._hasInitializedChildNodes() && Boolean(this.childNodes.length);
+	}
+	cloneNode(deep = false) {
+		const copy = this._shallowClone();
+		copy._setOwnerDocument(this.ownerDocument);
+		if (deep && this._hasInitializedChildNodes()) for (const child of this.childNodes) copy.appendChild(child.cloneNode(true));
+		return copy;
+	}
+	_shallowClone() {
+		throw new Error("Illegal invocation");
+	}
+	_remove(skipSetParent = false) {
+		const parent = this.parentNode;
+		if (parent) {
+			const nodeList = parent._getChildNodesMutator();
+			const idx = nodeList.indexOf(this);
+			nodeList.splice(idx, 1);
+			if (!skipSetParent) this._setParent(null);
+		}
+	}
+	appendChild(child) {
+		if (isDocumentFragment(child)) {
+			this._getChildNodesMutator().push(...child.childNodes);
+			moveDocumentFragmentChildren(child, this);
+			return child;
+		} else return child._appendTo(this);
+	}
+	_appendTo(parentNode) {
+		parentNode._assertNotAncestor(this);
+		const oldParentNode = this.parentNode;
+		if (oldParentNode === parentNode) {
+			if (parentNode._getChildNodesMutator().indexOf(this) !== -1) return this;
+		} else if (oldParentNode) this._remove();
+		this._setParent(parentNode, true);
+		parentNode._getChildNodesMutator().push(this);
+		return this;
+	}
+	removeChild(child) {
+		if (child && typeof child === "object") {
+			if (child.parentNode === this) {
+				child._remove();
+				return child;
+			} else throw new DOMException("Node.removeChild: The node to be removed is not a child of this node");
+		} else throw new TypeError("Node.removeChild: Argument 1 is not an object.");
+	}
+	replaceChild(newChild, oldChild) {
+		if (oldChild.parentNode !== this) throw new Error("Old child's parent is not the current node.");
+		oldChild._replaceWith(newChild);
+		return oldChild;
+	}
+	insertBefore(newNode, refNode) {
+		this._assertNotAncestor(newNode);
+		const mutator = this._getChildNodesMutator();
+		if (refNode === null) {
+			this.appendChild(newNode);
+			return newNode;
+		}
+		const index = mutator.indexOf(refNode);
+		if (index === -1) throw new Error("DOMException: Child to insert before is not a child of this node");
+		if (isDocumentFragment(newNode)) {
+			mutator.splice(index, 0, ...newNode.childNodes);
+			moveDocumentFragmentChildren(newNode, this);
+		} else {
+			const oldParentNode = newNode.parentNode;
+			const oldMutator = oldParentNode?._getChildNodesMutator();
+			if (oldMutator) oldMutator.splice(oldMutator.indexOf(newNode), 1);
+			newNode._setParent(this, oldParentNode !== this);
+			mutator.splice(index, 0, newNode);
+		}
+		return newNode;
+	}
+	_replaceWith(...nodes) {
+		if (this.parentNode) {
+			const parentNode = this.parentNode;
+			const mutator = parentNode._getChildNodesMutator();
+			let viableNextSibling = null;
+			{
+				const thisIndex = mutator.indexOf(this);
+				for (let i = thisIndex + 1; i < parentNode.childNodes.length; i++) if (!nodes.includes(parentNode.childNodes[i])) {
+					viableNextSibling = parentNode.childNodes[i];
+					break;
+				}
+			}
+			nodes = nodesAndTextNodes(nodes, parentNode);
+			let index = viableNextSibling ? mutator.indexOf(viableNextSibling) : parentNode.childNodes.length;
+			let deleteNumber;
+			if (parentNode.childNodes[index - 1] === this) {
+				index--;
+				deleteNumber = 1;
+			} else deleteNumber = 0;
+			mutator.splice(index, deleteNumber, ...nodes);
+			this._setParent(null);
+		}
+	}
+	get nextSibling() {
+		const parent = this.parentNode;
+		if (!parent) return null;
+		const index = parent._getChildNodesMutator().indexOf(this);
+		return parent.childNodes[index + 1] || null;
+	}
+	get previousSibling() {
+		const parent = this.parentNode;
+		if (!parent) return null;
+		const index = parent._getChildNodesMutator().indexOf(this);
+		return parent.childNodes[index - 1] || null;
+	}
+	static DOCUMENT_POSITION_DISCONNECTED = 1;
+	static DOCUMENT_POSITION_PRECEDING = 2;
+	static DOCUMENT_POSITION_FOLLOWING = 4;
+	static DOCUMENT_POSITION_CONTAINS = 8;
+	static DOCUMENT_POSITION_CONTAINED_BY = 16;
+	static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32;
+	/**
+	* FIXME: Does not implement attribute node checks
+	* ref: https://dom.spec.whatwg.org/#dom-node-comparedocumentposition
+	* MDN: https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
+	*/ compareDocumentPosition(other) {
+		if (other === this) return 0;
+		if (!(other instanceof Node)) throw new TypeError("Node.compareDocumentPosition: Argument 1 does not implement interface Node.");
+		let node1Root = other;
+		let node2Root = this;
+		const node1Hierarchy = [node1Root];
+		const node2Hierarchy = [node2Root];
+		while (node1Root.parentNode ?? node2Root.parentNode) {
+			node1Root = node1Root.parentNode ? (node1Hierarchy.push(node1Root.parentNode), node1Root.parentNode) : node1Root;
+			node2Root = node2Root.parentNode ? (node2Hierarchy.push(node2Root.parentNode), node2Root.parentNode) : node2Root;
+		}
+		if (node1Root !== node2Root) return Node.DOCUMENT_POSITION_DISCONNECTED | Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | Node.DOCUMENT_POSITION_PRECEDING;
+		const longerHierarchy = node1Hierarchy.length > node2Hierarchy.length ? node1Hierarchy : node2Hierarchy;
+		const shorterHierarchy = longerHierarchy === node1Hierarchy ? node2Hierarchy : node1Hierarchy;
+		if (longerHierarchy[longerHierarchy.length - shorterHierarchy.length] === shorterHierarchy[0]) return longerHierarchy === node1Hierarchy ? Node.DOCUMENT_POSITION_CONTAINED_BY | Node.DOCUMENT_POSITION_FOLLOWING : Node.DOCUMENT_POSITION_CONTAINS | Node.DOCUMENT_POSITION_PRECEDING;
+		const longerStart = longerHierarchy.length - shorterHierarchy.length;
+		for (let i = shorterHierarchy.length - 1; i >= 0; i--) {
+			const shorterHierarchyNode = shorterHierarchy[i];
+			const longerHierarchyNode = longerHierarchy[longerStart + i];
+			if (longerHierarchyNode !== shorterHierarchyNode) {
+				const siblings = shorterHierarchyNode.parentNode._getChildNodesMutator();
+				if (siblings.indexOf(shorterHierarchyNode) < siblings.indexOf(longerHierarchyNode)) {
+					if (shorterHierarchy === node1Hierarchy) return Node.DOCUMENT_POSITION_PRECEDING;
+					else return Node.DOCUMENT_POSITION_FOLLOWING;
+				} else if (longerHierarchy === node1Hierarchy) return Node.DOCUMENT_POSITION_PRECEDING;
+				else return Node.DOCUMENT_POSITION_FOLLOWING;
+			}
+		}
+		return Node.DOCUMENT_POSITION_FOLLOWING;
+	}
+	getRootNode(opts = {}) {
+		if (this.parentNode) return this.parentNode.getRootNode(opts);
+		if (opts.composed && this.host) return this.host.getRootNode(opts);
+		return this;
+	}
+};
+Node.prototype.ELEMENT_NODE = NodeType.ELEMENT_NODE;
+Node.prototype.ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE;
+Node.prototype.TEXT_NODE = NodeType.TEXT_NODE;
+Node.prototype.CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE;
+Node.prototype.ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE;
+Node.prototype.ENTITY_NODE = NodeType.ENTITY_NODE;
+Node.prototype.PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE;
+Node.prototype.COMMENT_NODE = NodeType.COMMENT_NODE;
+Node.prototype.DOCUMENT_NODE = NodeType.DOCUMENT_NODE;
+Node.prototype.DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE;
+Node.prototype.DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE;
+Node.prototype.NOTATION_NODE = NodeType.NOTATION_NODE;
+var CharacterData = class extends Node {
+	#nodeValue = "";
+	constructor(data, nodeName, nodeType, parentNode, key) {
+		super(nodeName, nodeType, parentNode, key);
+		this.#nodeValue = data;
+	}
+	get nodeValue() {
+		return this.#nodeValue;
+	}
+	set nodeValue(value) {
+		this.#nodeValue = String(value ?? "");
+	}
+	get data() {
+		return this.#nodeValue;
+	}
+	set data(value) {
+		this.nodeValue = value;
+	}
+	get textContent() {
+		return this.#nodeValue;
+	}
+	set textContent(value) {
+		this.nodeValue = value;
+	}
+	get length() {
+		return this.data.length;
+	}
+	before(...nodes) {
+		if (this.parentNode) insertBeforeAfter(this, nodes, true);
+	}
+	after(...nodes) {
+		if (this.parentNode) insertBeforeAfter(this, nodes, false);
+	}
+	remove() {
+		this._remove();
+	}
+	replaceWith(...nodes) {
+		this._replaceWith(...nodes);
+	}
+};
+var Text = class Text extends CharacterData {
+	constructor(text = "") {
+		super(String(text), "#text", NodeType.TEXT_NODE, null, CTOR_KEY);
+	}
+	_shallowClone() {
+		return new Text(this.textContent);
+	}
+};
+var Comment = class Comment extends CharacterData {
+	constructor(text = "") {
+		super(String(text), "#comment", NodeType.COMMENT_NODE, null, CTOR_KEY);
+	}
+	_shallowClone() {
+		return new Comment(this.textContent);
+	}
+	get textContent() {
+		return this.nodeValue;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/string-cache.js
+const upperCasedStringCache = /* @__PURE__ */ new Map();
+const lowerCasedStringCache = /* @__PURE__ */ new Map();
+function getUpperCase(string) {
+	return upperCasedStringCache.get(string) ?? upperCasedStringCache.set(string, string.toUpperCase()).get(string);
+}
+function getLowerCase(string) {
+	return lowerCasedStringCache.get(string) ?? lowerCasedStringCache.set(string, string.toLowerCase()).get(string);
+}
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/element.js
+var _computedKey;
+var _computedKey1;
+var _computedKey2;
+_computedKey = Symbol.iterator;
+var DOMTokenList = class DOMTokenList {
+	static #DOM_TOKEN_LIST_MIN_SET_SIZE = 32;
+	#_value = "";
+	get #value() {
+		return this.#_value;
+	}
+	set #value(value) {
+		this.#_value = value;
+		this.#onChange(value);
+	}
+	#set = [];
+	#onChange;
+	constructor(onChange, key) {
+		if (key !== CTOR_KEY) throw new TypeError("Illegal constructor");
+		this.#onChange = onChange;
+	}
+	static #invalidToken(token) {
+		return token === "" || /[\t\n\f\r ]/.test(token);
+	}
+	#setIndices() {
+		const classes = Array.from(this.#set);
+		for (let i = 0; i < classes.length; i++) this[i] = classes[i];
+	}
+	set value(input) {
+		this.#value = input;
+		this.#set = input.trim().split(/[\t\n\f\r\s]+/g).filter(Boolean);
+		if (this.#set.length > DOMTokenList.#DOM_TOKEN_LIST_MIN_SET_SIZE) this.#set = new Set(this.#set);
+		else {
+			const deduplicatedSet = [];
+			for (const element of this.#set) if (!deduplicatedSet.includes(element)) deduplicatedSet.push(element);
+			this.#set = deduplicatedSet;
+		}
+		this.#setIndices();
+	}
+	get value() {
+		return this.#_value;
+	}
+	get length() {
+		if (this.#set.constructor === Array) return this.#set.length;
+		else return this.#set.size;
+	}
+	*entries() {
+		const array = Array.from(this.#set);
+		for (let i = 0; i < array.length; i++) yield [i, array[i]];
+	}
+	*values() {
+		yield* this.#set.values();
+	}
+	*keys() {
+		const length = this.length;
+		for (let i = 0; i < length; i++) yield i;
+	}
+	*[_computedKey]() {
+		yield* this.#set.values();
+	}
+	item(index) {
+		index = Number(index);
+		if (Number.isNaN(index) || index === Infinity) index = 0;
+		return this[Math.trunc(index) % 2 ** 32] ?? null;
+	}
+	contains(element) {
+		if (this.#set.constructor === Array) return this.#set.includes(element);
+		else return this.#set.has(element);
+	}
+	#arrayAdd(element) {
+		const array = this.#set;
+		if (!array.includes(element)) {
+			this[array.length] = element;
+			array.push(element);
+		}
+	}
+	#setAdd(element) {
+		const set = this.#set;
+		const { size } = set;
+		set.add(element);
+		if (size < set.size) this[size] = element;
+	}
+	add(...elements) {
+		const method = (this.#set.constructor === Array ? this.#arrayAdd : this.#setAdd).bind(this);
+		for (const element of elements) {
+			if (DOMTokenList.#invalidToken(element)) throw new DOMException("Failed to execute 'add' on 'DOMTokenList': The token provided must not be empty.");
+			method(element);
+		}
+		this.#updateClassString();
+	}
+	#arrayRemove(element) {
+		const array = this.#set;
+		const index = array.indexOf(element);
+		if (index >= 0) array.splice(index, 1);
+	}
+	#setRemove(element) {
+		this.#set.delete(element);
+	}
+	remove(...elements) {
+		const method = (this.#set.constructor === Array ? this.#arrayRemove : this.#setRemove).bind(this);
+		const size = this.length;
+		for (const element of elements) {
+			if (DOMTokenList.#invalidToken(element)) throw new DOMException("Failed to execute 'remove' on 'DOMTokenList': The token provided must not be empty.");
+			method(element);
+		}
+		const newSize = this.length;
+		if (size !== newSize) {
+			for (let i = newSize; i < size; i++) delete this[i];
+			this.#setIndices();
+		}
+		this.#updateClassString();
+	}
+	replace(oldToken, newToken) {
+		const isArrayBacked = this.#set.constructor === Array;
+		const removeMethod = (isArrayBacked ? this.#arrayRemove : this.#setRemove).bind(this);
+		const addMethod = (isArrayBacked ? this.#arrayAdd : this.#setAdd).bind(this);
+		if ([oldToken, newToken].some((v) => DOMTokenList.#invalidToken(v))) throw new DOMException("Failed to execute 'replace' on 'DOMTokenList': The token provided must not be empty.");
+		if (!this.contains(oldToken)) return false;
+		if (this.contains(newToken)) this.remove(oldToken);
+		else {
+			removeMethod(oldToken);
+			addMethod(newToken);
+			this.#setIndices();
+			this.#updateClassString();
+		}
+		return true;
+	}
+	supports() {
+		throw new Error("Not implemented");
+	}
+	toggle(element, force) {
+		if (force !== void 0) {
+			const operation = force ? "add" : "remove";
+			this[operation](element);
+			return false;
+		} else {
+			const contains = this.contains(element);
+			const operation = contains ? "remove" : "add";
+			this[operation](element);
+			return !contains;
+		}
+	}
+	forEach(callback) {
+		for (const [i, value] of this.entries()) callback(value, i, this);
+	}
+	#updateClassString() {
+		this.#value = Array.from(this.#set).join(" ");
+		if (this.#set.constructor === Array && this.#set.length > DOMTokenList.#DOM_TOKEN_LIST_MIN_SET_SIZE) this.#set = new Set(this.#set);
+	}
+};
+const initializeClassListSym = Symbol("initializeClassListSym");
+const domTokenListCurrentElementSym = Symbol("domTokenListCurrentElementSym");
+_computedKey1 = Symbol.iterator;
+/**
+* The purpose of this uninitialized DOMTokenList is to consume less memory
+* than the actual DOMTokenList class. By measurements of Deno v2.1.0 (V8 13.0.245.12-rusty)
+* this class consumes 48 bytes while the smallest DOMTokenList consumes 488
+* bytes
+*/ var UninitializedDOMTokenList = class {
+	[domTokenListCurrentElementSym];
+	constructor(currentElement) {
+		this[domTokenListCurrentElementSym] = currentElement;
+	}
+	#getInitialized() {
+		const currentClassList = this[domTokenListCurrentElementSym].classList;
+		if (currentClassList === this) return null;
+		return currentClassList;
+	}
+	set value(input) {
+		this[domTokenListCurrentElementSym][initializeClassListSym]();
+		this[domTokenListCurrentElementSym].classList.value = String(input);
+	}
+	get value() {
+		return this.#getInitialized()?.value ?? "";
+	}
+	get length() {
+		return this.#getInitialized()?.length ?? 0;
+	}
+	*entries() {
+		const initialized = this.#getInitialized();
+		if (initialized) yield* initialized.entries();
+	}
+	*values() {
+		const initialized = this.#getInitialized();
+		if (initialized) yield* initialized.values();
+	}
+	*keys() {
+		const initialized = this.#getInitialized();
+		if (initialized) yield* initialized.keys();
+	}
+	*[_computedKey1]() {
+		yield* this.values();
+	}
+	item(index) {
+		return this.#getInitialized()?.item(index) ?? null;
+	}
+	contains(element) {
+		return this.#getInitialized()?.contains(element) ?? false;
+	}
+	add(...elements) {
+		this[domTokenListCurrentElementSym][initializeClassListSym]();
+		this[domTokenListCurrentElementSym].classList.add(...elements);
+	}
+	remove(...elements) {
+		this.#getInitialized()?.remove(...elements);
+	}
+	replace(oldToken, newToken) {
+		return this.#getInitialized()?.replace(oldToken, newToken) ?? false;
+	}
+	supports() {
+		throw new Error("Not implemented");
+	}
+	toggle(element, force) {
+		if (force === false) return this.#getInitialized()?.toggle(element, force) ?? false;
+		this[domTokenListCurrentElementSym][initializeClassListSym]();
+		this[domTokenListCurrentElementSym].classList.add(element);
+		return true;
+	}
+	forEach(callback) {
+		this.#getInitialized()?.forEach(callback);
+	}
+};
+const setNamedNodeMapOwnerElementSym = Symbol("setNamedNodeMapOwnerElementSym");
+const setAttrValueSym = Symbol("setAttrValueSym");
+var Attr = class Attr extends Node {
+	#namedNodeMap = null;
+	#name = "";
+	#value = "";
+	#ownerElement = null;
+	constructor(map, name, value, key) {
+		if (key !== CTOR_KEY) throw new TypeError("Illegal constructor");
+		super(name, NodeType.ATTRIBUTE_NODE, null, CTOR_KEY);
+		this.#name = name;
+		this.#value = value;
+		this.#namedNodeMap = map;
+	}
+	[setNamedNodeMapOwnerElementSym](ownerElement) {
+		this.#ownerElement = ownerElement;
+		this.#namedNodeMap = ownerElement?.attributes ?? null;
+		if (ownerElement) this._setOwnerDocument(ownerElement.ownerDocument);
+	}
+	[setAttrValueSym](value) {
+		this.#value = value;
+	}
+	_shallowClone() {
+		const newAttr = new Attr(null, this.#name, this.#value, CTOR_KEY);
+		newAttr._setOwnerDocument(this.ownerDocument);
+		return newAttr;
+	}
+	cloneNode() {
+		return super.cloneNode();
+	}
+	appendChild() {
+		throw new DOMException("Cannot add children to an Attribute");
+	}
+	replaceChild() {
+		throw new DOMException("Cannot add children to an Attribute");
+	}
+	insertBefore() {
+		throw new DOMException("Cannot add children to an Attribute");
+	}
+	removeChild() {
+		throw new DOMException("The node to be removed is not a child of this node");
+	}
+	get name() {
+		return this.#name;
+	}
+	get localName() {
+		return this.#name;
+	}
+	get value() {
+		return this.#value;
+	}
+	set value(value) {
+		this.#value = String(value);
+		if (this.#namedNodeMap) this.#namedNodeMap[setNamedNodeMapValueSym](this.#name, this.#value, true);
+	}
+	get ownerElement() {
+		return this.#ownerElement ?? null;
+	}
+	get specified() {
+		return true;
+	}
+	get prefix() {
+		return null;
+	}
+};
+const setNamedNodeMapValueSym = Symbol("setNamedNodeMapValueSym");
+const getNamedNodeMapValueSym = Symbol("getNamedNodeMapValueSym");
+const getNamedNodeMapAttrNamesSym = Symbol("getNamedNodeMapAttrNamesSym");
+const getNamedNodeMapAttrNodeSym = Symbol("getNamedNodeMapAttrNodeSym");
+const removeNamedNodeMapAttrSym = Symbol("removeNamedNodeMapAttrSym");
+_computedKey2 = Symbol.iterator;
+var NamedNodeMap = class NamedNodeMap {
+	static #indexedAttrAccess = function(map, index) {
+		if (index + 1 > this.length) return;
+		const attribute = Object.keys(map).filter((attribute) => map[attribute] !== void 0)[index]?.slice(1);
+		return this[getNamedNodeMapAttrNodeSym](attribute);
+	};
+	#onAttrNodeChange;
+	constructor(ownerElement, onAttrNodeChange, key) {
+		if (key !== CTOR_KEY) throw new TypeError("Illegal constructor.");
+		this.#ownerElement = ownerElement;
+		this.#onAttrNodeChange = onAttrNodeChange;
+		for (const attr of ownerElement.getAttributeNames()) this[setNamedNodeMapValueSym](attr, ownerElement.getAttribute(attr));
+	}
+	#attrNodeCache = {};
+	#map = {};
+	#length = 0;
+	#capacity = 0;
+	#ownerElement = null;
+	[getNamedNodeMapAttrNodeSym](attribute) {
+		const safeAttrName = "a" + attribute;
+		let attrNode = this.#attrNodeCache[safeAttrName];
+		if (!attrNode) {
+			attrNode = this.#attrNodeCache[safeAttrName] = new Attr(this, attribute, this.#map[safeAttrName], CTOR_KEY);
+			attrNode[setNamedNodeMapOwnerElementSym](this.#ownerElement);
+		}
+		return attrNode;
+	}
+	[getNamedNodeMapAttrNamesSym]() {
+		const names = [];
+		for (const [name, value] of Object.entries(this.#map)) if (value !== void 0) names.push(name.slice(1));
+		return names;
+	}
+	[getNamedNodeMapValueSym](attribute) {
+		const safeAttrName = "a" + attribute;
+		return this.#map[safeAttrName];
+	}
+	[setNamedNodeMapValueSym](attribute, value, bubble = false) {
+		const safeAttrName = "a" + attribute;
+		if (this.#map[safeAttrName] === void 0) {
+			this.#length++;
+			if (this.#length > this.#capacity) {
+				this.#capacity = this.#length;
+				const index = this.#capacity - 1;
+				Object.defineProperty(this, String(this.#capacity - 1), { get: NamedNodeMap.#indexedAttrAccess.bind(this, this.#map, index) });
+			}
+		} else if (this.#attrNodeCache[safeAttrName]) this.#attrNodeCache[safeAttrName][setAttrValueSym](value);
+		this.#map[safeAttrName] = value;
+		if (bubble) this.#onAttrNodeChange(attribute, value);
+	}
+	/**
+	* Called when an attribute is removed from
+	* an element
+	*/ [removeNamedNodeMapAttrSym](attribute) {
+		const safeAttrName = "a" + attribute;
+		if (this.#map[safeAttrName] !== void 0) {
+			this.#length--;
+			this.#map[safeAttrName] = void 0;
+			this.#onAttrNodeChange(attribute, null);
+			const attrNode = this.#attrNodeCache[safeAttrName];
+			if (attrNode) {
+				attrNode[setNamedNodeMapOwnerElementSym](null);
+				this.#attrNodeCache[safeAttrName] = void 0;
+			}
+		}
+	}
+	*[_computedKey2]() {
+		for (let i = 0; i < this.length; i++) yield this[i];
+	}
+	get length() {
+		return this.#length;
+	}
+	item(index) {
+		if (index >= this.#length) return null;
+		return this[index];
+	}
+	getNamedItem(attribute) {
+		const safeAttrName = "a" + attribute;
+		if (this.#map[safeAttrName] !== void 0) return this[getNamedNodeMapAttrNodeSym](attribute);
+		return null;
+	}
+	setNamedItem(attrNode) {
+		if (attrNode.ownerElement) throw new DOMException("Attribute already in use");
+		const safeAttrName = "a" + attrNode.name;
+		const previousAttr = this.#attrNodeCache[safeAttrName];
+		if (previousAttr) {
+			previousAttr[setNamedNodeMapOwnerElementSym](null);
+			this.#map[safeAttrName] = void 0;
+		}
+		attrNode[setNamedNodeMapOwnerElementSym](this.#ownerElement);
+		this.#attrNodeCache[safeAttrName] = attrNode;
+		this[setNamedNodeMapValueSym](attrNode.name, attrNode.value, true);
+	}
+	removeNamedItem(attribute) {
+		const safeAttrName = "a" + attribute;
+		if (this.#map[safeAttrName] !== void 0) {
+			const attrNode = this[getNamedNodeMapAttrNodeSym](attribute);
+			this[removeNamedNodeMapAttrSym](attribute);
+			return attrNode;
+		}
+		throw new DOMException("Node was not found");
+	}
+};
+const XML_NAMESTART_CHAR_RE_SRC = ":A-Za-z_" + String.raw`\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{2FF}\u{370}-\u{37D}` + String.raw`\u{37F}-\u{1FFF}\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}` + String.raw`\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}`;
+const XML_NAME_CHAR_RE_SRC = XML_NAMESTART_CHAR_RE_SRC + String.raw`\u{B7}\u{0300}-\u{036F}\u{203F}-\u{2040}0-9.-`;
+new RegExp(`[${XML_NAMESTART_CHAR_RE_SRC}]`, "u");
+const xmlNameCharRe = new RegExp(`[${XML_NAME_CHAR_RE_SRC}]`, "u");
+var Element$1 = class Element$1 extends Node {
+	#namedNodeMap = null;
+	get attributes() {
+		if (!this.#namedNodeMap) this.#namedNodeMap = new NamedNodeMap(this, (attribute, value) => {
+			const isRemoved = value === null;
+			if (value === null) value = "";
+			switch (attribute) {
+				case "class":
+					if (isRemoved) this.#hasClassNameAttribute = -1;
+					else if (this.#hasClassNameAttribute === -1) this.#hasClassNameAttribute = this.#hasIdAttribute + 1;
+					this.#currentClassName = value;
+					this.#classList.value = value;
+					break;
+				case "id":
+					if (isRemoved) this.#hasIdAttribute = -1;
+					else if (this.#hasIdAttribute === -1) this.#hasIdAttribute = this.#hasClassNameAttribute + 1;
+					this.#currentId = value;
+			}
+		}, CTOR_KEY);
+		return this.#namedNodeMap;
+	}
+	#datasetProxy = null;
+	#currentId = "";
+	#currentClassName = "";
+	#hasIdAttribute = -1;
+	#hasClassNameAttribute = -1;
+	#classListInstance = new UninitializedDOMTokenList(this);
+	get #classList() {
+		return this.#classListInstance;
+	}
+	[initializeClassListSym]() {
+		if (this.#classListInstance.constructor === DOMTokenList) return;
+		this.#classListInstance = new DOMTokenList((className) => {
+			if (this.#currentClassName !== className) {
+				this.#currentClassName = className;
+				if (this.#hasClassNameAttribute === -1) this.#hasClassNameAttribute = this.#hasIdAttribute + 1;
+				if (this.#namedNodeMap && (this.hasAttribute("class") || className !== "")) this.attributes[setNamedNodeMapValueSym]("class", className);
+			}
+		}, CTOR_KEY);
+	}
+	constructor(tagName, parentNode, attributes, key) {
+		super(tagName, NodeType.ELEMENT_NODE, parentNode, key);
+		for (const attr of attributes) this.setAttribute(attr[0], attr[1]);
+		this.nodeName = getUpperCase(tagName);
+	}
+	get tagName() {
+		return this.nodeName;
+	}
+	get localName() {
+		return getLowerCase(this.tagName);
+	}
+	_shallowClone() {
+		const attributes = [];
+		for (const attribute of this.getAttributeNames()) attributes.push([attribute, this.getAttribute(attribute)]);
+		return new Element$1(this.nodeName, null, attributes, CTOR_KEY);
+	}
+	get childElementCount() {
+		return this._getChildNodesMutator().elementsView().length;
+	}
+	get className() {
+		return this.#currentClassName;
+	}
+	set className(className) {
+		this.#classList.value = className;
+	}
+	get classList() {
+		return this.#classList;
+	}
+	get outerHTML() {
+		return getOuterOrInnerHtml(this, true);
+	}
+	set outerHTML(html) {
+		if (this.parentNode) {
+			const { parentElement, parentNode } = this;
+			let contextLocalName = parentElement?.localName;
+			switch (parentNode.nodeType) {
+				case NodeType.DOCUMENT_NODE: throw new DOMException("Modifications are not allowed for this document");
+				case NodeType.DOCUMENT_FRAGMENT_NODE: contextLocalName = "body";
+				default: {
+					const { childNodes: newChildNodes } = fragmentNodesFromString(html, contextLocalName).childNodes[0];
+					const mutator = parentNode._getChildNodesMutator();
+					const insertionIndex = mutator.indexOf(this);
+					for (let i = newChildNodes.length - 1; i >= 0; i--) {
+						const child = newChildNodes[i];
+						mutator.splice(insertionIndex, 0, child);
+						child._setParent(parentNode);
+						child._setOwnerDocument(parentNode.ownerDocument);
+					}
+					this.remove();
+				}
+			}
+		}
+	}
+	get innerHTML() {
+		return getOuterOrInnerHtml(this, false);
+	}
+	set innerHTML(html) {
+		for (const child of this.childNodes) child._setParent(null);
+		const mutator = this._getChildNodesMutator();
+		mutator.splice(0, this.childNodes.length);
+		if (html.length) {
+			const parsed = fragmentNodesFromString(html, this.localName);
+			for (const child of parsed.childNodes[0].childNodes) mutator.push(child);
+			for (const child of this.childNodes) {
+				child._setParent(this);
+				child._setOwnerDocument(this.ownerDocument);
+			}
+		}
+	}
+	get innerText() {
+		return this.textContent;
+	}
+	set innerText(text) {
+		this.textContent = text;
+	}
+	get children() {
+		return this._getChildNodesMutator().elementsView();
+	}
+	get id() {
+		return this.#currentId || "";
+	}
+	set id(id) {
+		this.setAttribute("id", id);
+	}
+	get dataset() {
+		if (this.#datasetProxy) return this.#datasetProxy;
+		this.#datasetProxy = new Proxy({}, {
+			get: (_target, property, _receiver) => {
+				if (typeof property === "string") {
+					const attributeName = getDatasetHtmlAttrName(property);
+					return this.getAttribute(attributeName) ?? void 0;
+				}
+			},
+			set: (_target, property, value, _receiver) => {
+				if (typeof property === "string") {
+					let attributeName = "data-";
+					let prevChar = "";
+					for (const char of property) {
+						if (prevChar === "-" && lowerCaseCharRe.test(char)) throw new DOMException("An invalid or illegal string was specified");
+						if (!xmlNameCharRe.test(char)) throw new DOMException("String contains an invalid character");
+						if (upperCaseCharRe.test(char)) attributeName += "-";
+						attributeName += char.toLowerCase();
+						prevChar = char;
+					}
+					this.setAttribute(attributeName, String(value));
+				}
+				return true;
+			},
+			deleteProperty: (_target, property) => {
+				if (typeof property === "string") {
+					const attributeName = getDatasetHtmlAttrName(property);
+					this.removeAttribute(attributeName);
+				}
+				return true;
+			},
+			ownKeys: (_target) => {
+				return this.getAttributeNames().flatMap((attributeName) => {
+					if (attributeName.startsWith?.("data-")) return [getDatasetJavascriptName(attributeName)];
+					else return [];
+				});
+			},
+			getOwnPropertyDescriptor: (_target, property) => {
+				if (typeof property === "string") {
+					const attributeName = getDatasetHtmlAttrName(property);
+					if (this.hasAttribute(attributeName)) return {
+						writable: true,
+						enumerable: true,
+						configurable: true
+					};
+				}
+			},
+			has: (_target, property) => {
+				if (typeof property === "string") {
+					const attributeName = getDatasetHtmlAttrName(property);
+					return this.hasAttribute(attributeName);
+				}
+				return false;
+			}
+		});
+		return this.#datasetProxy;
+	}
+	getAttributeNames() {
+		if (!this.#namedNodeMap) {
+			const attributes = [];
+			const startWithClassAttr = Number(this.#hasIdAttribute > this.#hasClassNameAttribute);
+			for (let i = 0; i < 2; i++) switch ((i + startWithClassAttr) % 2) {
+				case 0:
+					~this.#hasIdAttribute && attributes.push("id");
+					break;
+				case 1: ~this.#hasClassNameAttribute && attributes.push("class");
+			}
+			return attributes;
+		}
+		return this.attributes[getNamedNodeMapAttrNamesSym]();
+	}
+	getAttribute(rawName) {
+		const name = getLowerCase(String(rawName));
+		switch (name) {
+			case "id": if (~this.#hasIdAttribute) return this.#currentId;
+			else return null;
+			case "class": if (~this.#hasClassNameAttribute) return this.#currentClassName;
+			else return null;
+		}
+		if (!this.#namedNodeMap) return null;
+		return this.attributes[getNamedNodeMapValueSym](name) ?? null;
+	}
+	setAttribute(rawName, value) {
+		const name = getLowerCase(String(rawName));
+		const strValue = String(value);
+		let isNormalAttribute = false;
+		switch (name) {
+			case "id":
+				this.#currentId = strValue;
+				if (this.#hasIdAttribute === -1) this.#hasIdAttribute = this.#hasClassNameAttribute + 1;
+				break;
+			case "class":
+				this.#classList.value = strValue;
+				if (this.#hasClassNameAttribute === -1) this.#hasClassNameAttribute = this.#hasIdAttribute + 1;
+				break;
+			default: isNormalAttribute = true;
+		}
+		if (this.#namedNodeMap || isNormalAttribute) this.attributes[setNamedNodeMapValueSym](name, strValue);
+	}
+	removeAttribute(rawName) {
+		const name = getLowerCase(String(rawName));
+		switch (name) {
+			case "id":
+				this.#currentId = "";
+				this.#hasIdAttribute = -1;
+				break;
+			case "class":
+				this.#classList.value = "";
+				this.#hasClassNameAttribute = -1;
+		}
+		if (!this.#namedNodeMap) return;
+		this.attributes[removeNamedNodeMapAttrSym](name);
+	}
+	toggleAttribute(rawName, force) {
+		const name = getLowerCase(String(rawName));
+		if (this.hasAttribute(name)) {
+			if (force === void 0 || force === false) {
+				this.removeAttribute(name);
+				return false;
+			}
+			return true;
+		}
+		if (force === void 0 || force === true) {
+			this.setAttribute(name, "");
+			return true;
+		}
+		return false;
+	}
+	hasAttribute(rawName) {
+		const name = getLowerCase(String(rawName));
+		switch (name) {
+			case "id": return Boolean(~this.#hasIdAttribute);
+			case "class": return Boolean(~this.#hasClassNameAttribute);
+		}
+		if (!this.#namedNodeMap) return false;
+		return this.attributes[getNamedNodeMapValueSym](name) !== void 0;
+	}
+	hasAttributeNS(_namespace, rawName) {
+		const name = getLowerCase(String(rawName));
+		switch (name) {
+			case "id": return Boolean(~this.#hasIdAttribute);
+			case "class": return Boolean(~this.#hasClassNameAttribute);
+		}
+		if (!this.#namedNodeMap) return false;
+		return this.attributes[getNamedNodeMapValueSym](name) !== void 0;
+	}
+	/**
+	* https://dom.spec.whatwg.org/#concept-element-attributes-get-by-name
+	*/ getAttributeNode(rawName) {
+		const name = getLowerCase(String(rawName));
+		return this.attributes.getNamedItem(name);
+	}
+	/**
+	* https://dom.spec.whatwg.org/#concept-element-attributes-set
+	*/ setAttributeNode(attr) {
+		if (attr?.constructor !== Attr) throw new TypeError("Element.setAttributeNode: Argument 1 does not implement interface Attr");
+		const attrName = attr.localName;
+		const oldAttr = this.attributes.getNamedItem(attrName);
+		if (oldAttr === attr) return attr;
+		this.attributes.setNamedItem(attr);
+		return oldAttr;
+	}
+	replaceWith(...nodes) {
+		this._replaceWith(...nodes);
+	}
+	remove() {
+		this._remove();
+	}
+	append(...nodes) {
+		this._getChildNodesMutator().push(...nodesAndTextNodes(nodes, this));
+	}
+	prepend(...nodes) {
+		this._getChildNodesMutator().splice(0, 0, ...nodesAndTextNodes(nodes, this));
+	}
+	before(...nodes) {
+		if (this.parentNode) insertBeforeAfter(this, nodes, true);
+	}
+	after(...nodes) {
+		if (this.parentNode) insertBeforeAfter(this, nodes, false);
+	}
+	get firstElementChild() {
+		return this._getChildNodesMutator().elementsView()[0] ?? null;
+	}
+	get lastElementChild() {
+		const elements = this._getChildNodesMutator().elementsView();
+		return elements[elements.length - 1] ?? null;
+	}
+	get nextElementSibling() {
+		const parent = this.parentNode;
+		if (!parent) return null;
+		const mutator = parent._getChildNodesMutator();
+		const index = mutator.indexOfElementsView(this);
+		return mutator.elementsView()[index + 1] ?? null;
+	}
+	get previousElementSibling() {
+		const parent = this.parentNode;
+		if (!parent) return null;
+		const mutator = parent._getChildNodesMutator();
+		const index = mutator.indexOfElementsView(this);
+		return mutator.elementsView()[index - 1] ?? null;
+	}
+	querySelector(selectors) {
+		if (!this.ownerDocument) throw new Error("Element must have an owner document");
+		return this.ownerDocument._nwapi.first(selectors, this);
+	}
+	querySelectorAll(selectors) {
+		if (!this.ownerDocument) throw new Error("Element must have an owner document");
+		const nodeList = new NodeList();
+		const mutator = nodeList[nodeListMutatorSym]();
+		for (const match of this.ownerDocument._nwapi.select(selectors, this)) mutator.push(match);
+		return nodeList;
+	}
+	matches(selectorString) {
+		return this.ownerDocument._nwapi.match(selectorString, this);
+	}
+	closest(selectorString) {
+		const { match } = this.ownerDocument._nwapi;
+		let el = this;
+		do {
+			if (match(selectorString, el)) return el;
+			el = el.parentElement;
+		} while (el !== null);
+		return null;
+	}
+	getElementById(id) {
+		if (!this._hasInitializedChildNodes()) return null;
+		for (const child of this.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+			if (child.id === id) return child;
+			const search = child.getElementById(id);
+			if (search) return search;
+		}
+		return null;
+	}
+	getElementsByTagName(tagName) {
+		if (!this._hasInitializedChildNodes()) return [];
+		const fixCaseTagName = getUpperCase(tagName);
+		if (fixCaseTagName === "*") return this._getElementsByTagNameWildcard([]);
+		else return this._getElementsByTagName(fixCaseTagName, []);
+	}
+	_getElementsByTagNameWildcard(search) {
+		if (!this._hasInitializedChildNodes()) return search;
+		for (const child of this.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+			search.push(child);
+			child._getElementsByTagNameWildcard(search);
+		}
+		return search;
+	}
+	_getElementsByTagName(tagName, search) {
+		if (!this._hasInitializedChildNodes()) return search;
+		for (const child of this.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+			if (child.tagName === tagName) search.push(child);
+			child._getElementsByTagName(tagName, search);
+		}
+		return search;
+	}
+	getElementsByClassName(className) {
+		if (!this._hasInitializedChildNodes()) return [];
+		return getElementsByClassName(this, className.trim().split(/\s+/), []);
+	}
+	getElementsByTagNameNS(_namespace, localName) {
+		if (!this._hasInitializedChildNodes()) return [];
+		return this.getElementsByTagName(localName);
+	}
+};
+utils_types_default.Element = Element$1;
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/selectors/custom-api.js
+/**
+* Symbols for using getElementsByTagName/ClassName on document-fragment
+*/ const customByTagNameSym = Symbol();
+const customByClassNameSym = Symbol();
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/document-fragment.js
+var DocumentFragment$1 = class DocumentFragment$1 extends Node {
+	constructor() {
+		super("#document-fragment", NodeType.DOCUMENT_FRAGMENT_NODE, null, CTOR_KEY);
+	}
+	get childElementCount() {
+		return this._getChildNodesMutator().elementsView().length;
+	}
+	get children() {
+		return this._getChildNodesMutator().elementsView();
+	}
+	get firstElementChild() {
+		return this._getChildNodesMutator().elementsView()[0] ?? null;
+	}
+	get lastElementChild() {
+		const elements = this._getChildNodesMutator().elementsView();
+		return elements[elements.length - 1] ?? null;
+	}
+	_shallowClone() {
+		return new DocumentFragment$1();
+	}
+	append(...nodes) {
+		this._getChildNodesMutator().push(...nodesAndTextNodes(nodes, this));
+	}
+	prepend(...nodes) {
+		this._getChildNodesMutator().splice(0, 0, ...nodesAndTextNodes(nodes, this));
+	}
+	replaceChildren(...nodes) {
+		const mutator = this._getChildNodesMutator();
+		for (const child of this.childNodes) child._setParent(null);
+		mutator.splice(0, this.childNodes.length);
+		mutator.splice(0, 0, ...nodesAndTextNodes(nodes, this));
+	}
+	getElementById(id) {
+		for (const child of this.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+			if (child.id === id) return child;
+			const search = child.getElementById(id);
+			if (search) return search;
+		}
+		return null;
+	}
+	querySelector(selectors) {
+		if (!this.ownerDocument) throw new Error("DocumentFragment must have an owner document");
+		return this.ownerDocument._nwapi.first(selectors, this);
+	}
+	querySelectorAll(selectors) {
+		if (!this.ownerDocument) throw new Error("DocumentFragment must have an owner document");
+		const nodeList = new NodeList();
+		nodeList[nodeListMutatorSym]().push(...this.ownerDocument._nwapi.select(selectors, this));
+		return nodeList;
+	}
+};
+utils_types_default.DocumentFragment = DocumentFragment$1;
+function documentFragmentGetElementsByTagName(tagName) {
+	const search = [];
+	if (tagName === "*") return documentFragmentGetElementsByTagNameWildcard(this, search);
+	for (const child of this.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+		if (child.tagName === tagName) search.push(child);
+		child._getElementsByTagName(tagName, search);
+	}
+	return search;
+}
+function documentFragmentGetElementsByClassName(className) {
+	return getElementsByClassName(this, className.trim().split(/\s+/), []);
+}
+function documentFragmentGetElementsByTagNameWildcard(fragment, search) {
+	for (const child of fragment.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+		search.push(child);
+		child._getElementsByTagNameWildcard(search);
+	}
+	return search;
+}
+DocumentFragment$1.prototype[customByTagNameSym] = documentFragmentGetElementsByTagName;
+DocumentFragment$1.prototype[customByClassNameSym] = documentFragmentGetElementsByClassName;
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/elements/html-template-element.js
+var HTMLTemplateElement = class HTMLTemplateElement extends Element$1 {
+	/**
+	* This blocks access to the .#contents property when the
+	* super() constructor is running which invokes (our
+	* overridden) _setParent() method. Without it, we get
+	* the following error thrown:
+	*
+	*   TypeError: Cannot read private member #content from
+	*   an object whose class did not declare it
+	*
+	* FIXME: Maybe find a cleaner way to do this
+	*/ __contentIsSet = false;
+	#content = null;
+	constructor(parentNode, attributes, key, content) {
+		super("TEMPLATE", parentNode, attributes, key);
+		this.#content = content;
+		this.__contentIsSet = true;
+	}
+	get content() {
+		return this.#content;
+	}
+	_setOwnerDocument(document) {
+		super._setOwnerDocument(document);
+		if (this.__contentIsSet) this.content._setOwnerDocument(document);
+	}
+	_shallowClone() {
+		const frag = new DocumentFragment$1();
+		const attributes = this.getAttributeNames().map((name) => [name, this.getAttribute(name)]);
+		return new HTMLTemplateElement(null, attributes, CTOR_KEY, frag);
+	}
+	cloneNode(deep = false) {
+		const newNode = super.cloneNode(deep);
+		if (deep) {
+			const destContent = newNode.content;
+			for (const child of this.content.childNodes) destContent.appendChild(child.cloneNode(deep));
+		}
+		return newNode;
+	}
+	get innerHTML() {
+		return getOuterOrInnerHtml(this, false);
+	}
+	set innerHTML(html) {
+		const content = this.content;
+		for (const child of content.childNodes) child._setParent(null);
+		const mutator = content._getChildNodesMutator();
+		mutator.splice(0, content.childNodes.length);
+		if (html.length) {
+			const parsed = fragmentNodesFromString(html, this.localName);
+			mutator.push(...parsed.childNodes[0].childNodes);
+			for (const child of content.childNodes) {
+				child._setParent(content);
+				child._setOwnerDocument(content.ownerDocument);
+			}
+		}
+	}
+	get outerHTML() {
+		return `<template${getElementAttributesString(this)}>${this.innerHTML}</template>`;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/selectors/nwsapi.js
+var nwsapi_default = (document) => {
+	const NW = Factory({
+		document,
+		DOMException
+	}, "null");
+	NW.configure({
+		IDS_DUPES: false,
+		LOGERRORS: false
+	});
+	return NW;
+};
+function Factory(global, Export) {
+	var version = "nwsapi-2.2.0", doc = global.document, root = doc.documentElement, slice = Array.prototype.slice, WSP = "[\\x20\\t\\r\\n\\f]", CFG = {
+		operators: "[~*^$|]=|=",
+		combinators: "[\\x20\\t>+~](?=[^>+~])"
+	}, NOT = {
+		double_enc: "(?=(?:[^\"]*[\"][^\"]*[\"])*[^\"]*$)",
+		single_enc: "(?=(?:[^']*['][^']*['])*[^']*$)",
+		parens_enc: "(?![^\\x28]*\\x29)",
+		square_enc: "(?![^\\x5b]*\\x5d)"
+	}, REX = {
+		HasEscapes: RegExp("\\\\"),
+		HexNumbers: RegExp("^[0-9a-fA-F]"),
+		EscOrQuote: RegExp("^\\\\|[\\x22\\x27]"),
+		RegExpChar: RegExp("(?:(?!\\\\)[\\\\^$.*+?()[\\]{}|\\/])", "g"),
+		TrimSpaces: RegExp("[\\r\\n\\f]|^" + WSP + "+|" + WSP + "+$", "g"),
+		CommaGroup: RegExp("(\\s*,\\s*)" + NOT.square_enc + NOT.parens_enc, "g"),
+		SplitGroup: RegExp("((?:\\x28[^\\x29]*\\x29|\\[[^\\]]*\\]|\\\\.|[^,])+)", "g"),
+		FixEscapes: RegExp("\\\\([0-9a-fA-F]{1,6}" + WSP + "?|.)|([\\x22\\x27])", "g"),
+		CombineWSP: RegExp("[\\n\\r\\f\\x20]+" + NOT.single_enc + NOT.double_enc, "g"),
+		TabCharWSP: RegExp("(\\x20?\\t+\\x20?)" + NOT.single_enc + NOT.double_enc, "g"),
+		PseudosWSP: RegExp("\\s+([-+])\\s+" + NOT.square_enc, "g")
+	}, STD = {
+		combinator: RegExp("\\s?([>+~])\\s?", "g"),
+		apimethods: RegExp("^(?:[a-z]+|\\*)\\|", "i"),
+		namespaces: RegExp("(\\*|[a-z]+)\\|[-a-z]+", "i")
+	}, GROUPS = {
+		linguistic: "(dir|lang)\\x28\\s?([-\\w]{2,})\\s?(?:\\x29|$)",
+		logicalsel: "(is|where|matches|not)\\x28\\s?([^()]*|[^\\x28]*\\x28[^\\x29]*\\x29)\\s?(?:\\x29|$)",
+		treestruct: "(nth(?:-last)?(?:-child|-of-type))(?:\\x28\\s?(even|odd|(?:[-+]?\\d*)(?:n\\s?[-+]?\\s?\\d*)?)\\s?(?:\\x29|$))",
+		locationpc: "(any-link|link|visited|target)\\b",
+		useraction: "(hover|active|focus|focus-within)\\b",
+		structural: "(root|empty|(?:(?:first|last|only)(?:-child|-of-type)))\\b",
+		inputstate: "(enabled|disabled|read-only|read-write|placeholder-shown|default)\\b",
+		inputvalue: "(checked|indeterminate|required|optional|valid|invalid|in-range|out-of-range)\\b",
+		pseudo_sng: "(after|before|first-letter|first-line)\\b",
+		pseudo_dbl: ":(after|before|first-letter|first-line|selection|placeholder|-webkit-[-a-zA-Z0-9]{2,})\\b"
+	}, Patterns = {
+		treestruct: RegExp("^:(?:" + GROUPS.treestruct + ")(.*)", "i"),
+		structural: RegExp("^:(?:" + GROUPS.structural + ")(.*)", "i"),
+		linguistic: RegExp("^:(?:" + GROUPS.linguistic + ")(.*)", "i"),
+		useraction: RegExp("^:(?:" + GROUPS.useraction + ")(.*)", "i"),
+		inputstate: RegExp("^:(?:" + GROUPS.inputstate + ")(.*)", "i"),
+		inputvalue: RegExp("^:(?:" + GROUPS.inputvalue + ")(.*)", "i"),
+		locationpc: RegExp("^:(?:" + GROUPS.locationpc + ")(.*)", "i"),
+		logicalsel: RegExp("^:(?:" + GROUPS.logicalsel + ")(.*)", "i"),
+		pseudo_dbl: RegExp("^:(?:" + GROUPS.pseudo_dbl + ")(.*)", "i"),
+		pseudo_sng: RegExp("^:(?:" + GROUPS.pseudo_sng + ")(.*)", "i"),
+		children: RegExp("^" + WSP + "?\\>" + WSP + "?(.*)"),
+		adjacent: RegExp("^" + WSP + "?\\+" + WSP + "?(.*)"),
+		relative: RegExp("^" + WSP + "?\\~" + WSP + "?(.*)"),
+		ancestor: RegExp("^" + WSP + "+(.*)"),
+		universal: RegExp("^\\*(.*)"),
+		namespace: RegExp("^(\\w+|\\*)?\\|(.*)")
+	}, RTL = RegExp("^[\\u0591-\\u08ff\\ufb1d-\\ufdfd\\ufe70-\\ufefc ]+$"), qsNotArgs = "Not enough arguments", qsInvalid = " is not a valid selector", reNthElem = RegExp("(:nth(?:-last)?-child)", "i"), reNthType = RegExp("(:nth(?:-last)?-of-type)", "i"), reOptimizer, reValidator, Config = {
+		IDS_DUPES: true,
+		MIXEDCASE: true,
+		LOGERRORS: true,
+		VERBOSITY: true
+	}, NAMESPACE, QUIRKS_MODE, HTML_DOCUMENT, ATTR_STD_OPS = {
+		"=": 1,
+		"^=": 1,
+		"$=": 1,
+		"|=": 1,
+		"*=": 1,
+		"~=": 1
+	}, HTML_TABLE = {
+		"accept": 1,
+		"accept-charset": 1,
+		"align": 1,
+		"alink": 1,
+		"axis": 1,
+		"bgcolor": 1,
+		"charset": 1,
+		"checked": 1,
+		"clear": 1,
+		"codetype": 1,
+		"color": 1,
+		"compact": 1,
+		"declare": 1,
+		"defer": 1,
+		"dir": 1,
+		"direction": 1,
+		"disabled": 1,
+		"enctype": 1,
+		"face": 1,
+		"frame": 1,
+		"hreflang": 1,
+		"http-equiv": 1,
+		"lang": 1,
+		"language": 1,
+		"link": 1,
+		"media": 1,
+		"method": 1,
+		"multiple": 1,
+		"nohref": 1,
+		"noresize": 1,
+		"noshade": 1,
+		"nowrap": 1,
+		"readonly": 1,
+		"rel": 1,
+		"rev": 1,
+		"rules": 1,
+		"scope": 1,
+		"scrolling": 1,
+		"selected": 1,
+		"shape": 1,
+		"target": 1,
+		"text": 1,
+		"type": 1,
+		"valign": 1,
+		"valuetype": 1,
+		"vlink": 1
+	}, Combinators = {}, Selectors = {}, Operators = {
+		"=": {
+			p1: "^",
+			p2: "$",
+			p3: "true"
+		},
+		"^=": {
+			p1: "^",
+			p2: "",
+			p3: "true"
+		},
+		"$=": {
+			p1: "",
+			p2: "$",
+			p3: "true"
+		},
+		"*=": {
+			p1: "",
+			p2: "",
+			p3: "true"
+		},
+		"|=": {
+			p1: "^",
+			p2: "(-|$)",
+			p3: "true"
+		},
+		"~=": {
+			p1: "(^|\\s)",
+			p2: "(\\s|$)",
+			p3: "true"
+		}
+	}, concatCall = function(nodes, callback) {
+		var i = 0, l = nodes.length, list = Array(l);
+		while (l > i) {
+			if (false === callback(list[i] = nodes[i])) break;
+			++i;
+		}
+		return list;
+	}, concatList = function(list, nodes) {
+		var i = -1, l = nodes.length;
+		while (l--) list[list.length] = nodes[++i];
+		return list;
+	}, documentOrder = function(a, b) {
+		if (!hasDupes && a === b) {
+			hasDupes = true;
+			return 0;
+		}
+		return a.compareDocumentPosition(b) & 4 ? -1 : 1;
+	}, hasDupes = false, unique = function(nodes) {
+		var i = 0, j = -1, l = nodes.length + 1, list = [];
+		while (--l) {
+			if (nodes[i++] === nodes[i]) continue;
+			list[++j] = nodes[i - 1];
+		}
+		hasDupes = false;
+		return list;
+	}, hasMixedCaseTagNames = function(context) {
+		var ns, api = "getElementsByTagNameNS";
+		context = context.ownerDocument || context;
+		ns = context.documentElement.namespaceURI || "http://www.w3.org/1999/xhtml";
+		return context[api]("*", "*").length - context[api](ns, "*").length > 0;
+	}, switchContext = function(context, force) {
+		var oldDoc = doc;
+		doc = context.ownerDocument || context;
+		if (force || oldDoc !== doc) {
+			root = doc.documentElement;
+			HTML_DOCUMENT = isHTML(doc);
+			QUIRKS_MODE = HTML_DOCUMENT && doc.compatMode.indexOf("CSS") < 0;
+			NAMESPACE = root && root.namespaceURI;
+			Snapshot.doc = doc;
+			Snapshot.root = root;
+		}
+		return Snapshot.from = context;
+	}, codePointToUTF16 = function(codePoint) {
+		if (codePoint < 1 || codePoint > 1114111 || codePoint > 55295 && codePoint < 57344) return "\\ufffd";
+		if (codePoint < 65536) {
+			var lowHex = "000" + codePoint.toString(16);
+			return "\\u" + lowHex.substr(lowHex.length - 4);
+		}
+		return "\\u" + ((codePoint - 65536 >> 10) + 55296).toString(16) + "\\u" + ((codePoint - 65536) % 1024 + 56320).toString(16);
+	}, stringFromCodePoint = function(codePoint) {
+		if (codePoint < 1 || codePoint > 1114111 || codePoint > 55295 && codePoint < 57344) return "�";
+		if (codePoint < 65536) return String.fromCharCode(codePoint);
+		return String.fromCodePoint ? String.fromCodePoint(codePoint) : String.fromCharCode((codePoint - 65536 >> 10) + 55296, (codePoint - 65536) % 1024 + 56320);
+	}, convertEscapes = function(str) {
+		return REX.HasEscapes.test(str) ? str.replace(REX.FixEscapes, function(substring, p1, p2) {
+			return p2 ? "\\" + p2 : REX.HexNumbers.test(p1) ? codePointToUTF16(parseInt(p1, 16)) : REX.EscOrQuote.test(p1) ? substring : p1;
+		}) : str;
+	}, unescapeIdentifier = function(str) {
+		return REX.HasEscapes.test(str) ? str.replace(REX.FixEscapes, function(substring, p1, p2) {
+			return p2 ? p2 : REX.HexNumbers.test(p1) ? stringFromCodePoint(parseInt(p1, 16)) : REX.EscOrQuote.test(p1) ? substring : p1;
+		}) : str;
+	}, method = {
+		"#": "getElementById",
+		"*": "getElementsByTagNameNS",
+		".": "getElementsByClassName"
+	}, compat = {
+		"#": function(c, n) {
+			REX.HasEscapes.test(n) && (n = unescapeIdentifier(n));
+			return function(e, f) {
+				return byId(n, c);
+			};
+		},
+		"*": function(c, n) {
+			REX.HasEscapes.test(n) && (n = unescapeIdentifier(n));
+			return function(e, f) {
+				return byTag(n, c);
+			};
+		},
+		".": function(c, n) {
+			REX.HasEscapes.test(n) && (n = unescapeIdentifier(n));
+			return function(e, f) {
+				return byClass(n, c);
+			};
+		}
+	}, byIdRaw = function(id, context) {
+		var node = context, nodes = [], next = node.firstElementChild;
+		while (node = next) {
+			node.id == id && (nodes[nodes.length] = node);
+			if (next = node.firstElementChild || node.nextElementSibling) continue;
+			while (!next && (node = node.parentElement) && node !== context) next = node.nextElementSibling;
+		}
+		return nodes;
+	}, byId = function(id, context) {
+		var e, nodes, api = method["#"];
+		if (Config.IDS_DUPES === false) {
+			if (api in context) return (e = context[api](id)) ? [e] : none;
+		} else if ("all" in context) {
+			if (e = context.all[id]) {
+				if (e.nodeType == 1) return e.getAttribute("id") != id ? [] : [e];
+				else if (id == "length") return (e = context[api](id)) ? [e] : none;
+				for (i = 0, l = e.length, nodes = []; l > i; ++i) if (e[i].id == id) nodes[nodes.length] = e[i];
+				return nodes && nodes.length ? nodes : [nodes];
+			} else return none;
+		}
+		return byIdRaw(id, context);
+	}, byTag = function(tag, context) {
+		var e, nodes, api = method["*"];
+		if (api in context) return slice.call(context[api]("*", tag));
+		else {
+			tag = tag.toLowerCase();
+			if (e = context.firstElementChild) {
+				if (!(e.nextElementSibling || tag == "*" || e.localName == tag)) return slice.call(e[api]("*", tag));
+				else {
+					nodes = [];
+					do {
+						if (tag == "*" || e.localName == tag) nodes[nodes.length] = e;
+						concatList(nodes, e[api]("*", tag));
+					} while (e = e.nextElementSibling);
+				}
+			} else nodes = none;
+		}
+		return nodes;
+	}, byClass = function(cls, context) {
+		var e, nodes, api = method["."], reCls;
+		if (api in context) return slice.call(context[api](cls));
+		else if (e = context.firstElementChild) {
+			reCls = RegExp("(^|\\s)" + cls + "(\\s|$)", QUIRKS_MODE ? "i" : "");
+			if (!(e.nextElementSibling || reCls.test(e.className))) return slice.call(e[api](cls));
+			else {
+				nodes = [];
+				do {
+					if (reCls.test(e.className)) nodes[nodes.length] = e;
+					concatList(nodes, e[api](cls));
+				} while (e = e.nextElementSibling);
+			}
+		} else nodes = none;
+		return nodes;
+	}, hasAttributeNS = function(e, name) {
+		var i, l, attr = e.getAttributeNames();
+		name = RegExp(":?" + name + "$", HTML_DOCUMENT ? "i" : "");
+		for (i = 0, l = attr.length; l > i; ++i) if (name.test(attr[i])) return true;
+		return false;
+	}, nthElement = (function() {
+		var idx = 0, len = 0, set = 0, parent = void 0, parents = Array(), nodes = Array();
+		return function(element, dir) {
+			if (dir == 2) {
+				idx = 0;
+				len = 0;
+				set = 0;
+				nodes.length = 0;
+				parents.length = 0;
+				parent = void 0;
+				return -1;
+			}
+			var e, i, j, k, l;
+			if (parent === element.parentElement) {
+				i = set;
+				j = idx;
+				l = len;
+			} else {
+				l = parents.length;
+				parent = element.parentElement;
+				for (i = -1, j = 0, k = l - 1; l > j; ++j, --k) {
+					if (parents[j] === parent) {
+						i = j;
+						break;
+					}
+					if (parents[k] === parent) {
+						i = k;
+						break;
+					}
+				}
+				if (i < 0) {
+					parents[i = l] = parent;
+					l = 0;
+					nodes[i] = Array();
+					e = parent && parent.firstElementChild || element;
+					while (e) {
+						nodes[i][l] = e;
+						if (e === element) j = l;
+						e = e.nextElementSibling;
+						++l;
+					}
+					set = i;
+					idx = 0;
+					len = l;
+					if (l < 2) return l;
+				} else {
+					l = nodes[i].length;
+					set = i;
+				}
+			}
+			if (element !== nodes[i][j] && element !== nodes[i][j = 0]) for (j = 0, e = nodes[i], k = l - 1; l > j; ++j, --k) {
+				if (e[j] === element) break;
+				if (e[k] === element) {
+					j = k;
+					break;
+				}
+			}
+			idx = j + 1;
+			len = l;
+			return dir ? l - j : idx;
+		};
+	})(), nthOfType = (function() {
+		var idx = 0, len = 0, set = 0, parent = void 0, parents = Array(), nodes = Array();
+		return function(element, dir) {
+			if (dir == 2) {
+				idx = 0;
+				len = 0;
+				set = 0;
+				nodes.length = 0;
+				parents.length = 0;
+				parent = void 0;
+				return -1;
+			}
+			var e, i, j, k, l, name = element.localName;
+			if (nodes[set] && nodes[set][name] && parent === element.parentElement) {
+				i = set;
+				j = idx;
+				l = len;
+			} else {
+				l = parents.length;
+				parent = element.parentElement;
+				for (i = -1, j = 0, k = l - 1; l > j; ++j, --k) {
+					if (parents[j] === parent) {
+						i = j;
+						break;
+					}
+					if (parents[k] === parent) {
+						i = k;
+						break;
+					}
+				}
+				if (i < 0 || !nodes[i][name]) {
+					parents[i = l] = parent;
+					nodes[i] || (nodes[i] = Object());
+					l = 0;
+					nodes[i][name] = Array();
+					e = parent && parent.firstElementChild || element;
+					while (e) {
+						if (e === element) j = l;
+						if (e.localName == name) {
+							nodes[i][name][l] = e;
+							++l;
+						}
+						e = e.nextElementSibling;
+					}
+					set = i;
+					idx = j;
+					len = l;
+					if (l < 2) return l;
+				} else {
+					l = nodes[i][name].length;
+					set = i;
+				}
+			}
+			if (element !== nodes[i][name][j] && element !== nodes[i][name][j = 0]) for (j = 0, e = nodes[i][name], k = l - 1; l > j; ++j, --k) {
+				if (e[j] === element) break;
+				if (e[k] === element) {
+					j = k;
+					break;
+				}
+			}
+			idx = j + 1;
+			len = l;
+			return dir ? l - j : idx;
+		};
+	})(), isHTML = function(node) {
+		var doc = node.ownerDocument || node;
+		return doc.nodeType == 9 && "contentType" in doc ? doc.contentType.indexOf("/html") > 0 : doc.createElement("DiV").localName == "div";
+	}, configure = function(option, clear) {
+		if (typeof option == "string") return !!Config[option];
+		if (typeof option != "object") return Config;
+		for (var i in option) Config[i] = !!option[i];
+		if (clear) {
+			matchResolvers = {};
+			selectResolvers = {};
+		}
+		setIdentifierSyntax();
+		return true;
+	}, emit = function(message, proto) {
+		var err;
+		if (Config.VERBOSITY) {
+			if (proto) err = new proto(message);
+			else err = new global.DOMException(message, "SyntaxError");
+			throw err;
+		}
+		if (Config.LOGERRORS && console && console.log) console.log(message);
+	}, initialize = function(doc) {
+		setIdentifierSyntax();
+		lastContext = switchContext(doc, true);
+	}, setIdentifierSyntax = function() {
+		var identifier = "(?=[^0-9])(?:-{2}|[a-zA-Z0-9-_]|[^\\x00-\\x9f]|\\\\[^\\r\\n\\f0-9a-fA-F]|\\\\[0-9a-fA-F]{1,6}(?:\\r\\n|\\s)?|\\\\.)+", pseudonames = "[-\\w]+", pseudoparms = "(?:[-+]?\\d*)(?:n\\s?[-+]?\\s?\\d*)", attrparser = identifier + "|\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*(?:\"|$)|'[^'\\\\]*(?:\\\\.[^'\\\\]*)*(?:'|$)", attrvalues = "([\\x22\\x27]?)((?!\\3)*|(?:\\\\?.)*?)(?:\\3|$)", attributes = "\\[(?:\\*\\|)?" + WSP + "?(" + identifier + "(?::" + identifier + ")?)" + WSP + "?(?:(" + CFG.operators + ")" + WSP + "?(?:" + attrparser + "))?" + WSP + "?(i)?" + WSP + "?(?:\\]|$)", attrmatcher = attributes.replace(attrparser, attrvalues), pseudoclass = "(?:\\x28" + WSP + "*(?:" + pseudoparms + "?)?|(?:\\*|\\|)|(?:(?::" + pseudonames + "(?:\\x28" + pseudoparms + "?(?:\\x29|$))?|)|(?:[.#]?" + identifier + ")|(?:" + attributes + "))+|(?:" + WSP + "?," + WSP + "?)|(?:" + WSP + "?)|(?:\\x29|$))*", standardValidator = "(?=" + WSP + "?[^>+~(){}<>])(?:(?:\\*|\\|)|(?:[.#]?" + identifier + ")+|(?:" + attributes + ")+|(?:::?" + pseudonames + pseudoclass + ")|(?:" + WSP + "?" + CFG.combinators + WSP + "?)|(?:" + WSP + "?," + WSP + "?)|(?:" + WSP + "?))+";
+		reOptimizer = RegExp("(?:([.:#*]?)(" + identifier + ")(?::[-\\w]+|\\[[^\\]]+(?:\\]|$)|\\x28[^\\x29]+(?:\\x29|$))*)$");
+		reValidator = RegExp(standardValidator, "g");
+		Patterns.id = RegExp("^#(" + identifier + ")(.*)");
+		Patterns.tagName = RegExp("^(" + identifier + ")(.*)");
+		Patterns.className = RegExp("^\\.(" + identifier + ")(.*)");
+		Patterns.attribute = RegExp("^(?:" + attrmatcher + ")(.*)");
+	}, F_INIT = "\"use strict\";return function Resolver(c,f,x,r)", S_HEAD = "var e,n,o,j=r.length-1,k=-1", M_HEAD = "var e,n,o", S_LOOP = "main:while((e=c[++k]))", N_LOOP = "main:while((e=c.item(++k)))", M_LOOP = "e=c;", S_BODY = "r[++j]=c[k];", N_BODY = "r[++j]=c.item(k);", M_BODY = "", S_TAIL = "continue main;", M_TAIL = "r=true;", S_TEST = "if(f(c[k])){break main;}", N_TEST = "if(f(c.item(k))){break main;}", M_TEST = "f(c);", S_VARS = [], M_VARS = [], compile = function(selector, mode, callback) {
+		var factory, head = "", loop = "", macro = "", source = "", vars = "";
+		switch (mode) {
+			case true:
+				if (selectLambdas[selector]) return selectLambdas[selector];
+				macro = S_BODY + (callback ? S_TEST : "") + S_TAIL;
+				head = S_HEAD;
+				loop = S_LOOP;
+				break;
+			case false:
+				if (matchLambdas[selector]) return matchLambdas[selector];
+				macro = M_BODY + (callback ? M_TEST : "") + M_TAIL;
+				head = M_HEAD;
+				loop = M_LOOP;
+				break;
+			case null:
+				if (selectLambdas[selector]) return selectLambdas[selector];
+				macro = N_BODY + (callback ? N_TEST : "") + S_TAIL;
+				head = S_HEAD;
+				loop = N_LOOP;
+		}
+		source = compileSelector(selector, macro, mode, callback, false);
+		loop += mode || mode === null ? "{" + source + "}" : source;
+		if (mode || mode === null && selector.includes(":nth")) {
+			loop += reNthElem.test(selector) ? "s.nthElement(null, 2);" : "";
+			loop += reNthType.test(selector) ? "s.nthOfType(null, 2);" : "";
+		}
+		if (S_VARS[0] || M_VARS[0]) {
+			vars = "," + (S_VARS.join(",") || M_VARS.join(","));
+			S_VARS.length = 0;
+			M_VARS.length = 0;
+		}
+		factory = Function("s", F_INIT + "{" + head + vars + ";" + loop + "return r;}")(Snapshot);
+		return mode || mode === null ? selectLambdas[selector] = factory : matchLambdas[selector] = factory;
+	}, compileSelector = function(expression, source, mode, callback, not) {
+		var a, b, n, f, name, NS, N = not ? "!" : "", D = not ? "" : "!", compat, expr, match, result, status, symbol, test, type, selector = expression, selector_string = mode ? lastSelected : lastMatched, vars;
+		selector = selector.replace(STD.combinator, "$1");
+		while (selector) {
+			symbol = STD.apimethods.test(selector) ? "|" : selector[0];
+			switch (symbol) {
+				case "*":
+					match = selector.match(Patterns.universal);
+					if (N == "!") source = "if(" + N + "true){" + source + "}";
+					break;
+				case "#":
+					match = selector.match(Patterns.id);
+					source = "if(" + N + "(/^" + match[1] + "$/.test(e.getAttribute(\"id\")))){" + source + "}";
+					break;
+				case ".":
+					match = selector.match(Patterns.className);
+					compat = (QUIRKS_MODE ? "i" : "") + ".test(e.getAttribute(\"class\"))";
+					source = "if(" + N + "(/(^|\\s)" + match[1] + "(\\s|$)/" + compat + ")){" + source + "}";
+					break;
+				case /[_a-z]/i.test(symbol) ? symbol : void 0:
+					match = selector.match(Patterns.tagName);
+					source = "if(" + N + "(e.localName" + (Config.MIXEDCASE || hasMixedCaseTagNames(doc) ? "==\"" + match[1].toLowerCase() + "\"" : "==\"" + match[1].toUpperCase() + "\"") + ")){" + source + "}";
+					break;
+				case "|":
+					match = selector.match(Patterns.namespace);
+					if (match[1] == "*") source = "if(" + N + "true){" + source + "}";
+					else if (!match[1]) source = "if(" + N + "(!e.namespaceURI)){" + source + "}";
+					else if (typeof match[1] == "string" && root.prefix == match[1]) source = "if(" + N + "(e.namespaceURI==\"" + NAMESPACE + "\")){" + source + "}";
+					else emit("'" + selector_string + "'" + qsInvalid);
+					break;
+				case "[":
+					match = selector.match(Patterns.attribute);
+					NS = match[0].match(STD.namespaces);
+					name = match[1];
+					expr = name.split(":");
+					expr = expr.length == 2 ? expr[1] : expr[0];
+					if (match[2] && !(test = Operators[match[2]])) {
+						emit("'" + selector_string + "'" + qsInvalid);
+						return "";
+					}
+					if (match[4] === "") test = match[2] == "~=" ? {
+						p1: "^\\s",
+						p2: "+$",
+						p3: "true"
+					} : match[2] in ATTR_STD_OPS && match[2] != "~=" ? {
+						p1: "^",
+						p2: "$",
+						p3: "true"
+					} : test;
+					else if (match[2] == "~=" && match[4].includes(" ")) {
+						source = "if(" + N + "false){" + source + "}";
+						break;
+					} else if (match[4]) match[4] = convertEscapes(match[4]).replace(REX.RegExpChar, "\\$&");
+					type = match[5] == "i" || HTML_DOCUMENT && HTML_TABLE[expr.toLowerCase()] ? "i" : "";
+					source = "if(" + N + "(" + (!match[2] ? NS ? "s.hasAttributeNS(e,\"" + name + "\")" : "e.hasAttribute&&e.hasAttribute(\"" + name + "\")" : !match[4] && ATTR_STD_OPS[match[2]] && match[2] != "~=" ? "e.getAttribute&&e.getAttribute(\"" + name + "\")==\"\"" : "(/" + test.p1 + match[4] + test.p2 + "/" + type + ").test(e.getAttribute&&e.getAttribute(\"" + name + "\"))==" + test.p3) + ")){" + source + "}";
+					break;
+				case "~":
+					match = selector.match(Patterns.relative);
+					source = "n=e;while((e=e.previousElementSibling)){" + source + "}e=n;";
+					break;
+				case "+":
+					match = selector.match(Patterns.adjacent);
+					source = "n=e;if((e=e.previousElementSibling)){" + source + "}e=n;";
+					break;
+				case "	":
+				case " ":
+					match = selector.match(Patterns.ancestor);
+					source = "n=e;while((e=e.parentElement)){" + source + "}e=n;";
+					break;
+				case ">":
+					match = selector.match(Patterns.children);
+					source = "n=e;if((e=e.parentElement)){" + source + "}e=n;";
+					break;
+				case symbol in Combinators ? symbol : void 0:
+					match[match.length - 1] = "*";
+					source = Combinators[symbol](match) + source;
+					break;
+				case ":":
+					if (match = selector.match(Patterns.structural)) {
+						match[1] = match[1].toLowerCase();
+						switch (match[1]) {
+							case "root":
+								source = "if(" + N + "(e===s.root)){" + source + (mode ? "break main;" : "") + "}";
+								break;
+							case "empty":
+								source = "n=e.firstChild;while(n&&!(/1|3/).test(n.nodeType)){n=n.nextSibling}if(" + D + "n){" + source + "}";
+								break;
+							case "only-child":
+								source = "if(" + N + "(!e.nextElementSibling&&!e.previousElementSibling)){" + source + "}";
+								break;
+							case "last-child":
+								source = "if(" + N + "(!e.nextElementSibling)){" + source + "}";
+								break;
+							case "first-child":
+								source = "if(" + N + "(!e.previousElementSibling)){" + source + "}";
+								break;
+							case "only-of-type":
+								source = "o=e.localName;n=e;while((n=n.nextElementSibling)&&n.localName!=o);if(!n){n=e;while((n=n.previousElementSibling)&&n.localName!=o);}if(" + D + "n){" + source + "}";
+								break;
+							case "last-of-type":
+								source = "n=e;o=e.localName;while((n=n.nextElementSibling)&&n.localName!=o);if(" + D + "n){" + source + "}";
+								break;
+							case "first-of-type":
+								source = "n=e;o=e.localName;while((n=n.previousElementSibling)&&n.localName!=o);if(" + D + "n){" + source + "}";
+								break;
+							default: emit("'" + selector_string + "'" + qsInvalid);
+						}
+					} else if (match = selector.match(Patterns.treestruct)) {
+						match[1] = match[1].toLowerCase();
+						switch (match[1]) {
+							case "nth-child":
+							case "nth-of-type":
+							case "nth-last-child":
+							case "nth-last-of-type":
+								expr = /-of-type/i.test(match[1]);
+								if (match[1] && match[2]) {
+									type = /last/i.test(match[1]);
+									if (match[2] == "n") {
+										source = "if(" + N + "true){" + source + "}";
+										break;
+									} else if (match[2] == "1") {
+										test = type ? "next" : "previous";
+										source = expr ? "n=e;o=e.localName;while((n=n." + test + "ElementSibling)&&n.localName!=o);if(" + D + "n){" + source + "}" : "if(" + N + "!e." + test + "ElementSibling){" + source + "}";
+										break;
+									} else if (match[2] == "even" || match[2] == "2n0" || match[2] == "2n+0" || match[2] == "2n") test = "n%2==0";
+									else if (match[2] == "odd" || match[2] == "2n1" || match[2] == "2n+1") test = "n%2==1";
+									else {
+										f = /n/i.test(match[2]);
+										n = match[2].split("n");
+										a = parseInt(n[0], 10) || 0;
+										b = parseInt(n[1], 10) || 0;
+										if (n[0] == "-") a = -1;
+										if (n[0] == "+") a = 1;
+										test = (b ? "(n" + (b > 0 ? "-" : "+") + Math.abs(b) + ")" : "n") + "%" + a + "==0";
+										test = a >= 1 ? f ? "n>" + (b - 1) + (Math.abs(a) != 1 ? "&&" + test : "") : "n==" + a : a <= -1 ? f ? "n<" + (b + 1) + (Math.abs(a) != 1 ? "&&" + test : "") : "n==" + a : a === 0 ? n[0] ? "n==" + b : "n>" + (b - 1) : "false";
+									}
+									expr = expr ? "OfType" : "Element";
+									type = type ? "true" : "false";
+									source = "n=s.nth" + expr + "(e," + type + ");if(" + N + "(" + test + ")){" + source + "}";
+								} else emit("'" + selector_string + "'" + qsInvalid);
+								break;
+							default: emit("'" + selector_string + "'" + qsInvalid);
+						}
+					} else if (match = selector.match(Patterns.logicalsel)) {
+						match[1] = match[1].toLowerCase();
+						switch (match[1]) {
+							case "is":
+							case "where":
+							case "matches":
+								expr = match[2].replace(REX.CommaGroup, ",").replace(REX.TrimSpaces, "");
+								source = "if(s.match(\"" + expr.replace(/\x22/g, "\\\"") + "\",e)){" + source + "}";
+								break;
+							case "not":
+								expr = match[2].replace(REX.CommaGroup, ",").replace(REX.TrimSpaces, "");
+								source = "if(!s.match(\"" + expr.replace(/\x22/g, "\\\"") + "\",e)){" + source + "}";
+								break;
+							default: emit("'" + selector_string + "'" + qsInvalid);
+						}
+					} else if (match = selector.match(Patterns.linguistic)) {
+						match[1] = match[1].toLowerCase();
+						switch (match[1]) {
+							case "dir":
+								source = "var p;if(" + N + "((/" + match[2] + "/i.test(e.dir))||(p=s.ancestor(\"[dir]\", e))&&(/" + match[2] + "/i.test(p.dir))||(e.dir==\"\"||e.dir==\"auto\")&&(" + (match[2] == "ltr" ? "!" : "") + RTL + ".test(e.textContent)))){" + source + "};";
+								break;
+							case "lang":
+								expr = "(?:^|-)" + match[2] + "(?:-|$)";
+								source = "var p;if(" + N + "((e.isConnected&&(e.lang==\"\"&&(p=s.ancestor(\"[lang]\",e)))&&(p.lang==\"" + match[2] + "\")||/" + expr + "/i.test(e.lang)))){" + source + "};";
+								break;
+							default: emit("'" + selector_string + "'" + qsInvalid);
+						}
+					} else if (match = selector.match(Patterns.locationpc)) {
+						match[1] = match[1].toLowerCase();
+						switch (match[1]) {
+							case "any-link":
+								source = "if(" + N + "(/^a|area$/i.test(e.localName)&&e.hasAttribute(\"href\")||e.visited)){" + source + "}";
+								break;
+							case "link":
+								source = "if(" + N + "(/^a|area$/i.test(e.localName)&&e.hasAttribute(\"href\"))){" + source + "}";
+								break;
+							case "visited":
+								source = "if(" + N + "(/^a|area$/i.test(e.localName)&&e.hasAttribute(\"href\")&&e.visited)){" + source + "}";
+								break;
+							case "target":
+								source = "if(" + N + "((s.doc.compareDocumentPosition(e)&16)&&s.doc.location.hash&&e.id==s.doc.location.hash.slice(1))){" + source + "}";
+								break;
+							default: emit("'" + selector_string + "'" + qsInvalid);
+						}
+					} else if (match = selector.match(Patterns.useraction)) {
+						match[1] = match[1].toLowerCase();
+						switch (match[1]) {
+							case "hover":
+								source = "hasFocus" in doc && doc.hasFocus() ? "if(" + N + "(e===s.doc.hoverElement)){" + source + "}" : "if(" + D + "true){" + source + "}";
+								break;
+							case "active":
+								source = "hasFocus" in doc && doc.hasFocus() ? "if(" + N + "(e===s.doc.activeElement)){" + source + "}" : "if(" + D + "true){" + source + "}";
+								break;
+							case "focus":
+								source = "hasFocus" in doc ? "if(" + N + "(e===s.doc.activeElement&&s.doc.hasFocus()&&(e.type||e.href||typeof e.tabIndex==\"number\"))){" + source + "}" : "if(" + N + "(e===s.doc.activeElement&&(e.type||e.href))){" + source + "}";
+								break;
+							case "focus-within":
+								source = "hasFocus" in doc ? "n=s.doc.activeElement;while(e){if(e===n||e.parentNode===n)break;}if(" + N + "(e===n&&s.doc.hasFocus()&&(e.type||e.href||typeof e.tabIndex==\"number\"))){" + source + "}" : source;
+								break;
+							default: emit("'" + selector_string + "'" + qsInvalid);
+						}
+					} else if (match = selector.match(Patterns.inputstate)) {
+						match[1] = match[1].toLowerCase();
+						switch (match[1]) {
+							case "enabled":
+								source = "if(" + N + "((\"form\" in e||/^optgroup$/i.test(e.localName))&&\"disabled\" in e &&e.disabled===false)){" + source + "}";
+								break;
+							case "disabled":
+								source = "if(" + N + "((\"form\" in e||/^optgroup$/i.test(e.localName))&&\"disabled\" in e&&(e.disabled===true||(n=s.ancestor(\"fieldset\",e))&&(n=s.first(\"legend\",n))&&!n.contains(e)))){" + source + "}";
+								break;
+							case "read-only":
+								source = "if(" + N + "((/^textarea$/i.test(e.localName)&&(e.readOnly||e.disabled))||(\"|password|text|\".includes(\"|\"+e.type+\"|\")&&e.readOnly))){" + source + "}";
+								break;
+							case "read-write":
+								source = "if(" + N + "(((/^textarea$/i.test(e.localName)&&!e.readOnly&&!e.disabled)||(\"|password|text|\".includes(\"|\"+e.type+\"|\")&&!e.readOnly&&!e.disabled))||(e.hasAttribute(\"contenteditable\")||(s.doc.designMode==\"on\")))){" + source + "}";
+								break;
+							case "placeholder-shown":
+								source = "if(" + N + "((/^input|textarea$/i.test(e.localName))&&e.hasAttribute(\"placeholder\")&&(\"|textarea|password|number|search|email|text|tel|url|\".includes(\"|\"+e.type+\"|\"))&&(!s.match(\":focus\",e)))){" + source + "}";
+								break;
+							case "default":
+								source = "if(" + N + "(\"form\" in e && e.form)){var x=0;n=[];if(e.type==\"image\")n=e.form.getElementsByTagName(\"input\");if(e.type==\"submit\")n=e.form.elements;while(n[x]&&e!==n[x]){if(n[x].type==\"image\")break;if(n[x].type==\"submit\")break;x++;}}if(" + N + "(e.form&&(e===n[x]&&\"|image|submit|\".includes(\"|\"+e.type+\"|\"))||((/^option$/i.test(e.localName))&&e.defaultSelected)||((\"|radio|checkbox|\".includes(\"|\"+e.type+\"|\"))&&e.defaultChecked))){" + source + "}";
+								break;
+							default: emit("'" + selector_string + "'" + qsInvalid);
+						}
+					} else if (match = selector.match(Patterns.inputvalue)) {
+						match[1] = match[1].toLowerCase();
+						switch (match[1]) {
+							case "checked":
+								source = "if(" + N + "(/^input$/i.test(e.localName)&&(\"|radio|checkbox|\".includes(\"|\"+e.type+\"|\")&&e.checked)||(/^option$/i.test(e.localName)&&(e.selected||e.checked)))){" + source + "}";
+								break;
+							case "indeterminate":
+								source = "if(" + N + "(/^progress$/i.test(e.localName)&&!e.hasAttribute(\"value\"))||(/^input$/i.test(e.localName)&&(\"checkbox\"==e.type&&e.indeterminate)||(\"radio\"==e.type&&e.name&&!s.first(\"input[name=\"+e.name+\"]:checked\",e.form)))){" + source + "}";
+								break;
+							case "required":
+								source = "if(" + N + "(/^input|select|textarea$/i.test(e.localName)&&e.required)){" + source + "}";
+								break;
+							case "optional":
+								source = "if(" + N + "(/^input|select|textarea$/i.test(e.localName)&&!e.required)){" + source + "}";
+								break;
+							case "invalid":
+								source = "if(" + N + "(((/^form$/i.test(e.localName)&&!e.noValidate)||(e.willValidate&&!e.formNoValidate))&&!e.checkValidity())||(/^fieldset$/i.test(e.localName)&&s.first(\":invalid\",e))){" + source + "}";
+								break;
+							case "valid":
+								source = "if(" + N + "(((/^form$/i.test(e.localName)&&!e.noValidate)||(e.willValidate&&!e.formNoValidate))&&e.checkValidity())||(/^fieldset$/i.test(e.localName)&&s.first(\":valid\",e))){" + source + "}";
+								break;
+							case "in-range":
+								source = "if(" + N + "(/^input$/i.test(e.localName))&&(e.willValidate&&!e.formNoValidate)&&(!e.validity.rangeUnderflow&&!e.validity.rangeOverflow)&&(\"|date|datetime-local|month|number|range|time|week|\".includes(\"|\"+e.type+\"|\"))&&(\"range\"==e.type||e.getAttribute(\"min\")||e.getAttribute(\"max\"))){" + source + "}";
+								break;
+							case "out-of-range":
+								source = "if(" + N + "(/^input$/i.test(e.localName))&&(e.willValidate&&!e.formNoValidate)&&(e.validity.rangeUnderflow||e.validity.rangeOverflow)&&(\"|date|datetime-local|month|number|range|time|week|\".includes(\"|\"+e.type+\"|\"))&&(\"range\"==e.type||e.getAttribute(\"min\")||e.getAttribute(\"max\"))){" + source + "}";
+								break;
+							default: emit("'" + selector_string + "'" + qsInvalid);
+						}
+					} else if (match = selector.match(Patterns.pseudo_sng)) source = "if(e.element&&e.type.toLowerCase()==\":" + match[0].toLowerCase() + "\"){e=e.element;" + source + "}";
+					else if (match = selector.match(Patterns.pseudo_dbl)) source = "if(e.element&&e.type.toLowerCase()==\"" + match[0].toLowerCase() + "\"){e=e.element;" + source + "}";
+					else {
+						expr = false;
+						status = false;
+						for (expr in Selectors) if (match = selector.match(Selectors[expr].Expression)) {
+							result = Selectors[expr].Callback(match, source, mode, callback);
+							if ("match" in result) match = result.match;
+							vars = result.modvar;
+							if (mode) vars && S_VARS.indexOf(vars) < 0 && (S_VARS[S_VARS.length] = vars);
+							else vars && M_VARS.indexOf(vars) < 0 && (M_VARS[M_VARS.length] = vars);
+							source = result.source;
+							status = result.status;
+							if (status) break;
+						}
+						if (!status) {
+							emit("unknown pseudo-class selector '" + selector + "'");
+							return "";
+						}
+						if (!expr) {
+							emit("unknown token in selector '" + selector + "'");
+							return "";
+						}
+					}
+					break;
+				default: emit("'" + selector_string + "'" + qsInvalid);
+			}
+			if (!match) {
+				emit("'" + selector_string + "'" + qsInvalid);
+				return "";
+			}
+			selector = match.pop();
+		}
+		return source;
+	}, makeref = function(selectors, element) {
+		return selectors.replace(/:scope/gi, element.localName + (element.id ? "#" + element.id : "") + (element.className ? "." + element.classList[0] : ""));
+	}, ancestor = function _closest(selectors, element, callback) {
+		if (/:scope/i.test(selectors)) selectors = makeref(selectors, element);
+		while (element) {
+			if (match(selectors, element, callback)) break;
+			element = element.parentElement;
+		}
+		return element;
+	}, match_assert = function(f, element, callback) {
+		for (var i = 0, l = f.length, r = false; l > i; ++i) f[i](element, callback, null, false) && (r = true);
+		return r;
+	}, match_collect = function(selectors, callback) {
+		for (var i = 0, l = selectors.length, f = []; l > i; ++i) f[i] = compile(selectors[i], false, callback);
+		return { factory: f };
+	}, match = function _matches(selectors, element, callback) {
+		var expressions, parsed;
+		if (element && matchResolvers[selectors]) return match_assert(matchResolvers[selectors].factory, element, callback);
+		lastMatched = selectors;
+		if (arguments.length === 0) {
+			emit(qsNotArgs, TypeError);
+			return Config.VERBOSITY ? void 0 : false;
+		} else if (arguments[0] === "") {
+			emit("''" + qsInvalid);
+			return Config.VERBOSITY ? void 0 : false;
+		}
+		if (typeof selectors != "string") selectors = "" + selectors;
+		if (/:scope/i.test(selectors)) selectors = makeref(selectors, element);
+		parsed = selectors.replace(/\x00|\\$/g, "�").replace(REX.CombineWSP, " ").replace(REX.PseudosWSP, "$1").replace(REX.TabCharWSP, "	").replace(REX.CommaGroup, ",").replace(REX.TrimSpaces, "");
+		if ((expressions = parsed.match(reValidator)) && expressions.join("") == parsed) {
+			expressions = parsed.match(REX.SplitGroup);
+			if (parsed[parsed.length - 1] == ",") {
+				emit(qsInvalid);
+				return Config.VERBOSITY ? void 0 : false;
+			}
+		} else {
+			emit("'" + selectors + "'" + qsInvalid);
+			return Config.VERBOSITY ? void 0 : false;
+		}
+		matchResolvers[selectors] = match_collect(expressions, callback);
+		return match_assert(matchResolvers[selectors].factory, element, callback);
+	}, first = function _querySelector(selectors, context, callback) {
+		if (arguments.length === 0) emit(qsNotArgs, TypeError);
+		return select(selectors, context, typeof callback == "function" ? function firstMatch(element) {
+			callback(element);
+			return false;
+		} : function firstMatch() {
+			return false;
+		})[0] || null;
+	}, select = function _querySelectorAll(selectors, context, callback) {
+		var expressions, nodes, parsed, resolver;
+		context || (context = doc);
+		if (selectors) {
+			if (resolver = selectResolvers[selectors]) {
+				if (resolver.context === context && resolver.callback === callback) {
+					var f = resolver.factory, h = resolver.htmlset, n = resolver.nodeset, nodes = [];
+					if (n.length > 1) {
+						for (var i = 0, l = n.length, list; l > i; ++i) {
+							list = compat[n[i][0]](context, n[i].slice(1))();
+							if (f[i] !== null) f[i](list, callback, context, nodes);
+							else nodes = nodes.concat(list);
+						}
+						if (l > 1 && nodes.length > 1) {
+							nodes.sort(documentOrder);
+							hasDupes && (nodes = unique(nodes));
+						}
+					} else if (f[0]) nodes = f[0](h[0](), callback, context, nodes);
+					else nodes = h[0]();
+					return typeof callback == "function" ? concatCall(nodes, callback) : nodes;
+				}
+			}
+		}
+		lastSelected = selectors;
+		if (arguments.length === 0) {
+			emit(qsNotArgs, TypeError);
+			return Config.VERBOSITY ? void 0 : none;
+		} else if (arguments[0] === "") {
+			emit("''" + qsInvalid);
+			return Config.VERBOSITY ? void 0 : none;
+		} else if (lastContext !== context) lastContext = switchContext(context);
+		if (typeof selectors != "string") selectors = "" + selectors;
+		if (/:scope/i.test(selectors)) selectors = makeref(selectors, context);
+		parsed = selectors.replace(/\x00|\\$/g, "�").replace(REX.CombineWSP, " ").replace(REX.PseudosWSP, "$1").replace(REX.TabCharWSP, "	").replace(REX.CommaGroup, ",").replace(REX.TrimSpaces, "");
+		if ((expressions = parsed.match(reValidator)) && expressions.join("") == parsed) {
+			expressions = parsed.match(REX.SplitGroup);
+			if (parsed[parsed.length - 1] == ",") {
+				emit(qsInvalid);
+				return Config.VERBOSITY ? void 0 : false;
+			}
+		} else {
+			emit("'" + selectors + "'" + qsInvalid);
+			return Config.VERBOSITY ? void 0 : false;
+		}
+		selectResolvers[selectors] = collect(expressions, context, callback);
+		nodes = selectResolvers[selectors].results;
+		return typeof callback == "function" ? concatCall(nodes, callback) : nodes;
+	}, optimize = function(selector, token) {
+		var index = token.index, length = token[1].length + token[2].length;
+		return selector.slice(0, index) + (" >+~".indexOf(selector.charAt(index - 1)) > -1 ? ":[".indexOf(selector.charAt(index + length + 1)) > -1 ? "*" : "" : "") + selector.slice(index + length - (token[1] == "*" ? 1 : 0));
+	}, collect = function(selectors, context, callback) {
+		var i, l, seen = {}, token = [
+			"",
+			"*",
+			"*"
+		], optimized = selectors, factory = [], htmlset = [], nodeset = [], results = [], type;
+		for (i = 0, l = selectors.length; l > i; ++i) {
+			if (!seen[selectors[i]] && (seen[selectors[i]] = true)) {
+				type = selectors[i].match(reOptimizer);
+				if (type && type[1] != ":" && (token = type)) {
+					token[1] || (token[1] = "*");
+					optimized[i] = optimize(optimized[i], token);
+				} else token = [
+					"",
+					"*",
+					"*"
+				];
+			}
+			nodeset[i] = token[1] + token[2];
+			htmlset[i] = compat[token[1]](context, token[2]);
+			factory[i] = compile(optimized[i], true, null);
+			factory[i] ? factory[i](htmlset[i](), callback, context, results) : result.concat(htmlset[i]());
+		}
+		if (l > 1) {
+			results.sort(documentOrder);
+			hasDupes && (results = unique(results));
+		}
+		return {
+			callback,
+			context,
+			factory,
+			htmlset,
+			nodeset,
+			results
+		};
+	}, _closest, _matches, _querySelector, _querySelectorAll, install = function(all) {
+		_closest = Element.prototype.closest;
+		_matches = Element.prototype.matches;
+		_querySelector = Document.prototype.querySelector;
+		_querySelectorAll = Document.prototype.querySelectorAll;
+		Element.prototype.closest = function closest() {
+			var ctor = Object.getPrototypeOf(this).__proto__.__proto__.constructor.name;
+			if (!("nodeType" in this)) emit("'closest' called on an object that does not implement interface " + ctor + ".", TypeError);
+			return arguments.length < 1 ? ancestor.apply(this, []) : arguments.length < 2 ? ancestor.apply(this, [arguments[0], this]) : ancestor.apply(this, [
+				arguments[0],
+				this,
+				typeof arguments[1] == "function" ? arguments[1] : void 0
+			]);
+		};
+		Element.prototype.matches = function matches() {
+			var ctor = Object.getPrototypeOf(this).__proto__.__proto__.constructor.name;
+			if (!("nodeType" in this)) emit("'matches' called on an object that does not implement interface " + ctor + ".", TypeError);
+			return arguments.length < 1 ? match.apply(this, []) : arguments.length < 2 ? match.apply(this, [arguments[0], this]) : match.apply(this, [
+				arguments[0],
+				this,
+				typeof arguments[1] == "function" ? arguments[1] : void 0
+			]);
+		};
+		Element.prototype.querySelector = Document.prototype.querySelector = DocumentFragment.prototype.querySelector = function querySelector() {
+			var ctor = Object.getPrototypeOf(this).__proto__.__proto__.constructor.name;
+			if (!("nodeType" in this)) emit("'querySelector' called on an object that does not implement interface " + ctor + ".", TypeError);
+			return arguments.length < 1 ? first.apply(this, []) : arguments.length < 2 ? first.apply(this, [arguments[0], this]) : first.apply(this, [
+				arguments[0],
+				this,
+				typeof arguments[1] == "function" ? arguments[1] : void 0
+			]);
+		};
+		Element.prototype.querySelectorAll = Document.prototype.querySelectorAll = DocumentFragment.prototype.querySelectorAll = function querySelectorAll() {
+			var ctor = Object.getPrototypeOf(this).__proto__.__proto__.constructor.name;
+			if (!("nodeType" in this)) emit("'querySelectorAll' called on an object that does not implement interface " + ctor + ".", TypeError);
+			return arguments.length < 1 ? select.apply(this, []) : arguments.length < 2 ? select.apply(this, [arguments[0], this]) : select.apply(this, [
+				arguments[0],
+				this,
+				typeof arguments[1] == "function" ? arguments[1] : void 0
+			]);
+		};
+		if (all) document.addEventListener("load", function(e) {
+			var c, d, r, s, t = e.target;
+			if (/iframe/i.test(t.localName)) {
+				c = "(" + Export + ")(this, " + Factory + ");";
+				d = t.contentDocument;
+				s = d.createElement("script");
+				s.textContent = c + "NW.Dom.install()";
+				r = d.documentElement;
+				r.removeChild(r.insertBefore(s, r.firstChild));
+			}
+		}, true);
+	}, uninstall = function() {
+		Element.prototype.closest = _closest;
+		Element.prototype.matches = _matches;
+		Element.prototype.querySelector = Document.prototype.querySelector = DocumentFragment.prototype.querySelector = _querySelector;
+		Element.prototype.querySelectorAll = Document.prototype.querySelectorAll = DocumentFragment.prototype.querySelectorAll = _querySelectorAll;
+	}, none = Array(), lastContext, lastMatched, lastSelected, matchLambdas = {}, selectLambdas = {}, matchResolvers = {}, selectResolvers = {}, Snapshot = {
+		doc,
+		from: doc,
+		root,
+		byTag,
+		first,
+		match,
+		ancestor,
+		nthOfType,
+		nthElement,
+		hasAttributeNS
+	}, Dom = {
+		lastMatched,
+		lastSelected,
+		matchLambdas,
+		selectLambdas,
+		matchResolvers,
+		selectResolvers,
+		CFG,
+		M_BODY,
+		S_BODY,
+		M_TEST,
+		S_TEST,
+		byId,
+		byTag,
+		byClass,
+		match,
+		first,
+		select,
+		closest: ancestor,
+		compile,
+		configure,
+		emit,
+		Config,
+		Snapshot,
+		Version: version,
+		install,
+		uninstall,
+		Operators,
+		Selectors,
+		registerCombinator: function(combinator, resolver) {
+			var i = 0, l = combinator.length, symbol;
+			for (; l > i; ++i) if (combinator[i] != "=") {
+				symbol = combinator[i];
+				break;
+			}
+			if (CFG.combinators.indexOf(symbol) < 0) {
+				CFG.combinators = CFG.combinators.replace("](", symbol + "](");
+				CFG.combinators = CFG.combinators.replace("])", symbol + "])");
+				Combinators[combinator] = resolver;
+				setIdentifierSyntax();
+			} else console.warn("Warning: the '" + combinator + "' combinator is already registered.");
+		},
+		registerOperator: function(operator, resolver) {
+			var i = 0, l = operator.length, symbol;
+			for (; l > i; ++i) if (operator[i] != "=") {
+				symbol = operator[i];
+				break;
+			}
+			if (CFG.operators.indexOf(symbol) < 0 && !Operators[operator]) {
+				CFG.operators = CFG.operators.replace("]=", symbol + "]=");
+				Operators[operator] = resolver;
+				setIdentifierSyntax();
+			} else console.warn("Warning: the '" + operator + "' operator is already registered.");
+		},
+		registerSelector: function(name, rexp, func) {
+			Selectors[name] || (Selectors[name] = {
+				Expression: rexp,
+				Callback: func
+			});
+		}
+	};
+	initialize(doc);
+	return Dom;
+}
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/selectors/nwsapi-types.js
+const DOM$1 = nwsapi_default;
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/selectors/sizzle.js
+/*!
+* Sizzle CSS Selector Engine v2.3.7-pre
+* https://sizzlejs.com/
+*
+* Copyright JS Foundation and other contributors
+* Released under the MIT license
+* https://js.foundation/
+*
+* Date: 2022-04-02
+*
+* git commit hash for Deno DOM: ede0e97563c8473b8cfa4045c7c2cd6129ecc1aa
+*/
+var sizzle_default = (document) => {
+	const sizzleWindow = { document };
+	SetupSizzle(sizzleWindow);
+	const { Sizzle } = sizzleWindow;
+	return {
+		first(selectors, context) {
+			return Sizzle(selectors, context)[0] ?? null;
+		},
+		select(selectors, context) {
+			return Sizzle(selectors, context);
+		},
+		match(selectors, context) {
+			return Sizzle.matchesSelector(context, selectors);
+		}
+	};
+};
+function SetupSizzle(window) {
+	var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate, setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, expando = "sizzle" + 1 * /* @__PURE__ */ new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), nonnativeSelectorCache = createCache(), sortOrder = function(a, b) {
+		if (a === b) hasDuplicate = true;
+		return 0;
+	}, hasOwn = {}.hasOwnProperty, arr = [], pop = arr.pop, pushNative = arr.push, push = arr.push, slice = arr.slice, indexOf = function(list, elem) {
+		var i = 0, len = list.length;
+		for (; i < len; i++) if (list[i] === elem) return i;
+		return -1;
+	}, booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", whitespace = "[\\x20\\t\\r\\n\\f]", identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + "*([*^$|!~]?=)" + whitespace + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]", pseudos = ":(" + identifier + ")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|.*)\\)|)", rwhitespace = new RegExp(whitespace + "+", "g"), rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"), rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"), rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"), rdescend = new RegExp(whitespace + "|>"), rpseudo = new RegExp(pseudos), ridentifier = new RegExp("^" + identifier + "$"), matchExpr = {
+		ID: new RegExp("^#(" + identifier + ")"),
+		CLASS: new RegExp("^\\.(" + identifier + ")"),
+		TAG: new RegExp("^(" + identifier + "|[*])"),
+		ATTR: new RegExp("^" + attributes),
+		PSEUDO: new RegExp("^" + pseudos),
+		CHILD: new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
+		bool: new RegExp("^(?:" + booleans + ")$", "i"),
+		needsContext: new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
+	}, rhtml = /HTML$/i, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rnative = /^[^{]+\{\s*\[native \w/, rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, runescape = new RegExp("\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g"), funescape = function(escape, nonHex) {
+		var high = "0x" + escape.slice(1) - 65536;
+		return nonHex ? nonHex : high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320);
+	}, rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, fcssescape = function(ch, asCodePoint) {
+		if (asCodePoint) {
+			if (ch === "\0") return "�";
+			return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
+		}
+		return "\\" + ch;
+	}, unloadHandler = function() {
+		setDocument();
+	}, inDisabledFieldset = addCombinator(function(elem) {
+		return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
+	}, {
+		dir: "parentNode",
+		next: "legend"
+	});
+	try {
+		push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes);
+		arr[preferredDoc.childNodes.length].nodeType;
+	} catch (e) {
+		push = { apply: arr.length ? function(target, els) {
+			pushNative.apply(target, slice.call(els));
+		} : function(target, els) {
+			var j = target.length, i = 0;
+			while (target[j++] = els[i++]);
+			target.length = j - 1;
+		} };
+	}
+	function Sizzle(selector, context, results, seed) {
+		var m, i, elem, nid, match, groups, newSelector, newContext = context && context.ownerDocument, nodeType = context ? context.nodeType : 9;
+		results = results || [];
+		if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) return results;
+		if (!seed) {
+			setDocument(context);
+			context = context || document;
+			if (documentIsHTML) {
+				if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
+					if (m = match[1]) {
+						if (nodeType === 9) {
+							if (elem = context.getElementById(m)) {
+								if (elem.id === m) {
+									results.push(elem);
+									return results;
+								}
+							} else return results;
+						} else if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {
+							results.push(elem);
+							return results;
+						}
+					} else if (match[2]) {
+						push.apply(results, context.getElementsByTagName(selector));
+						return results;
+					} else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
+						push.apply(results, context.getElementsByClassName(m));
+						return results;
+					}
+				}
+				if (support.qsa && !nonnativeSelectorCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector)) && (nodeType !== 1 || context.nodeName.toLowerCase() !== "object")) {
+					newSelector = selector;
+					newContext = context;
+					if (nodeType === 1 && (rdescend.test(selector) || rcombinators.test(selector))) {
+						newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
+						if (newContext !== context || !support.scope) {
+							if (nid = context.getAttribute("id")) nid = nid.replace(rcssescape, fcssescape);
+							else context.setAttribute("id", nid = expando);
+						}
+						groups = tokenize(selector);
+						i = groups.length;
+						while (i--) groups[i] = (nid ? "#" + nid : ":scope") + " " + toSelector(groups[i]);
+						newSelector = groups.join(",");
+					}
+					try {
+						push.apply(results, newContext.querySelectorAll(newSelector));
+						return results;
+					} catch (qsaError) {
+						nonnativeSelectorCache(selector, true);
+					} finally {
+						if (nid === expando) context.removeAttribute("id");
+					}
+				}
+			}
+		}
+		return select(selector.replace(rtrim, "$1"), context, results, seed);
+	}
+	/**
+	* Create key-value caches of limited size
+	* @returns {function(string, object)} Returns the Object data after storing it on itself with
+	*	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
+	*	deleting the oldest entry
+	*/
+	function createCache() {
+		var keys = [];
+		function cache(key, value) {
+			if (keys.push(key + " ") > Expr.cacheLength) delete cache[keys.shift()];
+			return cache[key + " "] = value;
+		}
+		return cache;
+	}
+	/**
+	* Mark a function for special use by Sizzle
+	* @param {Function} fn The function to mark
+	*/
+	function markFunction(fn) {
+		fn[expando] = true;
+		return fn;
+	}
+	/**
+	* Support testing using an element
+	* @param {Function} fn Passed the created element and returns a boolean result
+	*/
+	function assert(fn) {
+		return true;
+	}
+	/**
+	* Adds the same handler for all of the specified attrs
+	* @param {String} attrs Pipe-separated list of attributes
+	* @param {Function} handler The method that will be applied
+	*/
+	function addHandle(attrs, handler) {
+		var arr = attrs.split("|"), i = arr.length;
+		while (i--) Expr.attrHandle[arr[i]] = handler;
+	}
+	/**
+	* Checks document order of two siblings
+	* @param {Element} a
+	* @param {Element} b
+	* @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
+	*/
+	function siblingCheck(a, b) {
+		var cur = b && a, diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex;
+		if (diff) return diff;
+		if (cur) {
+			while (cur = cur.nextSibling) if (cur === b) return -1;
+		}
+		return a ? 1 : -1;
+	}
+	/**
+	* Returns a function to use in pseudos for input types
+	* @param {String} type
+	*/
+	function createInputPseudo(type) {
+		return function(elem) {
+			return elem.nodeName.toLowerCase() === "input" && elem.type === type;
+		};
+	}
+	/**
+	* Returns a function to use in pseudos for buttons
+	* @param {String} type
+	*/
+	function createButtonPseudo(type) {
+		return function(elem) {
+			var name = elem.nodeName.toLowerCase();
+			return (name === "input" || name === "button") && elem.type === type;
+		};
+	}
+	/**
+	* Returns a function to use in pseudos for :enabled/:disabled
+	* @param {Boolean} disabled true for :disabled; false for :enabled
+	*/
+	function createDisabledPseudo(disabled) {
+		return function(elem) {
+			if ("form" in elem) {
+				if (elem.parentNode && elem.disabled === false) {
+					if ("label" in elem) {
+						if ("label" in elem.parentNode) return elem.parentNode.disabled === disabled;
+						else return elem.disabled === disabled;
+					}
+					return elem.isDisabled === disabled || elem.isDisabled !== !disabled && inDisabledFieldset(elem) === disabled;
+				}
+				return elem.disabled === disabled;
+			} else if ("label" in elem) return elem.disabled === disabled;
+			return false;
+		};
+	}
+	/**
+	* Returns a function to use in pseudos for positionals
+	* @param {Function} fn
+	*/
+	function createPositionalPseudo(fn) {
+		return markFunction(function(argument) {
+			argument = +argument;
+			return markFunction(function(seed, matches) {
+				var j, matchIndexes = fn([], seed.length, argument), i = matchIndexes.length;
+				while (i--) if (seed[j = matchIndexes[i]]) seed[j] = !(matches[j] = seed[j]);
+			});
+		});
+	}
+	/**
+	* Checks a node for validity as a Sizzle context
+	* @param {Element|Object=} context
+	* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
+	*/
+	function testContext(context) {
+		return context && typeof context.getElementsByTagName !== "undefined" && context;
+	}
+	support = Sizzle.support = {};
+	/**
+	* Detects XML nodes
+	* @param {Element|Object} elem An element or a document
+	* @returns {Boolean} True iff elem is a non-HTML XML node
+	*/
+	isXML = Sizzle.isXML = function(elem) {
+		var namespace = elem && elem.namespaceURI, docElem = elem && (elem.ownerDocument || elem).documentElement;
+		return !rhtml.test(namespace || docElem && docElem.nodeName || "HTML");
+	};
+	/**
+	* Sets document-related variables once based on the current document
+	* @param {Element|Object} [doc] An element or document object to use to set the document
+	* @returns {Object} Returns the current document
+	*/
+	setDocument = Sizzle.setDocument = function(node) {
+		var hasCompare, subWindow, doc = node ? node.ownerDocument || node : preferredDoc;
+		if (doc == document || doc.nodeType !== 9 || !doc.documentElement) return document;
+		document = doc;
+		docElem = document.documentElement;
+		documentIsHTML = !isXML(document);
+		if (preferredDoc != document && (subWindow = document.defaultView) && subWindow.top !== subWindow) {
+			if (subWindow.addEventListener) subWindow.addEventListener("unload", unloadHandler, false);
+			else if (subWindow.attachEvent) subWindow.attachEvent("onunload", unloadHandler);
+		}
+		support.scope = assert(function(el) {
+			docElem.appendChild(el).appendChild(document.createElement("div"));
+			return typeof el.querySelectorAll !== "undefined" && !el.querySelectorAll(":scope fieldset div").length;
+		});
+		support.attributes = assert(function(el) {
+			el.className = "i";
+			return !el.getAttribute("className");
+		});
+		support.getElementsByTagName = assert(function(el) {
+			el.appendChild(document.createComment(""));
+			return !el.getElementsByTagName("*").length;
+		});
+		support.getElementsByClassName = rnative.test(document.getElementsByClassName);
+		support.getById = assert(function(el) {
+			docElem.appendChild(el).id = expando;
+			return !document.getElementsByName || !document.getElementsByName(expando).length;
+		});
+		if (support.getById) {
+			Expr.filter["ID"] = function(id) {
+				var attrId = id.replace(runescape, funescape);
+				return function(elem) {
+					return elem.getAttribute("id") === attrId;
+				};
+			};
+			Expr.find["ID"] = function(id, context) {
+				if (typeof context.getElementById !== "undefined" && documentIsHTML) {
+					var elem = context.getElementById(id);
+					return elem ? [elem] : [];
+				}
+			};
+		} else {
+			Expr.filter["ID"] = function(id) {
+				var attrId = id.replace(runescape, funescape);
+				return function(elem) {
+					var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
+					return node && node.value === attrId;
+				};
+			};
+			Expr.find["ID"] = function(id, context) {
+				if (typeof context.getElementById !== "undefined" && documentIsHTML) {
+					var node, i, elems, elem = context.getElementById(id);
+					if (elem) {
+						node = elem.getAttributeNode("id");
+						if (node && node.value === id) return [elem];
+						elems = context.getElementsByName(id);
+						i = 0;
+						while (elem = elems[i++]) {
+							node = elem.getAttributeNode("id");
+							if (node && node.value === id) return [elem];
+						}
+					}
+					return [];
+				}
+			};
+		}
+		Expr.find["TAG"] = support.getElementsByTagName ? function(tag, context) {
+			if (typeof context.getElementsByTagName !== "undefined") return context.getElementsByTagName(tag);
+			else if (context[customByTagNameSym]) return context[customByTagNameSym](tag);
+			else if (support.qsa) return context.querySelectorAll(tag);
+		} : function(tag, context) {
+			var elem, tmp = [], i = 0, results = context.getElementsByTagName(tag);
+			if (tag === "*") {
+				while (elem = results[i++]) if (elem.nodeType === 1) tmp.push(elem);
+				return tmp;
+			}
+			return results;
+		};
+		Expr.find["CLASS"] = support.getElementsByClassName && function(className, context) {
+			if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) return context.getElementsByClassName(className);
+			else if (context[customByClassNameSym]) return context[customByClassNameSym](className);
+		};
+		rbuggyMatches = [];
+		rbuggyQSA = [];
+		if (support.qsa = rnative.test(document.querySelectorAll)) {}
+		if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector));
+		rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
+		rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));
+		hasCompare = rnative.test(docElem.compareDocumentPosition);
+		contains = hasCompare || rnative.test(docElem.contains) ? function(a, b) {
+			var adown = a.nodeType === 9 ? a.documentElement : a, bup = b && b.parentNode;
+			return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
+		} : function(a, b) {
+			if (b) {
+				while (b = b.parentNode) if (b === a) return true;
+			}
+			return false;
+		};
+		sortOrder = hasCompare ? function(a, b) {
+			if (a === b) {
+				hasDuplicate = true;
+				return 0;
+			}
+			var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
+			if (compare) return compare;
+			compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1;
+			if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {
+				if (a == document || a.ownerDocument == preferredDoc && contains(preferredDoc, a)) return -1;
+				if (b == document || b.ownerDocument == preferredDoc && contains(preferredDoc, b)) return 1;
+				return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
+			}
+			return compare & 4 ? -1 : 1;
+		} : function(a, b) {
+			if (a === b) {
+				hasDuplicate = true;
+				return 0;
+			}
+			var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [a], bp = [b];
+			if (!aup || !bup) return a == document ? -1 : b == document ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
+			else if (aup === bup) return siblingCheck(a, b);
+			cur = a;
+			while (cur = cur.parentNode) ap.unshift(cur);
+			cur = b;
+			while (cur = cur.parentNode) bp.unshift(cur);
+			while (ap[i] === bp[i]) i++;
+			return i ? siblingCheck(ap[i], bp[i]) : ap[i] == preferredDoc ? -1 : bp[i] == preferredDoc ? 1 : 0;
+		};
+		return document;
+	};
+	Sizzle.matches = function(expr, elements) {
+		return Sizzle(expr, null, null, elements);
+	};
+	Sizzle.matchesSelector = function(elem, expr) {
+		setDocument(elem);
+		if (support.matchesSelector && documentIsHTML && !nonnativeSelectorCache[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) try {
+			var ret = matches.call(elem, expr);
+			if (ret || support.disconnectedMatch || elem.document && elem.document.nodeType !== 11) return ret;
+		} catch (e) {
+			nonnativeSelectorCache(expr, true);
+		}
+		return Sizzle(expr, document, null, [elem]).length > 0;
+	};
+	Sizzle.contains = function(context, elem) {
+		if ((context.ownerDocument || context) != document) setDocument(context);
+		return contains(context, elem);
+	};
+	Sizzle.attr = function(elem, name) {
+		if ((elem.ownerDocument || elem) != document) setDocument(elem);
+		var fn = Expr.attrHandle[name.toLowerCase()], val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : void 0;
+		return val !== void 0 ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
+	};
+	Sizzle.escape = function(sel) {
+		return (sel + "").replace(rcssescape, fcssescape);
+	};
+	Sizzle.error = function(msg) {
+		throw new DOMException(`'${msg}' is not a valid selector`);
+	};
+	/**
+	* Document sorting and removing duplicates
+	* @param {ArrayLike} results
+	*/
+	Sizzle.uniqueSort = function(results) {
+		var elem, duplicates = [], j = 0, i = 0;
+		hasDuplicate = !support.detectDuplicates;
+		sortInput = !support.sortStable && results.slice(0);
+		results.sort(sortOrder);
+		if (hasDuplicate) {
+			while (elem = results[i++]) if (elem === results[i]) j = duplicates.push(i);
+			while (j--) results.splice(duplicates[j], 1);
+		}
+		sortInput = null;
+		return results;
+	};
+	/**
+	* Utility function for retrieving the text value of an array of DOM nodes
+	* @param {Array|Element} elem
+	*/
+	getText = Sizzle.getText = function(elem) {
+		var node, ret = "", i = 0, nodeType = elem.nodeType;
+		if (!nodeType) while (node = elem[i++]) ret += getText(node);
+		else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
+			if (typeof elem.textContent === "string") return elem.textContent;
+			else for (elem = elem.firstChild; elem; elem = elem.nextSibling) ret += getText(elem);
+		} else if (nodeType === 3 || nodeType === 4) return elem.nodeValue;
+		return ret;
+	};
+	Expr = Sizzle.selectors = {
+		cacheLength: 50,
+		createPseudo: markFunction,
+		match: matchExpr,
+		attrHandle: {},
+		find: {},
+		relative: {
+			">": {
+				dir: "parentNode",
+				first: true
+			},
+			" ": { dir: "parentNode" },
+			"+": {
+				dir: "previousSibling",
+				first: true
+			},
+			"~": { dir: "previousSibling" }
+		},
+		preFilter: {
+			ATTR: function(match) {
+				match[1] = match[1].replace(runescape, funescape);
+				match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
+				if (match[2] === "~=") match[3] = " " + match[3] + " ";
+				return match.slice(0, 4);
+			},
+			CHILD: function(match) {
+				match[1] = match[1].toLowerCase();
+				if (match[1].slice(0, 3) === "nth") {
+					if (!match[3]) Sizzle.error(match[0]);
+					match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
+					match[5] = +(match[7] + match[8] || match[3] === "odd");
+				} else if (match[3]) Sizzle.error(match[0]);
+				return match;
+			},
+			PSEUDO: function(match) {
+				var excess, unquoted = !match[6] && match[2];
+				if (matchExpr["CHILD"].test(match[0])) return null;
+				if (match[3]) match[2] = match[4] || match[5] || "";
+				else if (unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, true)) && (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
+					match[0] = match[0].slice(0, excess);
+					match[2] = unquoted.slice(0, excess);
+				}
+				return match.slice(0, 3);
+			}
+		},
+		filter: {
+			TAG: function(nodeNameSelector) {
+				var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
+				return nodeNameSelector === "*" ? function() {
+					return true;
+				} : function(elem) {
+					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
+				};
+			},
+			CLASS: function(className) {
+				var pattern = classCache[className + " "];
+				return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function(elem) {
+					return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
+				});
+			},
+			ATTR: function(name, operator, check) {
+				return function(elem) {
+					var result = Sizzle.attr(elem, name);
+					if (result == null) return operator === "!=";
+					if (!operator) return true;
+					result += "";
+					return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf(check) === 0 : operator === "*=" ? check && result.indexOf(check) > -1 : operator === "$=" ? check && result.slice(-check.length) === check : operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 : operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" : false;
+				};
+			},
+			CHILD: function(type, what, _argument, first, last) {
+				var simple = type.slice(0, 3) !== "nth", forward = type.slice(-4) !== "last", ofType = what === "of-type";
+				return first === 1 && last === 0 ? function(elem) {
+					return !!elem.parentNode;
+				} : function(elem, _context, xml) {
+					var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false;
+					if (parent) {
+						if (simple) {
+							while (dir) {
+								node = elem;
+								while (node = node[dir]) if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) return false;
+								start = dir = type === "only" && !start && "nextSibling";
+							}
+							return true;
+						}
+						start = [forward ? parent.firstChild : parent.lastChild];
+						if (forward && useCache) {
+							node = parent;
+							outerCache = node[expando] || (node[expando] = {});
+							uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
+							cache = uniqueCache[type] || [];
+							nodeIndex = cache[0] === dirruns && cache[1];
+							diff = nodeIndex && cache[2];
+							node = nodeIndex && parent.childNodes[nodeIndex];
+							while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) if (node.nodeType === 1 && ++diff && node === elem) {
+								uniqueCache[type] = [
+									dirruns,
+									nodeIndex,
+									diff
+								];
+								break;
+							}
+						} else {
+							if (useCache) {
+								node = elem;
+								outerCache = node[expando] || (node[expando] = {});
+								uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
+								cache = uniqueCache[type] || [];
+								nodeIndex = cache[0] === dirruns && cache[1];
+								diff = nodeIndex;
+							}
+							if (diff === false) {
+								while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {
+									if (useCache) {
+										outerCache = node[expando] || (node[expando] = {});
+										uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
+										uniqueCache[type] = [dirruns, diff];
+									}
+									if (node === elem) break;
+								}
+							}
+						}
+						diff -= last;
+						return diff === first || diff % first === 0 && diff / first >= 0;
+					}
+				};
+			},
+			PSEUDO: function(pseudo, argument) {
+				var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
+				if (fn[expando]) return fn(argument);
+				if (fn.length > 1) {
+					args = [
+						pseudo,
+						pseudo,
+						"",
+						argument
+					];
+					return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, matches) {
+						var idx, matched = fn(seed, argument), i = matched.length;
+						while (i--) {
+							idx = indexOf(seed, matched[i]);
+							seed[idx] = !(matches[idx] = matched[i]);
+						}
+					}) : function(elem) {
+						return fn(elem, 0, args);
+					};
+				}
+				return fn;
+			}
+		},
+		pseudos: {
+			not: markFunction(function(selector) {
+				var input = [], results = [], matcher = compile(selector.replace(rtrim, "$1"));
+				return matcher[expando] ? markFunction(function(seed, matches, _context, xml) {
+					var elem, unmatched = matcher(seed, null, xml, []), i = seed.length;
+					while (i--) if (elem = unmatched[i]) seed[i] = !(matches[i] = elem);
+				}) : function(elem, _context, xml) {
+					input[0] = elem;
+					matcher(input, null, xml, results);
+					input[0] = null;
+					return !results.pop();
+				};
+			}),
+			has: markFunction(function(selector) {
+				return function(elem) {
+					return Sizzle(selector, elem).length > 0;
+				};
+			}),
+			contains: markFunction(function(text) {
+				text = text.replace(runescape, funescape);
+				return function(elem) {
+					return (elem.textContent || getText(elem)).indexOf(text) > -1;
+				};
+			}),
+			lang: markFunction(function(lang) {
+				if (!ridentifier.test(lang || "")) Sizzle.error("unsupported lang: " + lang);
+				lang = lang.replace(runescape, funescape).toLowerCase();
+				return function(elem) {
+					var elemLang;
+					do
+						if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
+							elemLang = elemLang.toLowerCase();
+							return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
+						}
+					while ((elem = elem.parentNode) && elem.nodeType === 1);
+					return false;
+				};
+			}),
+			target: function(elem) {
+				var hash = window.location && window.location.hash;
+				return hash && hash.slice(1) === elem.id;
+			},
+			root: function(elem) {
+				return elem === docElem;
+			},
+			focus: function(elem) {
+				return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
+			},
+			enabled: createDisabledPseudo(false),
+			disabled: createDisabledPseudo(true),
+			checked: function(elem) {
+				var nodeName = elem.nodeName.toLowerCase();
+				return nodeName === "input" && !!elem.checked || nodeName === "option" && !!elem.selected;
+			},
+			selected: function(elem) {
+				if (elem.parentNode) elem.parentNode.selectedIndex;
+				return elem.selected === true;
+			},
+			empty: function(elem) {
+				for (elem = elem.firstChild; elem; elem = elem.nextSibling) if (elem.nodeType < 6) return false;
+				return true;
+			},
+			parent: function(elem) {
+				return !Expr.pseudos["empty"](elem);
+			},
+			header: function(elem) {
+				return rheader.test(elem.nodeName);
+			},
+			input: function(elem) {
+				return rinputs.test(elem.nodeName);
+			},
+			button: function(elem) {
+				var name = elem.nodeName.toLowerCase();
+				return name === "input" && elem.type === "button" || name === "button";
+			},
+			text: function(elem) {
+				var attr;
+				return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
+			},
+			first: createPositionalPseudo(function() {
+				return [0];
+			}),
+			last: createPositionalPseudo(function(_matchIndexes, length) {
+				return [length - 1];
+			}),
+			eq: createPositionalPseudo(function(_matchIndexes, length, argument) {
+				return [argument < 0 ? argument + length : argument];
+			}),
+			even: createPositionalPseudo(function(matchIndexes, length) {
+				var i = 0;
+				for (; i < length; i += 2) matchIndexes.push(i);
+				return matchIndexes;
+			}),
+			odd: createPositionalPseudo(function(matchIndexes, length) {
+				var i = 1;
+				for (; i < length; i += 2) matchIndexes.push(i);
+				return matchIndexes;
+			}),
+			lt: createPositionalPseudo(function(matchIndexes, length, argument) {
+				var i = argument < 0 ? argument + length : argument > length ? length : argument;
+				for (; --i >= 0;) matchIndexes.push(i);
+				return matchIndexes;
+			}),
+			gt: createPositionalPseudo(function(matchIndexes, length, argument) {
+				var i = argument < 0 ? argument + length : argument;
+				for (; ++i < length;) matchIndexes.push(i);
+				return matchIndexes;
+			})
+		}
+	};
+	Expr.pseudos["nth"] = Expr.pseudos["eq"];
+	for (i in {
+		radio: true,
+		checkbox: true,
+		file: true,
+		password: true,
+		image: true
+	}) Expr.pseudos[i] = createInputPseudo(i);
+	for (i in {
+		submit: true,
+		reset: true
+	}) Expr.pseudos[i] = createButtonPseudo(i);
+	function setFilters() {}
+	setFilters.prototype = Expr.filters = Expr.pseudos;
+	Expr.setFilters = new setFilters();
+	tokenize = Sizzle.tokenize = function(selector, parseOnly) {
+		var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + " "];
+		if (cached) return parseOnly ? 0 : cached.slice(0);
+		soFar = selector;
+		groups = [];
+		preFilters = Expr.preFilter;
+		while (soFar) {
+			if (!matched || (match = rcomma.exec(soFar))) {
+				if (match) soFar = soFar.slice(match[0].length) || soFar;
+				groups.push(tokens = []);
+			}
+			matched = false;
+			if (match = rcombinators.exec(soFar)) {
+				matched = match.shift();
+				tokens.push({
+					value: matched,
+					type: match[0].replace(rtrim, " ")
+				});
+				soFar = soFar.slice(matched.length);
+			}
+			for (type in Expr.filter) if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
+				matched = match.shift();
+				tokens.push({
+					value: matched,
+					type,
+					matches: match
+				});
+				soFar = soFar.slice(matched.length);
+			}
+			if (!matched) break;
+		}
+		return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : tokenCache(selector, groups).slice(0);
+	};
+	function toSelector(tokens) {
+		var i = 0, len = tokens.length, selector = "";
+		for (; i < len; i++) selector += tokens[i].value;
+		return selector;
+	}
+	function addCombinator(matcher, combinator, base) {
+		var dir = combinator.dir, skip = combinator.next, key = skip || dir, checkNonElements = base && key === "parentNode", doneName = done++;
+		return combinator.first ? function(elem, context, xml) {
+			while (elem = elem[dir]) if (elem.nodeType === 1 || checkNonElements) return matcher(elem, context, xml);
+			return false;
+		} : function(elem, context, xml) {
+			var oldCache, uniqueCache, outerCache, newCache = [dirruns, doneName];
+			if (xml) {
+				while (elem = elem[dir]) if (elem.nodeType === 1 || checkNonElements) {
+					if (matcher(elem, context, xml)) return true;
+				}
+			} else while (elem = elem[dir]) if (elem.nodeType === 1 || checkNonElements) {
+				outerCache = elem[expando] || (elem[expando] = {});
+				uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});
+				if (skip && skip === elem.nodeName.toLowerCase()) elem = elem[dir] || elem;
+				else if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) return newCache[2] = oldCache[2];
+				else {
+					uniqueCache[key] = newCache;
+					if (newCache[2] = matcher(elem, context, xml)) return true;
+				}
+			}
+			return false;
+		};
+	}
+	function elementMatcher(matchers) {
+		return matchers.length > 1 ? function(elem, context, xml) {
+			var i = matchers.length;
+			while (i--) if (!matchers[i](elem, context, xml)) return false;
+			return true;
+		} : matchers[0];
+	}
+	function multipleContexts(selector, contexts, results) {
+		var i = 0, len = contexts.length;
+		for (; i < len; i++) Sizzle(selector, contexts[i], results);
+		return results;
+	}
+	function condense(unmatched, map, filter, context, xml) {
+		var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null;
+		for (; i < len; i++) if (elem = unmatched[i]) {
+			if (!filter || filter(elem, context, xml)) {
+				newUnmatched.push(elem);
+				if (mapped) map.push(i);
+			}
+		}
+		return newUnmatched;
+	}
+	function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
+		if (postFilter && !postFilter[expando]) postFilter = setMatcher(postFilter);
+		if (postFinder && !postFinder[expando]) postFinder = setMatcher(postFinder, postSelector);
+		return markFunction(function(seed, results, context, xml) {
+			var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []), matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems, matcherOut = matcher ? postFinder || (seed ? preFilter : preexisting || postFilter) ? [] : results : matcherIn;
+			if (matcher) matcher(matcherIn, matcherOut, context, xml);
+			if (postFilter) {
+				temp = condense(matcherOut, postMap);
+				postFilter(temp, [], context, xml);
+				i = temp.length;
+				while (i--) if (elem = temp[i]) matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
+			}
+			if (seed) {
+				if (postFinder || preFilter) {
+					if (postFinder) {
+						temp = [];
+						i = matcherOut.length;
+						while (i--) if (elem = matcherOut[i]) temp.push(matcherIn[i] = elem);
+						postFinder(null, matcherOut = [], temp, xml);
+					}
+					i = matcherOut.length;
+					while (i--) if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) seed[temp] = !(results[temp] = elem);
+				}
+			} else {
+				matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
+				if (postFinder) postFinder(null, results, matcherOut, xml);
+				else push.apply(results, matcherOut);
+			}
+		});
+	}
+	function matcherFromTokens(tokens) {
+		var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative || Expr.relative[" "], i = leadingRelative ? 1 : 0, matchContext = addCombinator(function(elem) {
+			return elem === checkContext;
+		}, implicitRelative, true), matchAnyContext = addCombinator(function(elem) {
+			return indexOf(checkContext, elem) > -1;
+		}, implicitRelative, true), matchers = [function(elem, context, xml) {
+			var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
+			checkContext = null;
+			return ret;
+		}];
+		for (; i < len; i++) if (matcher = Expr.relative[tokens[i].type]) matchers = [addCombinator(elementMatcher(matchers), matcher)];
+		else {
+			matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
+			if (matcher[expando]) {
+				j = ++i;
+				for (; j < len; j++) if (Expr.relative[tokens[j].type]) break;
+				return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === " " ? "*" : "" })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
+			}
+			matchers.push(matcher);
+		}
+		return elementMatcher(matchers);
+	}
+	function matcherFromGroupMatchers(elementMatchers, setMatchers) {
+		var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function(seed, context, xml, results, outermost) {
+			var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, elems = seed || byElement && Expr.find["TAG"]("*", outermost), dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || .1, len = elems.length;
+			if (outermost) outermostContext = context == document || context || outermost;
+			for (; i !== len && (elem = elems[i]) != null; i++) {
+				if (byElement && elem) {
+					j = 0;
+					if (!context && elem.ownerDocument != document) {
+						setDocument(elem);
+						xml = !documentIsHTML;
+					}
+					while (matcher = elementMatchers[j++]) if (matcher(elem, context || document, xml)) {
+						results.push(elem);
+						break;
+					}
+					if (outermost) dirruns = dirrunsUnique;
+				}
+				if (bySet) {
+					if (elem = !matcher && elem) matchedCount--;
+					if (seed) unmatched.push(elem);
+				}
+			}
+			matchedCount += i;
+			if (bySet && i !== matchedCount) {
+				j = 0;
+				while (matcher = setMatchers[j++]) matcher(unmatched, setMatched, context, xml);
+				if (seed) {
+					if (matchedCount > 0) {
+						while (i--) if (!(unmatched[i] || setMatched[i])) setMatched[i] = pop.call(results);
+					}
+					setMatched = condense(setMatched);
+				}
+				push.apply(results, setMatched);
+				if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) Sizzle.uniqueSort(results);
+			}
+			if (outermost) {
+				dirruns = dirrunsUnique;
+				outermostContext = contextBackup;
+			}
+			return unmatched;
+		};
+		return bySet ? markFunction(superMatcher) : superMatcher;
+	}
+	compile = Sizzle.compile = function(selector, match) {
+		var i, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + " "];
+		if (!cached) {
+			if (!match) match = tokenize(selector);
+			i = match.length;
+			while (i--) {
+				cached = matcherFromTokens(match[i]);
+				if (cached[expando]) setMatchers.push(cached);
+				else elementMatchers.push(cached);
+			}
+			cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
+			cached.selector = selector;
+		}
+		return cached;
+	};
+	/**
+	* A low-level selection function that works with Sizzle's compiled
+	*  selector functions
+	* @param {String|Function} selector A selector or a pre-compiled
+	*  selector function built with Sizzle.compile
+	* @param {Element} context
+	* @param {Array} [results]
+	* @param {Array} [seed] A set of elements to match against
+	*/
+	select = Sizzle.select = function(selector, context, results, seed) {
+		var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed && tokenize(selector = compiled.selector || selector);
+		results = results || [];
+		if (match.length === 1) {
+			tokens = match[0] = match[0].slice(0);
+			if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
+				context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
+				if (!context) return results;
+				else if (compiled) context = context.parentNode;
+				selector = selector.slice(tokens.shift().value.length);
+			}
+			i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
+			while (i--) {
+				token = tokens[i];
+				if (Expr.relative[type = token.type]) break;
+				if (find = Expr.find[type]) {
+					if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {
+						tokens.splice(i, 1);
+						selector = seed.length && toSelector(tokens);
+						if (!selector) {
+							push.apply(results, seed);
+							return results;
+						}
+						break;
+					}
+				}
+			}
+		}
+		(compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
+		return results;
+	};
+	support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
+	support.detectDuplicates = !!hasDuplicate;
+	setDocument();
+	support.sortDetached = assert(function(el) {
+		return el.compareDocumentPosition(document.createElement("fieldset")) & 1;
+	});
+	if (!assert(function(el) {
+		el.innerHTML = "<a href='#'></a>";
+		return el.firstChild.getAttribute("href") === "#";
+	})) addHandle("type|href|height|width", function(elem, name, isXML) {
+		if (!isXML) return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
+	});
+	if (!support.attributes || !assert(function(el) {
+		el.innerHTML = "<input/>";
+		el.firstChild.setAttribute("value", "");
+		return el.firstChild.getAttribute("value") === "";
+	})) addHandle("value", function(elem, _name, isXML) {
+		if (!isXML && elem.nodeName.toLowerCase() === "input") return elem.defaultValue;
+	});
+	if (!assert(function(el) {
+		return el.getAttribute("disabled") == null;
+	})) addHandle(booleans, function(elem, name, isXML) {
+		var val;
+		if (!isXML) return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
+	});
+	var _sizzle = window.Sizzle;
+	Sizzle.noConflict = function() {
+		if (window.Sizzle === Sizzle) window.Sizzle = _sizzle;
+		return Sizzle;
+	};
+	if (typeof define === "function" && define.amd) define(function() {
+		return Sizzle;
+	});
+	else if (typeof module !== "undefined" && module.exports) module.exports = Sizzle;
+	else window.Sizzle = Sizzle;
+}
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/selectors/sizzle-types.js
+const DOM = sizzle_default;
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/selectors/selectors.js
+let codeGenerationAllowed = null;
+function getSelectorEngine() {
+	if (codeGenerationAllowed === null) try {
+		new Function("");
+		codeGenerationAllowed = true;
+	} catch (e) {
+		codeGenerationAllowed = false;
+	}
+	if (codeGenerationAllowed) return DOM$1;
+	else return DOM;
+}
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/document.js
+var DOMImplementation = class {
+	constructor(key) {
+		if (key !== CTOR_KEY) throw new TypeError("Illegal constructor.");
+	}
+	createDocument() {
+		throw new Error("Unimplemented");
+	}
+	createHTMLDocument(titleStr) {
+		titleStr += "";
+		const doc = new HTMLDocument(CTOR_KEY);
+		const docType = new DocumentType("html", "", "", CTOR_KEY);
+		doc.appendChild(docType);
+		const html = new Element$1("html", doc, [], CTOR_KEY);
+		html._setOwnerDocument(doc);
+		const head = new Element$1("head", html, [], CTOR_KEY);
+		const body = new Element$1("body", html, [], CTOR_KEY);
+		const title = new Element$1("title", head, [], CTOR_KEY);
+		const titleText = new Text(titleStr);
+		title.appendChild(titleText);
+		doc.head = head;
+		doc.body = body;
+		return doc;
+	}
+	createDocumentType(qualifiedName, publicId, systemId) {
+		return new DocumentType(qualifiedName, publicId, systemId, CTOR_KEY);
+	}
+};
+var DocumentType = class DocumentType extends Node {
+	#qualifiedName = "";
+	#publicId = "";
+	#systemId = "";
+	constructor(name, publicId, systemId, key) {
+		super("html", NodeType.DOCUMENT_TYPE_NODE, null, key);
+		this.#qualifiedName = name;
+		this.#publicId = publicId;
+		this.#systemId = systemId;
+	}
+	get name() {
+		return this.#qualifiedName;
+	}
+	get publicId() {
+		return this.#publicId;
+	}
+	get systemId() {
+		return this.#systemId;
+	}
+	_shallowClone() {
+		return new DocumentType(this.#qualifiedName, this.#publicId, this.#systemId, CTOR_KEY);
+	}
+};
+var Document$1 = class Document$1 extends Node {
+	head = null;
+	body = null;
+	implementation;
+	#documentURI = "about:blank";
+	#nwapi = null;
+	constructor() {
+		super("#document", NodeType.DOCUMENT_NODE, null, CTOR_KEY);
+		this.implementation = new DOMImplementation(CTOR_KEY);
+	}
+	_shallowClone() {
+		return new Document$1();
+	}
+	get _nwapi() {
+		return this.#nwapi || (this.#nwapi = getSelectorEngine()(this));
+	}
+	get documentURI() {
+		return this.#documentURI;
+	}
+	get title() {
+		return this.querySelector("title")?.textContent || "";
+	}
+	set title(value) {
+		let titleElement = this.querySelector("title");
+		if (!titleElement) {
+			const { head } = this;
+			if (!head) return;
+			titleElement = this.createElement("title");
+			head.appendChild(titleElement);
+		}
+		titleElement.textContent = value;
+	}
+	get cookie() {
+		return "";
+	}
+	set cookie(newCookie) {}
+	get visibilityState() {
+		return "visible";
+	}
+	get hidden() {
+		return false;
+	}
+	get compatMode() {
+		return "CSS1Compat";
+	}
+	get documentElement() {
+		for (const node of this.childNodes) if (node.nodeType === NodeType.ELEMENT_NODE) return node;
+		return null;
+	}
+	get doctype() {
+		for (const node of this.childNodes) if (node.nodeType === NodeType.DOCUMENT_TYPE_NODE) return node;
+		return null;
+	}
+	get childElementCount() {
+		let count = 0;
+		for (const { nodeType } of this.childNodes) if (nodeType === NodeType.ELEMENT_NODE) count++;
+		return count;
+	}
+	appendChild(child) {
+		super.appendChild(child);
+		child._setOwnerDocument(this);
+		return child;
+	}
+	createElement(tagName, options) {
+		tagName = getUpperCase(tagName);
+		switch (tagName) {
+			case "TEMPLATE": {
+				const frag = new DocumentFragment$1();
+				const elm = new HTMLTemplateElement(null, [], CTOR_KEY, frag);
+				elm._setOwnerDocument(this);
+				return elm;
+			}
+			default: {
+				const elm = new Element$1(tagName, null, [], CTOR_KEY);
+				elm._setOwnerDocument(this);
+				return elm;
+			}
+		}
+	}
+	createElementNS(namespace, qualifiedName, options) {
+		if (namespace === "http://www.w3.org/1999/xhtml") return this.createElement(qualifiedName, options);
+		else throw new Error(`createElementNS: "${namespace}" namespace unimplemented`);
+	}
+	createTextNode(data) {
+		return new Text(data);
+	}
+	createComment(data) {
+		return new Comment(data);
+	}
+	createDocumentFragment() {
+		const fragment = new DocumentFragment$1();
+		fragment._setOwnerDocument(this);
+		return fragment;
+	}
+	importNode(node, deep = false) {
+		const copy = node.cloneNode(deep);
+		copy._setOwnerDocument(this);
+		return copy;
+	}
+	adoptNode(node) {
+		if (node instanceof Document$1) throw new DOMException("Adopting a Document node is not supported.", "NotSupportedError");
+		node._setParent(null);
+		node._setOwnerDocument(this);
+		return node;
+	}
+	cloneNode(deep) {
+		const doc = super.cloneNode(deep);
+		for (const child of doc.documentElement?.childNodes || []) switch (child.nodeName) {
+			case "BODY":
+				doc.body = child;
+				break;
+			case "HEAD": doc.head = child;
+		}
+		return doc;
+	}
+	querySelector(selectors) {
+		return this._nwapi.first(selectors, this);
+	}
+	querySelectorAll(selectors) {
+		const nodeList = new NodeList();
+		const mutator = nodeList[nodeListMutatorSym]();
+		for (const match of this._nwapi.select(selectors, this)) mutator.push(match);
+		return nodeList;
+	}
+	getElementById(id) {
+		if (!this._hasInitializedChildNodes()) return null;
+		for (const child of this.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+			if (child.id === id) return child;
+			const search = child.getElementById(id);
+			if (search) return search;
+		}
+		return null;
+	}
+	getElementsByTagName(tagName) {
+		if (tagName === "*") return this.documentElement ? this._getElementsByTagNameWildcard(this.documentElement, []) : [];
+		else return this._getElementsByTagName(getUpperCase(tagName), []);
+	}
+	_getElementsByTagNameWildcard(node, search) {
+		for (const child of this.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+			search.push(child);
+			child._getElementsByTagNameWildcard(search);
+		}
+		return search;
+	}
+	_getElementsByTagName(tagName, search) {
+		for (const child of this.childNodes) if (child.nodeType === NodeType.ELEMENT_NODE) {
+			if (child.tagName === tagName) search.push(child);
+			child._getElementsByTagName(tagName, search);
+		}
+		return search;
+	}
+	getElementsByTagNameNS(_namespace, localName) {
+		return this.getElementsByTagName(localName);
+	}
+	getElementsByClassName(className) {
+		return getElementsByClassName(this, className.trim().split(/\s+/), []);
+	}
+	hasFocus() {
+		return true;
+	}
+};
+var HTMLDocument = class HTMLDocument extends Document$1 {
+	constructor(key) {
+		if (key !== CTOR_KEY) throw new TypeError("Illegal constructor.");
+		super();
+	}
+	_shallowClone() {
+		return new HTMLDocument(CTOR_KEY);
+	}
+};
+utils_types_default.Document = Document$1;
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/deserialize.js
+function nodesFromString(html) {
+	return nodeFromArray(JSON.parse(parse(html)), null);
+}
+function fragmentNodesFromString(html, contextLocalName) {
+	return nodeFromArray(JSON.parse(parseFrag(html, contextLocalName)), null);
+}
+function nodeFromArray(data, parentNode) {
+	if (data[1] === "template") {
+		const content = nodeFromArray(data[3], null);
+		const contentFrag = new DocumentFragment$1();
+		const fragMutator = contentFrag._getChildNodesMutator();
+		for (const child of content.childNodes) {
+			fragMutator.push(child);
+			child._setParent(contentFrag);
+		}
+		return new HTMLTemplateElement(parentNode, data[2], CTOR_KEY, contentFrag);
+	}
+	const elm = new Element$1(data[1], parentNode, data[2], CTOR_KEY);
+	const childNodes = elm._getChildNodesMutator();
+	let childNode;
+	for (const child of data.slice(3)) switch (child[0]) {
+		case NodeType.TEXT_NODE:
+			childNode = new Text(child[1]);
+			childNode.parentNode = elm;
+			childNodes.push(childNode);
+			break;
+		case NodeType.COMMENT_NODE:
+			childNode = new Comment(child[1]);
+			childNode.parentNode = elm;
+			childNodes.push(childNode);
+			break;
+		case NodeType.DOCUMENT_NODE:
+		case NodeType.ELEMENT_NODE:
+			nodeFromArray(child, elm);
+			break;
+		case NodeType.DOCUMENT_TYPE_NODE:
+			childNode = new DocumentType(child[1], child[2], child[3], CTOR_KEY);
+			childNode.parentNode = elm;
+			childNodes.push(childNode);
+	}
+	return elm;
+}
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/dom/dom-parser.js
+var DOMParser$1 = class {
+	parseFromString(source, mimeType) {
+		if (mimeType !== "text/html") throw new Error(`DOMParser: "${mimeType}" unimplemented`);
+		const doc = new HTMLDocument(CTOR_KEY);
+		const fakeDoc = nodesFromString(String(source));
+		let htmlNode = null;
+		let hasDoctype = false;
+		for (const child of [...fakeDoc.childNodes]) {
+			doc.appendChild(child);
+			if (child instanceof DocumentType) hasDoctype = true;
+			else if (child.nodeName === "HTML") htmlNode = child;
+		}
+		if (!hasDoctype) {
+			const docType = new DocumentType("html", "", "", CTOR_KEY);
+			if (doc.childNodes.length === 0) doc.appendChild(docType);
+			else doc.insertBefore(docType, doc.childNodes[0]);
+		}
+		if (htmlNode) for (const child of htmlNode.childNodes) switch (child.tagName) {
+			case "HEAD":
+				doc.head = child;
+				break;
+			case "BODY": doc.body = child;
+		}
+		return doc;
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/src/api.js
+const oldHasInstance = Array[Symbol.hasInstance];
+Object.defineProperty(Array, Symbol.hasInstance, {
+	value(value) {
+		switch (value?.constructor) {
+			case HTMLCollection:
+			case NodeList: return false;
+			default: return oldHasInstance.call(this, value);
+		}
+	},
+	configurable: true
+});
+const oldIsArray = Array.isArray;
+Object.defineProperty(Array, "isArray", {
+	value: (value) => {
+		switch (value?.constructor) {
+			case HTMLCollection:
+			case NodeList: return false;
+			default: return oldIsArray.call(Array, value);
+		}
+	},
+	configurable: true
+});
+//#endregion
+//#region node_modules/.pnpm/@jsr+b-fuze__deno-dom@0.1.56/node_modules/@jsr/b-fuze__deno-dom/deno-dom-wasm.js
+/**
+* @module
+*
+* This module exposes the Deno DOM API with the WASM (Web Assembly) backend
+*
+* @example
+* ```typescript
+* import { DOMParser, Element } from "jsr:@b-fuze/deno-dom";
+*
+* const doc = new DOMParser().parseFromString(
+*   `
+*     <h1>Hello World!</h1>
+*     <p>Hello from <a href="https://deno.land/">Deno!</a></p>
+*   `,
+*   "text/html",
+* );
+*
+* const p = doc.querySelector("p")!;
+* console.log(p.textContent); // "Hello from Deno!"
+* ```
+*/ register(parse$1, parse_frag);
+//#endregion
 //#region src/dom.ts
-let DOMParser$1 = globalThis.DOMParser;
+let DOMParser = globalThis.DOMParser;
 const setDOMParser = (parser) => {
-	DOMParser$1 = parser;
+	DOMParser = parser;
 };
 //#endregion
 //#region src/node-dom.ts
@@ -12,7 +4190,7 @@ const setDOMParser = (parser) => {
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */
-setDOMParser(DOMParser);
+setDOMParser(DOMParser$1);
 //#endregion
 //#region src/BookmarksTree/BookmarksTree.ts
 /**
@@ -149,7 +4327,7 @@ var BookmarksTree = class BookmarksTree extends Map {
 	* ```
 	*/
 	toDOM() {
-		return new DOMParser$1().parseFromString(this.HTMLString, "text/html");
+		return new DOMParser().parseFromString(this.HTMLString, "text/html");
 	}
 	/**
 	* Gets the BookmarksTree as an HTML string in Netscape Bookmark format
@@ -285,7 +4463,7 @@ var BookmarksParser = class {
 	* ```
 	*/
 	static parseFromHTMLString(htmlString) {
-		const dom = new DOMParser$1().parseFromString(htmlString, "text/html");
+		const dom = new DOMParser().parseFromString(htmlString, "text/html");
 		return BookmarksTree.fromDOM(dom);
 	}
 	/**