@skaldapp/monaco-sfc 1.2.6 → 1.2.7

package/dist/vue.worker.js

@@ -46,6 +46,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/constants.mjs
 var NAME = Symbol("name");
+var PREFIX = Symbol("prefix");
 var VALUE = Symbol("value");
 var NS = Symbol("ns");
 var OWNER_ELEMENT = Symbol("owner");
@@ -55,50 +56,84 @@ var PREV = Symbol("prev");
 var NEXT = Symbol("next");
 var CHILD = Symbol("child");
 var PARENT = Symbol("parent");
+var HOST = Symbol("host");
 var DATA = Symbol("data");
 var LISTENERS = Symbol("listeners");
 var IS_TRUSTED = Symbol("isTrusted");
 var PATH = Symbol("path");
 var STOP_IMMEDIATE_PROPAGATION = Symbol("stop_immediate_propagation");
+var DISPATCHING = Symbol("dispatching");
 var CONTENT = Symbol("content");
 var HOOKS = Symbol("hooks");
+var EXTENSIONS = Symbol("extensions");
+var HOOKS_DISPATCH = Symbol("hooks_dispatch");
 var IS_CONNECTED = Symbol("is_connected");
-var NodeType$1 = /*#__PURE__*/ function(NodeType) {
-	NodeType[NodeType["NODE"] = 0] = "NODE";
-	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";
-	return NodeType;
-}({});
-var NamespaceURI = /*#__PURE__*/ function(NamespaceURI) {
-	NamespaceURI["XHTML"] = "http://www.w3.org/1999/xhtml";
-	NamespaceURI["SVG"] = "http://www.w3.org/2000/svg";
-	return NamespaceURI;
-}({});
+var CREATE_ELEMENT = Symbol("create_element");
+var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+function splitOnASCIIWhitespace(value) {
+	return value.split(/[\t\n\f\r ]+/).filter(Boolean);
+}
+function asciiLowercase(value) {
+	return value.replace(/[A-Z]/g, (character) => String.fromCharCode(character.charCodeAt(0) + 32));
+}
+function asciiUppercase(value) {
+	return value.replace(/[a-z]/g, (character) => String.fromCharCode(character.charCodeAt(0) - 32));
+}
+//#endregion
+//#region node_modules/@remote-dom/polyfill/build/esm/dom-exception.mjs
+function createDOMException(message, name) {
+	const DOMExceptionConstructor = globalThis.DOMException;
+	if (typeof DOMExceptionConstructor === "function") return new DOMExceptionConstructor(message, name);
+	const error = new Error(message);
+	error.name = name;
+	return error;
+}
 //#endregion
-//#region node_modules/@remote-dom/polyfill/build/esm/Event.mjs
-var EventPhase = /*#__PURE__*/ function(EventPhase) {
-	EventPhase[EventPhase["NONE"] = 0] = "NONE";
-	EventPhase[EventPhase["CAPTURING_PHASE"] = 1] = "CAPTURING_PHASE";
-	EventPhase[EventPhase["AT_TARGET"] = 2] = "AT_TARGET";
-	EventPhase[EventPhase["BUBBLING_PHASE"] = 3] = "BUBBLING_PHASE";
-	return EventPhase;
-}({});
+//#region node_modules/@remote-dom/polyfill/build/esm/names.mjs
+var VALID_ELEMENT_LOCAL_NAME = /^(?:[A-Za-z][^\0\t\n\f\r\u0020/>]*|[:_\u0080-\u{10FFFF}][A-Za-z0-9-.:_\u0080-\u{10FFFF}]*)$/u;
+var INVALID_ATTRIBUTE_LOCAL_NAME = /[\0\t\n\f\r />=]/u;
+var INVALID_NAMESPACE_PREFIX = /[\0\t\n\f\r />]/u;
+function normalizeNamespace(namespace) {
+	if (namespace == null) return null;
+	const normalized = String(namespace);
+	return normalized === "" ? null : normalized;
+}
+function validateElementLocalName(name) {
+	if (!VALID_ELEMENT_LOCAL_NAME.test(name)) throwInvalidCharacterError(name);
+}
+function validateAttributeLocalName(name) {
+	if (name === "" || INVALID_ATTRIBUTE_LOCAL_NAME.test(name)) throwInvalidCharacterError(name);
+}
+function validateAndExtractQualifiedName(namespaceValue, qualifiedNameValue, kind) {
+	const namespace = normalizeNamespace(namespaceValue);
+	const qualifiedName = String(qualifiedNameValue);
+	const separator = qualifiedName.indexOf(":");
+	const prefix = separator < 0 ? null : qualifiedName.slice(0, separator);
+	const localName = separator < 0 ? qualifiedName : qualifiedName.slice(separator + 1);
+	if (prefix != null && (prefix === "" || INVALID_NAMESPACE_PREFIX.test(prefix)) || (kind === "element" ? !VALID_ELEMENT_LOCAL_NAME.test(localName) : localName === "" || INVALID_ATTRIBUTE_LOCAL_NAME.test(localName))) throwInvalidCharacterError(qualifiedName);
+	if (prefix != null && namespace == null) throw createDOMException(`A namespace is required for the prefix in "${qualifiedName}"`, "NamespaceError");
+	if (prefix === "xml" && namespace !== "http://www.w3.org/XML/1998/namespace") throw createDOMException(`The xml prefix requires the XML namespace`, "NamespaceError");
+	if ((qualifiedName === "xmlns" || prefix === "xmlns") && namespace !== "http://www.w3.org/2000/xmlns/") throw createDOMException(`The xmlns name requires the XMLNS namespace`, "NamespaceError");
+	if (namespace === "http://www.w3.org/2000/xmlns/" && qualifiedName !== "xmlns" && prefix !== "xmlns") throw createDOMException(`The XMLNS namespace requires the xmlns name or prefix`, "NamespaceError");
+	return {
+		namespace,
+		qualifiedName,
+		prefix,
+		localName
+	};
+}
+function throwInvalidCharacterError(name) {
+	throw createDOMException(`Invalid name: "${name}"`, "InvalidCharacterError");
+}
 var now = typeof performance === "undefined" ? Date.now : performance.now.bind(performance);
 var Event = class {
-	static NONE = (() => EventPhase.NONE)();
-	static CAPTURING_PHASE = (() => EventPhase.CAPTURING_PHASE)();
-	static AT_TARGET = (() => EventPhase.AT_TARGET)();
-	static BUBBLING_PHASE = (() => EventPhase.BUBBLING_PHASE)();
-	timeStamp = (() => now())();
+	static NONE = 0;
+	static CAPTURING_PHASE = 1;
+	static AT_TARGET = 2;
+	static BUBBLING_PHASE = 3;
+	timeStamp = now();
 	target = null;
 	currentTarget = null;
 	srcElement = null;
@@ -110,6 +145,7 @@ var Event = class {
 	eventPhase = 0;
 	[PATH] = [];
 	[STOP_IMMEDIATE_PROPAGATION] = false;
+	[DISPATCHING] = false;
 	constructor(type, options) {
 		this.type = type;
 		Object.defineProperty(this, IS_TRUSTED, {
@@ -126,7 +162,7 @@ var Event = class {
 		return this[IS_TRUSTED];
 	}
 	composedPath() {
-		return this[PATH];
+		return [...this[PATH]];
 	}
 	stopPropagation() {
 		this.cancelBubble = true;
@@ -136,13 +172,13 @@ var Event = class {
 		this.cancelBubble = true;
 	}
 	preventDefault() {
-		this.defaultPrevented = true;
+		if (this.cancelable) this.defaultPrevented = true;
 	}
 	set returnValue(value) {
-		this.defaultPrevented = value;
+		if (!value) this.preventDefault();
 	}
 	get returnValue() {
-		return this.defaultPrevented;
+		return !this.defaultPrevented;
 	}
 	/** @deprecated */
 	initEvent(type, bubbles, cancelable) {
@@ -152,11 +188,14 @@ var Event = class {
 	}
 };
 function fireEvent(event, currentTarget, phase) {
-	const list = currentTarget[LISTENERS]?.get(`${event.type}${phase === EventPhase.CAPTURING_PHASE ? "@" : ""}`);
+	if (event.cancelBubble) return;
+	const list = currentTarget[LISTENERS]?.get(event.type)?.[phase === 1 ? "capture" : "bubble"];
 	if (!list) return;
-	for (const listener of list) {
-		event.eventPhase = event.target === currentTarget ? EventPhase.AT_TARGET : phase;
+	for (const registration of [...list]) {
+		if (!list.has(registration) || registration.signal?.aborted) continue;
+		event.eventPhase = event.target === currentTarget ? 2 : phase;
 		event.currentTarget = currentTarget;
+		const listener = registration.normalizedListener;
 		try {
 			if (typeof listener === "object") listener.handleEvent(event);
 			else listener.call(currentTarget, event);
@@ -170,140 +209,649 @@ function thrower(error) {
 	throw error;
 }
 //#endregion
+//#region node_modules/@remote-dom/polyfill/build/esm/custom-element-reactions.mjs
+var scopes = [];
+var reactionsByTarget = /* @__PURE__ */ new WeakMap();
+function enqueueCustomElementReaction(target, reaction) {
+	const reactions = reactionsByTarget.get(target);
+	if (reactions) reactions.push(reaction);
+	else reactionsByTarget.set(target, [reaction]);
+	scopes[scopes.length - 1].push(target);
+}
+function performWithCustomElementReactions(mutation) {
+	const scope = [];
+	scopes.push(scope);
+	let result;
+	try {
+		result = mutation();
+	} catch (error) {
+		scopes.pop();
+		try {
+			flushCustomElementReactions(scope);
+		} catch {}
+		throw error;
+	}
+	scopes.pop();
+	flushCustomElementReactions(scope);
+	return result;
+}
+function flushCustomElementReactions(scope) {
+	let firstError;
+	let didThrow = false;
+	for (const target of scope) {
+		const reactions = reactionsByTarget.get(target);
+		if (!reactions) continue;
+		while (reactions.length > 0) {
+			const reaction = reactions.shift();
+			try {
+				reaction();
+			} catch (error) {
+				if (!didThrow) {
+					firstError = error;
+					didThrow = true;
+				}
+			}
+		}
+		reactionsByTarget.delete(target);
+	}
+	if (didThrow) throw firstError;
+}
+//#endregion
+//#region node_modules/@remote-dom/polyfill/build/esm/hook-effects.mjs
+var hookEffects = [];
+var pendingPublications = [];
+var isDispatchingHookEffects = false;
+function performHookEffects(effects) {
+	for (const effect of effects) {
+		hookEffects.push(effect);
+		if (effect[1]) pendingPublications.push(effect[1]);
+	}
+	if (isDispatchingHookEffects) return;
+	isDispatchingHookEffects = true;
+	try {
+		let firstError;
+		let didThrow = false;
+		for (let index = 0; index < hookEffects.length; index++) {
+			const [run, publication] = hookEffects[index];
+			if (publication) pendingPublications.splice(pendingPublications.indexOf(publication), 1);
+			try {
+				run();
+			} catch (error) {
+				if (!didThrow) {
+					firstError = error;
+					didThrow = true;
+				}
+			}
+		}
+		if (didThrow) throw firstError;
+	} finally {
+		hookEffects.length = 0;
+		pendingPublications.length = 0;
+		isDispatchingHookEffects = false;
+	}
+}
+function isCoveredByPendingPublication(node) {
+	let current = node;
+	while (current) {
+		if (pendingPublications.includes(current)) return true;
+		current = current[PARENT] ?? current[HOST];
+	}
+	return false;
+}
+//#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/EventTarget.mjs
-var ONCE_LISTENERS = Symbol("onceListeners");
+var LISTENER_REGISTRATIONS = Symbol("listenerRegistrations");
 var EventTarget = class {
-	[LISTENERS] = (() => void 0)();
-	[ONCE_LISTENERS] = (() => void 0)();
+	[LISTENERS] = void 0;
+	[LISTENER_REGISTRATIONS] = void 0;
 	/**
 	* Property set by entities that extend this class that are part of the DOM tree.
 	* @internal
 	*/
-	[OWNER_DOCUMENT] = (() => void 0)();
+	[OWNER_DOCUMENT] = void 0;
 	addEventListener(type, listener, options) {
 		if (listener == null) return;
-		const capture = options === true || options && options.capture === true;
+		const capture = options === true || typeof options === "object" && options.capture === true;
 		const once = typeof options === "object" && options.once === true;
 		const signal = typeof options === "object" ? options.signal : void 0;
-		const key = `${type}${capture ? "@" : ""}`;
-		let normalizedListener = listener;
-		if (once) {
-			normalizedListener = function normalizedListener(...args) {
-				this.removeEventListener(type, listener, options);
-				return typeof listener === "object" ? listener.handleEvent(...args) : listener.call(this, ...args);
-			};
-			let onceListeners = this[ONCE_LISTENERS];
-			if (!onceListeners) {
-				onceListeners = /* @__PURE__ */ new WeakMap();
-				this[ONCE_LISTENERS] = onceListeners;
+		if (signal?.aborted) return;
+		const phase = listenerPhase(capture);
+		let registrations = this[LISTENER_REGISTRATIONS];
+		if (!registrations) {
+			registrations = /* @__PURE__ */ new Map();
+			this[LISTENER_REGISTRATIONS] = registrations;
+		}
+		let registrationsForType = registrations.get(type);
+		if (!registrationsForType) {
+			registrationsForType = {};
+			registrations.set(type, registrationsForType);
+		}
+		let registrationsForPhase = registrationsForType[phase];
+		if (!registrationsForPhase) {
+			registrationsForPhase = /* @__PURE__ */ new Map();
+			registrationsForType[phase] = registrationsForPhase;
+		}
+		if (registrationsForPhase.has(listener)) return;
+		const target = this;
+		const registration = {
+			type,
+			listener,
+			capture,
+			once,
+			normalizedListener: listener,
+			signal
+		};
+		if (once || signal) registration.normalizedListener = function normalizedListener(...args) {
+			if (registration.signal?.aborted) {
+				removeListenerRegistration(target, registration);
+				return;
 			}
-			onceListeners.set(listener, normalizedListener);
-		}
+			if (registration.once) removeListenerRegistration(target, registration);
+			return typeof registration.listener === "object" ? registration.listener.handleEvent(...args) : registration.listener.call(this, ...args);
+		};
 		let listeners = this[LISTENERS];
 		if (!listeners) {
 			listeners = /* @__PURE__ */ new Map();
 			this[LISTENERS] = listeners;
 		}
-		let list = listeners.get(key);
+		let listenersForType = listeners.get(type);
+		if (!listenersForType) {
+			listenersForType = {};
+			listeners.set(type, listenersForType);
+		}
+		let list = listenersForType[phase];
 		if (!list) {
 			list = /* @__PURE__ */ new Set();
-			listeners.set(key, list);
+			listenersForType[phase] = list;
+		}
+		registrationsForPhase.set(listener, registration);
+		list.add(registration);
+		if (signal) {
+			const abortListener = () => {
+				removeListenerRegistration(target, registration);
+			};
+			registration.abortListener = abortListener;
+			signal.addEventListener("abort", abortListener, { once: true });
 		}
-		if (list.has(normalizedListener)) return;
-		signal?.addEventListener("abort", () => {
-			removeEventListener.call(this, type, listener, options);
-		}, { once: true });
-		list.add(normalizedListener);
-		this[OWNER_DOCUMENT]?.defaultView[HOOKS].addEventListener?.(this, type, listener, options);
+		this[OWNER_DOCUMENT]?.defaultView[HOOKS_DISPATCH].addEventListener?.(this, type, listener, options);
 	}
 	removeEventListener(type, listener, options) {
 		return removeEventListener.call(this, type, listener, options);
 	}
 	dispatchEvent(event) {
-		const path = [];
-		let target = this;
-		while (target != null) {
-			path.push(target);
-			target = target.parentNode;
-		}
-		event.target = this;
-		event.srcElement = this;
-		event[PATH] = path;
-		for (let i = path.length; i--;) {
-			fireEvent(event, path[i], EventPhase.CAPTURING_PHASE);
-			if (event.cancelBubble) return event.defaultPrevented;
-		}
-		const bubblePath = event.bubbles ? path : path.slice(0, 1);
-		for (let i = 0; i < bubblePath.length; i++) {
-			fireEvent(event, bubblePath[i], EventPhase.BUBBLING_PHASE);
-			if (event.cancelBubble) return event.defaultPrevented;
-		}
-		return event.defaultPrevented;
+		if (event[DISPATCHING]) throw createDOMException(`Failed to execute 'dispatchEvent' on 'EventTarget': The event is already being dispatched.`, "InvalidStateError");
+		event[DISPATCHING] = true;
+		try {
+			const path = [];
+			let target = this;
+			while (target != null) {
+				path.push(target);
+				target = target.parentNode;
+			}
+			event.target = this;
+			event.srcElement = this;
+			event[PATH] = path;
+			for (let i = path.length; i--;) {
+				fireEvent(event, path[i], 1);
+				if (event.cancelBubble) return !event.defaultPrevented;
+			}
+			const bubblePath = event.bubbles ? path : path.slice(0, 1);
+			for (let i = 0; i < bubblePath.length; i++) {
+				fireEvent(event, bubblePath[i], 3);
+				if (event.cancelBubble) return !event.defaultPrevented;
+			}
+			return !event.defaultPrevented;
+		} finally {
+			event[DISPATCHING] = false;
+			event.cancelBubble = false;
+			event[STOP_IMMEDIATE_PROPAGATION] = false;
+			event.eventPhase = 0;
+			event.currentTarget = null;
+			event[PATH] = [];
+		}
 	}
 };
 function removeEventListener(type, listener, options) {
 	if (listener == null) return;
-	const onceListeners = this[ONCE_LISTENERS];
-	const normalizedListener = onceListeners?.get(listener) ?? listener;
-	onceListeners?.delete(listener);
-	const key = `${type}${options === true || options && options.capture === true ? "@" : ""}`;
-	const list = this[LISTENERS]?.get(key);
-	if (list) {
-		if (list.delete(normalizedListener)) this[OWNER_DOCUMENT]?.defaultView[HOOKS].removeEventListener?.(this, type, listener, options);
+	const capture = options === true || options && options.capture === true;
+	const phase = listenerPhase(Boolean(capture));
+	const registration = this[LISTENER_REGISTRATIONS]?.get(type)?.[phase]?.get(listener);
+	if (!registration) return;
+	removeListenerRegistration(this, registration);
+}
+function listenerPhase(capture) {
+	return capture ? "capture" : "bubble";
+}
+function removeListenerRegistration(target, registration) {
+	const phase = listenerPhase(registration.capture);
+	const registrations = target[LISTENER_REGISTRATIONS];
+	const registrationsForType = registrations?.get(registration.type);
+	if (!registrationsForType) return;
+	const registrationsForPhase = registrationsForType[phase];
+	if (!registrationsForPhase || registrationsForPhase.get(registration.listener) !== registration) return;
+	registrationsForPhase.delete(registration.listener);
+	if (registrationsForPhase.size === 0) delete registrationsForType[phase];
+	if (!registrationsForType.bubble && !registrationsForType.capture) registrations?.delete(registration.type);
+	if (registration.signal && registration.abortListener) registration.signal.removeEventListener("abort", registration.abortListener);
+	const listeners = target[LISTENERS];
+	const listenersForType = listeners?.get(registration.type);
+	if (!listenersForType) return;
+	const list = listenersForType[phase];
+	if (!list?.delete(registration)) return;
+	if (list.size === 0) delete listenersForType[phase];
+	if (!listenersForType.bubble && !listenersForType.capture) listeners?.delete(registration.type);
+	target[OWNER_DOCUMENT]?.defaultView[HOOKS_DISPATCH].removeEventListener?.(target, registration.type, registration.listener, registration.capture);
+}
+//#endregion
+//#region node_modules/@remote-dom/polyfill/build/esm/NodeList.mjs
+var NodeList = class extends Array {
+	item(index) {
+		return this[index] ?? null;
+	}
+};
+var SUPPORTED_IDENTIFIER_TEST = /^(?:--|-?[A-Za-z_\u0080-\u{10FFFF}])[A-Za-z0-9_\u0080-\u{10FFFF}-]*$/u;
+function readFunctionArgument(selector, start) {
+	let depth = 1;
+	let quote = null;
+	for (let index = start; index < selector.length; index++) {
+		const character = selector[index];
+		if (quote) {
+			if (character === "\\") index++;
+			else if (character === quote) quote = null;
+			continue;
+		}
+		if (character === "\"" || character === "'") quote = character;
+		else if (character === "(") depth++;
+		else if (character === ")" && --depth === 0) return [selector.slice(start, index), index + 1];
+	}
+	return [selector.slice(start), selector.length];
+}
+function throwSelectorSyntaxError(selector) {
+	throw createDOMException(`Invalid or unsupported selector: "${selector}"`, "SyntaxError");
+}
+function querySelector(within, selector) {
+	const parts = typeof selector === "string" ? parseSelector(selector) : [{
+		combinator: 4,
+		matchers: selector
+	}];
+	let result = null;
+	const child = within[CHILD];
+	if (child && parts[0].matchers.length) walkNodesForSelector(child, parts, (node) => {
+		result = node;
+		return false;
+	});
+	return result;
+}
+function querySelectorAll(within, selector) {
+	const parts = typeof selector === "string" ? parseSelector(selector) : [{
+		combinator: 4,
+		matchers: selector
+	}];
+	const results = new NodeList();
+	const child = within[CHILD];
+	if (child && parts[0].matchers.length) walkNodesForSelector(child, parts, (node) => {
+		results.push(node);
+	});
+	return results;
+}
+function parseSelector(selector, insideHas = false, allowLeadingCombinator = false) {
+	let part = {
+		combinator: 4,
+		matchers: []
+	};
+	const parts = [part];
+	const tokenizer = /[\t\n\f\r ]*?([>\t\n\f\r +~]?)[\t\n\f\r ]*?(?:(?:\[[\t\n\f\r ]*([^\]=\t\n\f\r ]+)[\t\n\f\r ]*(?:=[\t\n\f\r ]*(?:(['"])(.*?)\3|([^\]\t\n\f\r ]+)))?[\t\n\f\r ]*(?:\]|$))|([#.]?)([^\t\n\f\r #.[>:+~()]+)|:(\w+)(\()?)/gi;
+	const normalizedSelector = selector.replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, "");
+	if (normalizedSelector === "") throwSelectorSyntaxError(selector);
+	let consumed = 0;
+	let token;
+	while (token = tokenizer.exec(normalizedSelector)) {
+		if (token.index !== consumed) throwSelectorSyntaxError(selector);
+		if (token[1]) {
+			if (part.matchers.length === 0 && !(allowLeadingCombinator && parts.length === 1)) throwSelectorSyntaxError(selector);
+			if (token[1] === ">") part.combinator = 1;
+			else if (token[1] === "+") part.combinator = 3;
+			else if (token[1] === "~") part.combinator = 2;
+			else part.combinator = 0;
+			part = {
+				combinator: 4,
+				matchers: []
+			};
+			parts.push(part);
+		}
+		const name = token[8] ? asciiLowercase(token[8]) : token[2] || token[7];
+		if (token[7] != null && !token[6] && part.matchers.length > 0) throwSelectorSyntaxError(selector);
+		let type;
+		let value = token[4] ?? token[5] ?? token[7];
+		if (token[2]) {
+			if (!SUPPORTED_IDENTIFIER_TEST.test(name)) throwSelectorSyntaxError(selector);
+			const unquotedValue = token[5];
+			const openingQuote = unquotedValue?.[0];
+			if (token[3] == null && (openingQuote === "\"" || openingQuote === "'")) {
+				const valueOffset = token[0].lastIndexOf(unquotedValue);
+				value = normalizedSelector.slice(token.index + valueOffset + 1);
+				tokenizer.lastIndex = normalizedSelector.length;
+			} else if (unquotedValue != null && !SUPPORTED_IDENTIFIER_TEST.test(unquotedValue)) throwSelectorSyntaxError(selector);
+			type = 4;
+		} else if (token[6]) {
+			if (!SUPPORTED_IDENTIFIER_TEST.test(name)) throwSelectorSyntaxError(selector);
+			type = token[6] === "#" ? 2 : 3;
+		} else if (token[8]) type = token[9] == null ? 5 : 6;
+		else if (token[7] === "*") type = 0;
+		else if (token[7] && SUPPORTED_IDENTIFIER_TEST.test(token[7])) type = 1;
+		else throwSelectorSyntaxError(selector);
+		if (token[9]) {
+			[value, tokenizer.lastIndex] = readFunctionArgument(normalizedSelector, tokenizer.lastIndex);
+			if (name !== "has" && name !== "not") throwSelectorSyntaxError(selector);
+			if (name === "has" && insideHas) throwSelectorSyntaxError(selector);
+			parseSelector(value, insideHas || name === "has", name === "has");
+		} else if (type === 5) throwSelectorSyntaxError(selector);
+		part.matchers.push({
+			type,
+			name,
+			value
+		});
+		consumed = tokenizer.lastIndex;
+	}
+	if (consumed !== normalizedSelector.length || part.matchers.length === 0) throwSelectorSyntaxError(selector);
+	return parts;
+}
+function matchesSelector(element, selector) {
+	const parsed = parseSelector(selector);
+	return parsed[0]?.matchers.length ? matchesSelectorRecursive(element, parsed) : false;
+}
+function matchesRelativeSelector(scope, selector) {
+	const parts = parseSelector(selector, true, true);
+	const first = parts[0];
+	if (parts.length === 1 && first.matchers.length === 0) return false;
+	let leadingCombinator = 0;
+	const scopeMatcher = {
+		type: 7,
+		name: ":scope"
+	};
+	if (first.matchers.length === 0) {
+		leadingCombinator = first.combinator;
+		first.matchers.push(scopeMatcher);
+	} else parts.unshift({
+		combinator: 0,
+		matchers: [scopeMatcher]
+	});
+	if (parts.some(({ matchers }) => matchers.length === 0)) return false;
+	const root = leadingCombinator === 3 || leadingCombinator === 2 ? scope[NEXT] : scope[CHILD];
+	if (!root) return false;
+	let matched = false;
+	walkNodesForSelector(root, parts, () => {
+		matched = true;
+		return false;
+	}, scope);
+	return matched;
+}
+function walkNodesForSelector(node, parts, callback, scope) {
+	const pendingSiblings = [];
+	let current = node;
+	while (current) {
+		if (isElementNode(current)) {
+			if (matchesSelectorRecursive(current, parts, scope)) {
+				if (callback(current) === false) return false;
+			}
+			const child = current[CHILD];
+			if (child) {
+				const sibling = current[NEXT];
+				if (sibling) pendingSiblings.push(sibling);
+				current = child;
+				continue;
+			}
+		}
+		current = current[NEXT] ?? pendingSiblings.pop() ?? null;
+	}
+	return true;
+}
+function matchesSelectorRecursive(element, parts, scope) {
+	const { combinator, matchers } = parts[parts.length - 1];
+	if (combinator === 4) {
+		if (!matchesSelectorMatcher(element, matchers, scope)) return false;
+		const pp = parts.slice(0, -1);
+		return pp.length === 0 || matchesSelectorRecursive(element, pp, scope);
+	}
+	const link = combinator === 1 || combinator === 0 ? PARENT : PREV;
+	let ref = element[link];
+	if (!ref) return false;
+	if (combinator === 0 || combinator === 2) {
+		while (ref) {
+			if (isElementNode(ref) && matchesSelectorMatcher(ref, matchers, scope)) {
+				const pp = parts.slice(0, -1);
+				if (pp.length === 0) return true;
+				if (matchesSelectorRecursive(ref, pp, scope)) return true;
+			}
+			ref = ref[link];
+		}
+		return false;
+	} else {
+		if (combinator === 3 && !isElementNode(ref)) {
+			while (ref && !isElementNode(ref)) ref = ref[link];
+			if (!ref) return false;
+		}
+		if (!isElementNode(ref) || !matchesSelectorMatcher(ref, matchers, scope)) return false;
+		const pp = parts.slice(0, -1);
+		return pp.length === 0 || matchesSelectorRecursive(ref, pp, scope);
+	}
+}
+function getSelectorAttribute(element, name) {
+	return element.getAttributeNS(null, element.namespaceURI === "http://www.w3.org/1999/xhtml" ? asciiLowercase(name) : name);
+}
+function matchesSelectorMatcher(element, matcher, scope) {
+	if (!element) return false;
+	if (Array.isArray(matcher)) {
+		for (const single of matcher) if (matchesSelectorMatcher(element, single, scope) === false) return false;
+		return true;
+	}
+	const { type, name, value } = matcher;
+	switch (type) {
+		case 0: return name === "*";
+		case 1: return element.namespaceURI === "http://www.w3.org/1999/xhtml" ? element.localName === asciiLowercase(name) : element.localName === name;
+		case 2: return getSelectorAttribute(element, "id") === name;
+		case 3:
+			const classAttr = getSelectorAttribute(element, "class");
+			if (!classAttr) return false;
+			return splitOnASCIIWhitespace(classAttr).includes(name);
+		case 4:
+			const attribute = getSelectorAttribute(element, name);
+			return value == null ? attribute != null : attribute === value;
+		case 7: return element === scope;
+		case 5: throwSelectorSyntaxError(`:${name}`);
+		case 6: switch (name) {
+			case "has": return matchesRelativeSelector(element, value || "");
+			case "not": return !matchesSelector(element, value || "");
+			default: throwSelectorSyntaxError(`:${name}(${value})`);
+		}
 	}
+	return false;
 }
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/shared.mjs
+function isAttributeNode(node) {
+	return node.nodeType === 2;
+}
 function isCharacterData(node) {
 	return DATA in node;
 }
 function isTextNode(node) {
-	return node.nodeType === NodeType$1.TEXT_NODE;
+	return node.nodeType === 3;
 }
 function isCommentNode(node) {
-	return node.nodeType === NodeType$1.COMMENT_NODE;
+	return node.nodeType === 8;
 }
 function isElementNode(node) {
-	return node.nodeType === NodeType$1.ELEMENT_NODE;
+	return node.nodeType === 1;
 }
 function isDocumentFragmentNode(node) {
-	return node.nodeType === NodeType$1.DOCUMENT_FRAGMENT_NODE;
+	return node.nodeType === 11;
 }
 function isParentNode(node) {
 	return "appendChild" in node;
 }
-function cloneNode(node, deep, document = node.ownerDocument) {
+function collectAdoptionSnapshot(root) {
+	const nodes = [];
+	const pendingRoots = [root];
+	const pending = new Set(pendingRoots);
+	const visited = /* @__PURE__ */ new Set();
+	let treeNodes;
+	while (pendingRoots.length > 0) {
+		const currentRoot = pendingRoots.pop();
+		pending.delete(currentRoot);
+		if (visited.has(currentRoot)) continue;
+		const currentTreeNodes = [];
+		for (const node of selfAndDescendants(currentRoot)) {
+			if (visited.has(node)) continue;
+			visited.add(node);
+			nodes.push(node);
+			currentTreeNodes.push(node);
+			if (!isElementNode(node)) continue;
+			const attributes = node[ATTRIBUTES];
+			if (attributes) for (const attribute of attributes) {
+				if (visited.has(attribute)) continue;
+				visited.add(attribute);
+				nodes.push(attribute);
+			}
+			const content = node[CONTENT];
+			if (content && !visited.has(content) && !pending.has(content)) {
+				pending.add(content);
+				pendingRoots.push(content);
+			}
+		}
+		treeNodes ??= currentTreeNodes;
+	}
+	return {
+		nodes,
+		treeNodes
+	};
+}
+function adoptNodes(nodes, document) {
+	for (const node of nodes) node[OWNER_DOCUMENT] = document;
+}
+function cloneAttribute(attribute, document) {
+	const Attribute = attribute.constructor;
+	const cloned = new Attribute(attribute.name, attribute.value, attribute.namespaceURI);
+	cloned[OWNER_DOCUMENT] = document;
+	return cloned;
+}
+function cloneNodeShallow(node, document) {
 	if (isTextNode(node)) return document.createTextNode(node.data);
 	else if (isCommentNode(node)) return document.createComment(node.data);
+	else if (isAttributeNode(node)) return cloneAttribute(node, document);
 	else if (isElementNode(node)) {
-		const cloned = document.createElement(node.localName);
+		const cloned = document[CREATE_ELEMENT](node[NAME], node.namespaceURI, node[PREFIX], node.localName);
 		if (node[ATTRIBUTES]) for (let i = 0; i < node[ATTRIBUTES].length; i++) {
 			const attribute = node[ATTRIBUTES].item(i);
-			cloned.setAttributeNS(attribute.namespaceURI, attribute.name, attribute.value);
+			cloned.attributes.setNamedItem(cloneAttribute(attribute, document));
 		}
-		if (deep) for (const child of node.childNodes) cloned.appendChild(cloneNode(child, true, document));
 		return cloned;
-	} else if (isDocumentFragmentNode(node)) {
-		const fragment = document.createDocumentFragment();
-		if (deep) for (const child of node.childNodes) fragment.appendChild(cloneNode(child, true, document));
-		return fragment;
-	} else {
+	} else if (isDocumentFragmentNode(node)) return document.createDocumentFragment();
+	else {
 		const cloned = new node.constructor();
 		cloned[OWNER_DOCUMENT] = document;
 		return cloned;
 	}
 }
+function cloneNode(node, deep, document = node.ownerDocument) {
+	if (node.nodeType === 9) throw createDOMException("Cannot clone a document node", "NotSupportedError");
+	const cloned = cloneNodeShallow(node, document);
+	if (!deep || !isElementNode(node) && !isDocumentFragmentNode(node)) return cloned;
+	const visited = /* @__PURE__ */ new Set([node]);
+	const frames = [{
+		source: node,
+		destination: cloned,
+		childIndex: 0,
+		cloningContent: false
+	}];
+	while (frames.length > 0) {
+		const frame = frames[frames.length - 1];
+		let sourceChild;
+		let destinationParent;
+		if (!frame.cloningContent) {
+			sourceChild = frame.source.childNodes[frame.childIndex++];
+			destinationParent = frame.destination;
+			if (!sourceChild) {
+				frame.cloningContent = true;
+				frame.childIndex = 0;
+				if (isElementNode(frame.source) && frame.source.namespaceURI === "http://www.w3.org/1999/xhtml" && frame.source.localName === "template") {
+					const content = frame.source[CONTENT];
+					if (content) {
+						if (visited.has(content)) throwCloneGraphError();
+						visited.add(content);
+						frame.contentSource = content;
+						frame.contentDestination = frame.destination.content;
+					}
+				}
+				continue;
+			}
+		} else if (frame.contentSource && frame.contentDestination) {
+			sourceChild = frame.contentSource.childNodes[frame.childIndex++];
+			destinationParent = frame.contentDestination;
+		} else {
+			frames.pop();
+			if (frame.appendTo) frame.appendTo.appendChild(frame.destination);
+			continue;
+		}
+		if (!sourceChild) {
+			frames.pop();
+			if (frame.appendTo) frame.appendTo.appendChild(frame.destination);
+			continue;
+		}
+		if (visited.has(sourceChild)) throwCloneGraphError();
+		visited.add(sourceChild);
+		const clonedChild = cloneNodeShallow(sourceChild, document);
+		if (isElementNode(sourceChild) || isDocumentFragmentNode(sourceChild)) frames.push({
+			source: sourceChild,
+			destination: clonedChild,
+			appendTo: destinationParent,
+			childIndex: 0,
+			cloningContent: false
+		});
+		else destinationParent.appendChild(clonedChild);
+	}
+	return cloned;
+}
+function throwCloneGraphError() {
+	throw new Error("Cannot clone a cyclic or repeated node graph");
+}
+function getElementById(within, elementId) {
+	const id = String(elementId);
+	if (id === "") return null;
+	return querySelector(within, [{
+		type: 2,
+		name: id
+	}]);
+}
+function getElementsByClassName(within, classNames) {
+	return querySelectorAll(within, [...new Set(splitOnASCIIWhitespace(String(classNames)))].map((name) => ({
+		type: 3,
+		name
+	})));
+}
+function getElementsByTagName(within, qualifiedName) {
+	const name = String(qualifiedName);
+	const normalizedHtmlName = asciiLowercase(name);
+	const elements = [];
+	for (const node of descendants(within)) {
+		if (!isElementNode(node)) continue;
+		if (name === "*" || (node.namespaceURI === "http://www.w3.org/1999/xhtml" ? node[NAME] === normalizedHtmlName : node[NAME] === name)) elements.push(node);
+	}
+	return elements;
+}
 function descendants(node) {
 	const nodes = [];
-	const walk = (node) => {
-		nodes.push(node);
-		const child = node[CHILD];
-		if (child) walk(child);
-		const sibling = node[NEXT];
-		if (sibling) walk(sibling);
-	};
-	const child = node[CHILD];
-	if (child) walk(child);
+	const pendingSiblings = [];
+	let current = node[CHILD];
+	while (current) {
+		nodes.push(current);
+		const child = current[CHILD];
+		const sibling = current[NEXT];
+		if (child) {
+			if (sibling) pendingSiblings.push(sibling);
+			current = child;
+		} else current = sibling ?? pendingSiblings.pop() ?? null;
+	}
 	return nodes;
 }
 function selfAndDescendants(node) {
@@ -314,21 +862,22 @@ function selfAndDescendants(node) {
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/Node.mjs
 var Node$2 = class extends EventTarget {
-	nodeType = (() => NodeType$1.NODE)();
+	nodeType = 0;
 	[NAME] = "";
 	[PARENT] = null;
+	[HOST] = null;
 	[CHILD] = null;
 	[PREV] = null;
 	[NEXT] = null;
 	[IS_CONNECTED] = false;
 	get [HOOKS]() {
-		return this[OWNER_DOCUMENT].defaultView[HOOKS];
+		return this[OWNER_DOCUMENT].defaultView[HOOKS_DISPATCH];
 	}
 	get localName() {
 		return this[NAME];
 	}
 	get nodeName() {
-		return this[NAME].toUpperCase();
+		return this[NAME];
 	}
 	get ownerDocument() {
 		return this[OWNER_DOCUMENT];
@@ -337,7 +886,8 @@ var Node$2 = class extends EventTarget {
 		return this[IS_CONNECTED];
 	}
 	isDefaultNamespace(namespace) {
-		return namespace === NamespaceURI.XHTML;
+		const normalizedNamespace = normalizeNamespace(namespace);
+		return locateNamespace(this) === normalizedNamespace;
 	}
 	get parentNode() {
 		return this[PARENT];
@@ -399,9 +949,9 @@ var Node$2 = class extends EventTarget {
 	set textContent(data) {
 		if (isCharacterData(this)) this.data = data;
 		else if (isParentNode(this)) {
-			let child;
-			while (child = this[CHILD]) this.removeChild(child);
-			this.append(data);
+			const text = data == null ? "" : String(data);
+			if (text === "") this.replaceChildren();
+			else this.replaceChildren(text);
 		}
 	}
 	cloneNode(deep) {
@@ -409,15 +959,41 @@ var Node$2 = class extends EventTarget {
 	}
 	contains(node) {
 		let currentNode = node;
-		while (true) {
-			if (currentNode == null) return false;
+		while (currentNode != null) {
 			if (currentNode === this) return true;
-			currentNode = node.parentNode;
+			currentNode = currentNode.parentNode;
 		}
+		return false;
 	}
 };
+function locateNamespace(node) {
+	let current = node;
+	while (current) switch (current.nodeType) {
+		case 1: {
+			const element = current;
+			if (element.prefix == null && element.namespaceURI != null) return element.namespaceURI;
+			const namespace = element.attributes.getNamedItemNS(XMLNS_NAMESPACE, "xmlns");
+			if (namespace != null && namespace.prefix == null) return normalizeNamespace(namespace.value);
+			current = element.parentElement;
+			break;
+		}
+		case 9:
+			current = current.documentElement;
+			break;
+		case 10:
+		case 11: return null;
+		case 2:
+			current = current.ownerElement;
+			break;
+		default: current = current.parentElement;
+	}
+	return null;
+}
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/ChildNode.mjs
+var INSERT_NODE = Symbol("insertNode");
+var PREFLIGHT_INSERTIONS = Symbol("preflightInsertions");
+var REPLACE_NODE = Symbol("replaceNode");
 var ChildNode = class extends Node$2 {
 	remove() {
 		const parent = this.parentNode;
@@ -425,259 +1001,297 @@ var ChildNode = class extends Node$2 {
 		parent.removeChild(this);
 	}
 	replaceWith(...nodes) {
+		const staged = stageNodes(nodes);
 		const parent = this.parentNode;
 		if (!parent) return;
-		const node = toNode(parent, nodes[0]);
-		const next = node[NEXT];
-		parent.replaceChild(this, node);
-		for (let i = 1; i < nodes.length; i++) parent.insertBefore(toNode(parent, nodes[i]), next);
+		return performChildNodeMutation((hookEffects) => {
+			validateInsertionNodes(parent, staged);
+			let next = this[NEXT];
+			while (next && staged.includes(next)) next = next[NEXT];
+			const replacement = convertNodesIntoNode(parent, staged, hookEffects);
+			if (this.parentNode === parent) parent[REPLACE_NODE](replacement, this, hookEffects);
+			else parent[INSERT_NODE](replacement, next, hookEffects);
+		});
 	}
 	before(...nodes) {
+		const staged = stageNodes(nodes);
 		const parent = this.parentNode;
 		if (!parent) return;
-		for (const node of nodes) parent.insertBefore(toNode(parent, node), this);
+		return performChildNodeMutation((hookEffects) => {
+			validateInsertionNodes(parent, staged);
+			let previous = this[PREV];
+			while (previous && staged.includes(previous)) previous = previous[PREV];
+			const node = convertNodesIntoNode(parent, staged, hookEffects);
+			parent[INSERT_NODE](node, previous ? previous[NEXT] : parent.firstChild, hookEffects);
+		});
 	}
 	after(...nodes) {
+		const staged = stageNodes(nodes);
 		const parent = this.parentNode;
 		if (!parent) return;
-		const next = this[NEXT];
-		for (const node of nodes) parent.insertBefore(toNode(parent, node), next);
+		return performChildNodeMutation((hookEffects) => {
+			validateInsertionNodes(parent, staged);
+			let next = this[NEXT];
+			while (next && staged.includes(next)) next = next[NEXT];
+			const node = convertNodesIntoNode(parent, staged, hookEffects);
+			parent[INSERT_NODE](node, next, hookEffects);
+		});
 	}
 };
+function performChildNodeMutation(mutation) {
+	return performWithCustomElementReactions(() => {
+		const hookEffects = [];
+		try {
+			mutation(hookEffects);
+		} catch (error) {
+			try {
+				performHookEffects(hookEffects);
+			} catch {}
+			throw error;
+		}
+		performHookEffects(hookEffects);
+	});
+}
+function stageNodes(nodes) {
+	return nodes.map((node) => node instanceof Node$2 ? node : String(node));
+}
 function toNode(parent, node) {
 	if (node instanceof Node$2) return node;
 	return parent.ownerDocument.createTextNode(String(node));
 }
-//#endregion
-//#region node_modules/@remote-dom/polyfill/build/esm/NodeList.mjs
-var NodeList = class extends Array {
-	item(index) {
-		return this[index];
-	}
-};
-//#endregion
-//#region node_modules/@remote-dom/polyfill/build/esm/selectors.mjs
-var Combinator = /*#__PURE__*/ function(Combinator) {
-	Combinator[Combinator["Descendant"] = 0] = "Descendant";
-	Combinator[Combinator["Child"] = 1] = "Child";
-	Combinator[Combinator["Sibling"] = 2] = "Sibling";
-	Combinator[Combinator["Adjacent"] = 3] = "Adjacent";
-	Combinator[Combinator["Inner"] = 4] = "Inner";
-	return Combinator;
-}(Combinator || {});
-var MatcherType = /*#__PURE__*/ function(MatcherType) {
-	MatcherType[MatcherType["Unknown"] = 0] = "Unknown";
-	MatcherType[MatcherType["Element"] = 1] = "Element";
-	MatcherType[MatcherType["Id"] = 2] = "Id";
-	MatcherType[MatcherType["Class"] = 3] = "Class";
-	MatcherType[MatcherType["Attribute"] = 4] = "Attribute";
-	MatcherType[MatcherType["Pseudo"] = 5] = "Pseudo";
-	MatcherType[MatcherType["Function"] = 6] = "Function";
-	return MatcherType;
-}(MatcherType || {});
-var ELEMENT_SELECTOR_TEST = /[a-z]/;
-function querySelector(within, selector) {
-	const parts = parseSelector(selector);
-	let result = null;
-	const child = within[CHILD];
-	if (child && parts[0].matchers.length) walkNodesForSelector(child, parts, (node) => {
-		result = node;
-		return false;
-	});
-	return result;
-}
-function querySelectorAll(within, selector) {
-	const parts = parseSelector(selector);
-	const results = [];
-	const child = within[CHILD];
-	if (child && parts[0].matchers.length) walkNodesForSelector(child, parts, (node) => {
-		results.push(node);
-	});
-	return results;
-}
-function parseSelector(selector) {
-	let part = {
-		combinator: Combinator.Inner,
-		matchers: []
-	};
-	const parts = [part];
-	const tokenizer = /\s*?([>\s+~]?)\s*?(?:(?:\[\s*([^\]=]+)(?:=(['"])(.*?)\3)?\s*\])|([#.]?)([^\s#.[>:+~]+)|:(\w+)(?:\((.*?)\))?)/gi;
-	let token;
-	while (token = tokenizer.exec(selector)) {
-		if (token[1]) {
-			if (token[1] === ">") part.combinator = Combinator.Child;
-			else if (token[1] === "+") part.combinator = Combinator.Adjacent;
-			else if (token[1] === "~") part.combinator = Combinator.Sibling;
-			else part.combinator = Combinator.Descendant;
-			part = {
-				combinator: Combinator.Inner,
-				matchers: []
-			};
-			parts.push(part);
+function validateInsertionNodes(parent, nodes) {
+	for (const node of nodes) {
+		if (!(node instanceof Node$2)) continue;
+		let ancestor = parent;
+		while (ancestor) {
+			if (ancestor === node) throw createDOMException("Cannot insert a node into itself or one of its descendants", "HierarchyRequestError");
+			ancestor = ancestor[PARENT] ?? ancestor[HOST];
 		}
-		let type = MatcherType.Unknown;
-		if (token[2]) type = MatcherType.Attribute;
-		else if (token[5]) type = token[5] === "#" ? MatcherType.Id : MatcherType.Class;
-		else if (token[7]) type = token[8] == null ? MatcherType.Pseudo : MatcherType.Function;
-		else if (token[6]) {
-			if (token[6] === "*") type = MatcherType.Unknown;
-			else if (ELEMENT_SELECTOR_TEST.test(token[6])) type = MatcherType.Element;
-		}
-		part.matchers.push({
-			type,
-			name: token[2] || token[6] || token[7],
-			value: token[4] ?? token[6] ?? token[8]
-		});
 	}
-	return parts;
 }
-function matchesSelector(element, selector) {
-	const parsed = parseSelector(selector);
-	let part;
-	while (part = parsed.pop()) if (!matchesSelectorPart(element, part)) return false;
-	return true;
+function convertNodesIntoNode(parent, nodes, hookEffects) {
+	const convertedNodes = [];
+	for (const node of nodes) convertedNodes.push(toNode(parent, node));
+	if (convertedNodes.length === 1) return convertedNodes[0];
+	const fragment = parent.ownerDocument.createDocumentFragment();
+	fragment[PREFLIGHT_INSERTIONS](convertedNodes);
+	for (const node of convertedNodes) fragment[INSERT_NODE](node, null, hookEffects);
+	return fragment;
 }
-function walkNodesForSelector(node, parts, callback) {
-	if (isElementNode(node)) {
-		if (matchesSelectorRecursive(node, parts)) {
-			if (callback(node) === false) return false;
-		}
-		const child = node[CHILD];
-		if (child && walkNodesForSelector(child, parts, callback) === false) return false;
+//#endregion
+//#region node_modules/@remote-dom/polyfill/build/esm/MutationObserver.mjs
+var registrations;
+var registrationCount = 0;
+var attributeRegistrationCount = 0;
+var characterDataRegistrationCount = 0;
+var childListRegistrationCount = 0;
+/** @internal */
+var attributeObserversActive = false;
+/** @internal */
+var characterDataObserversActive = false;
+/** @internal */
+var childListObserversActive = false;
+var MutationObserver = class {
+	#callback;
+	#records = [];
+	#targets = /* @__PURE__ */ new Set();
+	#scheduled = false;
+	constructor(callback) {
+		if (typeof callback !== "function") throw new TypeError("MutationObserver callback must be a function");
+		this.#callback = callback;
+	}
+	observe(target, options = {}) {
+		const normalizedOptions = normalizeOptions(options);
+		const currentRegistrations = registrations ??= /* @__PURE__ */ new WeakMap();
+		let targetRegistrations = currentRegistrations.get(target);
+		if (targetRegistrations == null) {
+			targetRegistrations = /* @__PURE__ */ new Map();
+			currentRegistrations.set(target, targetRegistrations);
+		}
+		const previousOptions = targetRegistrations.get(this);
+		if (previousOptions == null) registrationCount++;
+		else updateRegistrationCounts(previousOptions, -1);
+		targetRegistrations.set(this, normalizedOptions);
+		updateRegistrationCounts(normalizedOptions, 1);
+		this.#targets.add(target);
+	}
+	disconnect() {
+		const currentRegistrations = registrations;
+		if (currentRegistrations == null) return;
+		for (const target of this.#targets) {
+			const targetRegistrations = currentRegistrations.get(target);
+			const options = targetRegistrations?.get(this);
+			if (options != null) {
+				targetRegistrations.delete(this);
+				registrationCount--;
+				updateRegistrationCounts(options, -1);
+			}
+			if (targetRegistrations?.size === 0) currentRegistrations.delete(target);
+		}
+		this.#targets.clear();
+		this.#records.length = 0;
+		if (registrationCount === 0) registrations = void 0;
+	}
+	takeRecords() {
+		return this.#records.splice(0);
+	}
+	/** @internal */
+	enqueue(record) {
+		this.#records.push(record);
+		if (this.#scheduled) return;
+		this.#scheduled = true;
+		queueMicrotask(() => {
+			this.#scheduled = false;
+			const records = this.takeRecords();
+			if (records.length > 0) this.#callback.call(this, records, this);
+		});
 	}
-	const next = node[NEXT];
-	if (next && walkNodesForSelector(next, parts, callback) === false) return false;
-	return true;
+};
+/** @internal */
+function queueMutationRecord(init) {
+	const currentRegistrations = registrations;
+	if (currentRegistrations == null) return;
+	const interestedObservers = /* @__PURE__ */ new Map();
+	let node = init.target;
+	while (node) {
+		const targetRegistrations = currentRegistrations.get(node);
+		if (targetRegistrations) for (const [observer, options] of targetRegistrations) {
+			if (node !== init.target && !options.subtree) continue;
+			let includeOldValue = false;
+			if (init.type === "attributes") {
+				if (!options.attributes) continue;
+				if (options.attributeFilter && !options.attributeFilter.has(init.attributeName ?? "")) continue;
+				includeOldValue = options.attributeOldValue;
+			} else if (init.type === "characterData") {
+				if (!options.characterData) continue;
+				includeOldValue = options.characterDataOldValue;
+			} else if (!options.childList) continue;
+			interestedObservers.set(observer, interestedObservers.get(observer) === true || includeOldValue);
+		}
+		node = node.parentNode;
+	}
+	for (const [observer, includeOldValue] of interestedObservers) observer.enqueue({
+		addedNodes: init.addedNodes ?? new NodeList(),
+		attributeName: init.attributeName ?? null,
+		attributeNamespace: init.attributeNamespace ?? null,
+		nextSibling: init.nextSibling ?? null,
+		oldValue: includeOldValue ? init.oldValue ?? null : null,
+		previousSibling: init.previousSibling ?? null,
+		removedNodes: init.removedNodes ?? new NodeList(),
+		target: init.target,
+		type: init.type
+	});
 }
-function matchesSelectorRecursive(element, parts) {
-	const { combinator, matchers } = parts[parts.length - 1];
-	if (combinator === Combinator.Inner) {
-		if (!matchesSelectorMatcher(element, matchers)) return false;
-		const pp = parts.slice(0, -1);
-		return pp.length === 0 || matchesSelectorRecursive(element, pp);
-	}
-	const link = combinator === Combinator.Child || combinator === Combinator.Descendant ? PARENT : PREV;
-	let ref = element[link];
-	if (!ref) return false;
-	if (combinator === Combinator.Descendant || combinator === Combinator.Sibling) {
-		while (ref) {
-			if (isElementNode(ref) && matchesSelectorMatcher(ref, matchers)) {
-				const pp = parts.slice(0, -1);
-				if (pp.length === 0) return true;
-				if (matchesSelectorRecursive(element, pp)) return true;
-			}
-			ref = ref[link];
-		}
-		return false;
-	} else {
-		if (combinator === Combinator.Adjacent && !isElementNode(ref)) {
-			while (ref && !isElementNode(ref)) ref = ref[link];
-			if (!ref) return false;
-		}
-		if (!isElementNode(ref) || !matchesSelectorMatcher(ref, matchers)) return false;
-		const pp = parts.slice(0, -1);
-		return pp.length === 0 || matchesSelectorRecursive(element, pp);
-	}
+/** @internal */
+function mutationNodeList(...nodes) {
+	const list = new NodeList();
+	list.push(...nodes);
+	return list;
 }
-function matchesSelectorPart(element, { combinator, matchers }) {
-	if (combinator === Combinator.Inner) return matchesSelectorMatcher(element, matchers);
-	const link = combinator === Combinator.Child || combinator === Combinator.Descendant ? PARENT : PREV;
-	let ref = element[link];
-	if (!ref) return false;
-	if (combinator === Combinator.Adjacent && !isElementNode(ref)) {
-		while (ref && !isElementNode(ref)) ref = ref[link];
-		if (!ref) return false;
-	}
-	if (!isElementNode(ref) || !matchesSelectorMatcher(ref, matchers)) return false;
-	if (combinator === Combinator.Descendant || combinator === Combinator.Sibling) {
-		while (ref = ref[link]) if (isElementNode(ref) && matchesSelectorMatcher(ref, matchers)) return true;
-	}
-	return true;
+function normalizeOptions(options) {
+	if (options.attributes === false && (options.attributeOldValue || options.attributeFilter != null)) throw new TypeError("attributeOldValue and attributeFilter require attributes to be enabled");
+	if (options.characterData === false && options.characterDataOldValue) throw new TypeError("characterDataOldValue requires characterData to be enabled");
+	const attributes = options.attributes ?? (options.attributeOldValue === true || options.attributeFilter != null);
+	const characterData = options.characterData ?? options.characterDataOldValue === true;
+	const childList = options.childList === true;
+	if (!attributes && !characterData && !childList) throw new TypeError("MutationObserver options must enable childList, attributes, or characterData");
+	return {
+		attributes,
+		attributeFilter: options.attributeFilter == null ? void 0 : new Set(options.attributeFilter.map(String)),
+		attributeOldValue: options.attributeOldValue === true,
+		characterData,
+		characterDataOldValue: options.characterDataOldValue === true,
+		childList,
+		subtree: options.subtree === true
+	};
 }
-function matchesSelectorMatcher(element, matcher) {
-	if (!element) return false;
-	if (Array.isArray(matcher)) {
-		for (const single of matcher) if (matchesSelectorMatcher(element, single) === false) return false;
-		return true;
-	}
-	const { type, name, value } = matcher;
-	switch (type) {
-		case MatcherType.Unknown: return name === "*";
-		case MatcherType.Element: return element.localName === name;
-		case MatcherType.Id: return element.getAttribute("id") === name;
-		case MatcherType.Class:
-			const classAttr = element.getAttribute("class");
-			if (!classAttr) return false;
-			return classAttr.split(/\s+/).includes(name);
-		case MatcherType.Attribute: return value == null ? element.hasAttribute(name) : element.getAttribute(name) === value;
-		case MatcherType.Pseudo: switch (name) {
-			default: throw Error(`Pseudo :${name} not implemented`);
-		}
-		case MatcherType.Function: switch (name) {
-			case "has": return matchesSelector(element, value || "");
-			case "not": return !matchesSelector(element, value || "");
-			default: throw Error(`Function :${name}(${value}) not implemented`);
-		}
-	}
-	return false;
+function updateRegistrationCounts(options, delta) {
+	if (options.attributes) attributeRegistrationCount += delta;
+	if (options.characterData) characterDataRegistrationCount += delta;
+	if (options.childList) childListRegistrationCount += delta;
+	attributeObserversActive = attributeRegistrationCount > 0;
+	characterDataObserversActive = characterDataRegistrationCount > 0;
+	childListObserversActive = childListRegistrationCount > 0;
 }
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/ParentNode.mjs
 var ParentNode = class extends ChildNode {
-	childNodes = (() => new NodeList())();
-	children = (() => new NodeList())();
+	childNodes = new NodeList();
+	children = new NodeList();
 	appendChild(child) {
-		this.insertInto(child, null);
+		return performWithCustomElementReactions(() => this[INSERT_NODE](child, null));
 	}
 	insertBefore(child, ref) {
-		this.insertInto(child, ref || null);
+		return performWithCustomElementReactions(() => this[INSERT_NODE](child, ref || null));
 	}
 	append(...nodes) {
-		for (const child of nodes) {
-			if (child == null) continue;
-			this.appendChild(toNode(this, child));
-		}
+		return performWithCustomElementReactions(() => {
+			const staged = stageNodes(nodes.filter((node) => node != null));
+			if (staged.length > 1) validateInsertionNodes(this, staged);
+			for (const child of staged) this[INSERT_NODE](toNode(this, child), null);
+		});
 	}
 	prepend(...nodes) {
-		const before = this.firstChild;
-		for (const child of nodes) {
-			if (child == null) continue;
-			this.insertBefore(toNode(this, child), before);
-		}
+		return performWithCustomElementReactions(() => {
+			const staged = stageNodes(nodes.filter((node) => node != null));
+			if (staged.length > 1) validateInsertionNodes(this, staged);
+			const before = this.firstChild;
+			for (const child of staged) this[INSERT_NODE](toNode(this, child), before);
+		});
 	}
 	replaceChildren(...nodes) {
-		let child;
-		while (child = this.firstChild) this.removeChild(child);
-		this.append(...nodes);
+		return performWithCustomElementReactions(() => {
+			const staged = stageNodes(nodes.filter((node) => node != null));
+			validateInsertionNodes(this, staged);
+			let child;
+			while (child = this.firstChild) this.removeChildImmediately(child);
+			for (const node of staged) this[INSERT_NODE](toNode(this, node), null);
+		});
 	}
 	removeChild(child) {
-		if (child.parentNode !== this) throw Error(`not a child of this node`);
-		const prev = child[PREV];
-		const next = child[NEXT];
-		if (prev) prev[NEXT] = next;
-		else this[CHILD] = next;
-		if (next) next[PREV] = prev;
-		const childNodes = this.childNodes;
-		const childNodesIndex = childNodes.indexOf(child);
-		childNodes.splice(childNodesIndex, 1);
-		if (child.nodeType === 1) {
-			const children = this.children;
-			children.splice(children.indexOf(child), 1);
-		}
-		child[PARENT] = null;
-		child[NEXT] = null;
-		child[PREV] = null;
-		if (this[IS_CONNECTED]) for (const node of selfAndDescendants(child)) {
-			node[IS_CONNECTED] = false;
-			node.disconnectedCallback?.();
-		}
-		if (this.nodeType === NodeType$1.ELEMENT_NODE) this[HOOKS].removeChild?.(this, child, childNodesIndex);
+		return performWithCustomElementReactions(() => {
+			this.removeChildImmediately(child);
+			return child;
+		});
+	}
+	removeChildImmediately(child) {
+		if (child.parentNode !== this) throw createDOMException("The node is not a child of this node", "NotFoundError");
+		const disconnectedNodes = this[IS_CONNECTED] ? selfAndDescendants(child) : void 0;
+		const previousSibling = child[PREV];
+		const nextSibling = child[NEXT];
+		const childNodesIndex = detachChild(this, child);
+		if (disconnectedNodes) for (const node of disconnectedNodes) node[IS_CONNECTED] = false;
+		this.queueRemovalMutationRecord(this, child, previousSibling, nextSibling);
+		if (disconnectedNodes) this.enqueueTreeReactions(disconnectedNodes, "disconnectedCallback");
+		performHookEffects(this.collectRemovalHookEffects(child, childNodesIndex));
 	}
 	replaceChild(newChild, oldChild) {
-		if (oldChild.parentNode !== this) throw Error("reference node is not a child of this parent");
+		return performWithCustomElementReactions(() => this[REPLACE_NODE](newChild, oldChild));
+	}
+	[REPLACE_NODE](newChild, oldChild, hookEffects) {
+		validateInsertionNodes(this, [newChild]);
+		if (oldChild.parentNode !== this) throw createDOMException("The reference node is not a child of this parent", "NotFoundError");
+		const previous = oldChild[PREV];
 		const next = oldChild[NEXT];
-		this.removeChild(oldChild);
-		this.insertInto(newChild, next);
+		const insertion = this.prepareInsertion(newChild);
+		const removedNodes = this[IS_CONNECTED] ? selfAndDescendants(oldChild) : void 0;
+		const insertionRoots = new Set(insertion.map(({ node }) => node));
+		let before = next;
+		while (before && insertionRoots.has(before)) before = before[NEXT];
+		const oldChildIndex = detachChild(this, oldChild);
+		if (removedNodes) {
+			for (const node of removedNodes) node[IS_CONNECTED] = false;
+			const removedNodeSet = new Set(removedNodes);
+			for (const prepared of insertion) if (removedNodeSet.has(prepared.node)) prepared.shouldDisconnect = false;
+		}
+		this.commitInsertion(insertion, before);
+		const destinationIsConnected = this[IS_CONNECTED];
+		this.queueRemovalMutationRecord(this, oldChild, previous, next);
+		this.queueInsertionMutationRecords(insertion);
+		if (removedNodes) this.enqueueTreeReactions(removedNodes, "disconnectedCallback");
+		this.enqueueInsertionReactions(insertion, destinationIsConnected);
+		this.performOrCollectHookEffects([...this.collectRemovalHookEffects(oldChild, oldChildIndex), ...this.collectInsertionHookEffects(insertion)], hookEffects);
+		return oldChild;
 	}
 	querySelectorAll(selector) {
 		return querySelectorAll(this, selector);
@@ -685,22 +1299,99 @@ var ParentNode = class extends ChildNode {
 	querySelector(selector) {
 		return querySelector(this, selector);
 	}
-	insertInto(child, before) {
-		if (child.nodeType === NodeType$1.DOCUMENT_FRAGMENT_NODE) {
+	[INSERT_NODE](child, before, hookEffects) {
+		this.validateInsertion(child, before);
+		this.insertIntoValidated(child, before, hookEffects);
+		return child;
+	}
+	[PREFLIGHT_INSERTIONS](children) {
+		for (const child of children) {
+			this.validateInsertion(child, null);
+			this.prepareInsertion(child);
+		}
+	}
+	validateInsertion(child, before) {
+		validateInsertionNodes(this, [child]);
+		if (before && before.parentNode !== this) throw createDOMException("The reference node is not a child of this parent", "NotFoundError");
+	}
+	insertIntoValidated(child, before, hookEffects) {
+		if (child === before) before = child[NEXT];
+		const insertion = this.prepareInsertion(child);
+		this.commitInsertion(insertion, before);
+		const destinationIsConnected = this[IS_CONNECTED];
+		this.queueInsertionMutationRecords(insertion);
+		this.enqueueInsertionReactions(insertion, destinationIsConnected);
+		this.performOrCollectHookEffects(this.collectInsertionHookEffects(insertion), hookEffects);
+	}
+	performOrCollectHookEffects(effects, hookEffects) {
+		if (hookEffects) hookEffects.push(...effects);
+		else performHookEffects(effects);
+	}
+	prepareInsertion(child) {
+		const roots = [];
+		if (child.nodeType === 11) {
 			let node = child[CHILD];
 			while (node) {
-				const next = node[NEXT];
-				this.insertInto(node, before);
-				node = next;
+				roots.push(node);
+				node = node[NEXT];
+			}
+		} else roots.push(child);
+		const destinationIsConnected = this[IS_CONNECTED];
+		const ownerDocument = this[OWNER_DOCUMENT];
+		const insertion = [];
+		for (const node of roots) {
+			const wasConnected = node[IS_CONNECTED];
+			const shouldTraverse = wasConnected || destinationIsConnected;
+			let nodes;
+			let adoption;
+			if (node[OWNER_DOCUMENT] === ownerDocument) {
+				if (shouldTraverse) nodes = selfAndDescendants(node);
+			} else {
+				const snapshot = collectAdoptionSnapshot(node);
+				adoption = snapshot.nodes;
+				if (shouldTraverse) nodes = snapshot.treeNodes;
+			}
+			insertion.push({
+				node,
+				nodes,
+				adoption,
+				shouldDisconnect: wasConnected
+			});
+		}
+		return insertion;
+	}
+	commitInsertion(insertion, before) {
+		for (const prepared of insertion) {
+			const sourceParent = prepared.node[PARENT];
+			if (sourceParent) {
+				const previousSibling = prepared.node[PREV];
+				const nextSibling = prepared.node[NEXT];
+				prepared.source = {
+					parent: sourceParent,
+					index: detachChild(sourceParent, prepared.node),
+					previousSibling,
+					nextSibling
+				};
 			}
-			return;
 		}
-		if (child.parentNode !== null) child.parentNode.removeChild(child);
+		for (const prepared of insertion) {
+			const attached = this.attachChild(prepared.node, before);
+			prepared.insertIndex = attached.index;
+			prepared.previousSibling = attached.previousSibling;
+			prepared.nextSibling = attached.nextSibling;
+		}
+		const ownerDocument = this[OWNER_DOCUMENT];
+		for (const { adoption } of insertion) if (adoption) adoptNodes(adoption, ownerDocument);
+		const isConnected = this[IS_CONNECTED];
+		for (const { nodes } of insertion) if (nodes) for (const node of nodes) node[IS_CONNECTED] = isConnected;
+	}
+	attachChild(child, before) {
 		if (before) {
-			if (before.parentNode !== this) throw Error("reference node is not a child of this parent");
+			const previous = before[PREV];
 			child[NEXT] = before;
-			child[PREV] = before[PREV];
-			if (before[PREV] === null) this[CHILD] = child;
+			child[PREV] = previous;
+			if (previous) previous[NEXT] = child;
+			else this[CHILD] = child;
 			before[PREV] = child;
 		} else {
 			child[NEXT] = null;
@@ -715,34 +1406,127 @@ var ParentNode = class extends ChildNode {
 				child[PREV] = null;
 			}
 		}
-		const ownerDocument = this[OWNER_DOCUMENT];
-		const isElement = child.nodeType === NodeType$1.ELEMENT_NODE;
+		const isElement = isElementNode(child);
 		child[PARENT] = this;
-		child[OWNER_DOCUMENT] = ownerDocument;
-		const childNodes = this.childNodes;
 		let insertIndex;
 		if (before) {
-			insertIndex = childNodes.indexOf(before);
-			childNodes.splice(insertIndex, 0, child);
+			insertIndex = this.childNodes.indexOf(before);
+			this.childNodes.splice(insertIndex, 0, child);
 			if (isElement) {
-				const children = this.children;
-				let ref = before;
-				while (ref && ref.nodeType !== 1) ref = ref[NEXT];
-				if (ref) children.splice(children.indexOf(ref), 0, child);
-				else children.push(child);
+				let reference = before;
+				while (reference && !isElementNode(reference)) reference = reference[NEXT];
+				if (reference) this.children.splice(this.children.indexOf(reference), 0, child);
+				else this.children.push(child);
 			}
 		} else {
-			insertIndex = childNodes.length;
-			childNodes.push(child);
+			insertIndex = this.childNodes.length;
+			this.childNodes.push(child);
 			if (isElement) this.children.push(child);
 		}
-		if (this[IS_CONNECTED]) for (const node of selfAndDescendants(child)) {
-			node[IS_CONNECTED] = true;
-			node.connectedCallback?.();
+		return {
+			index: insertIndex,
+			previousSibling: child[PREV],
+			nextSibling: child[NEXT]
+		};
+	}
+	queueRemovalMutationRecord(parent, child, previousSibling, nextSibling) {
+		if (!childListObserversActive) return;
+		queueMutationRecord({
+			type: "childList",
+			target: parent,
+			removedNodes: mutationNodeList(child),
+			previousSibling,
+			nextSibling
+		});
+	}
+	queueInsertionMutationRecords(insertion) {
+		if (!childListObserversActive) return;
+		for (const prepared of insertion) {
+			const { node, source } = prepared;
+			if (source) this.queueRemovalMutationRecord(source.parent, node, source.previousSibling, source.nextSibling);
+			queueMutationRecord({
+				type: "childList",
+				target: this,
+				addedNodes: mutationNodeList(node),
+				previousSibling: prepared.previousSibling,
+				nextSibling: prepared.nextSibling
+			});
+		}
+	}
+	collectRemovalHookEffects(child, childNodesIndex) {
+		if (this.nodeType !== 1 || isCoveredByPendingPublication(this)) return [];
+		return [[() => this[HOOKS].removeChild?.(this, child, childNodesIndex)]];
+	}
+	collectInsertionHookEffects(insertion) {
+		const effects = [];
+		for (const prepared of insertion) {
+			const { node, source } = prepared;
+			if (source?.parent.nodeType === 1 && !isCoveredByPendingPublication(source.parent)) effects.push([() => source.parent[HOOKS].removeChild?.(source.parent, node, source.index)]);
+			if (this.nodeType === 1 && !isCoveredByPendingPublication(this)) effects.push([() => this[HOOKS].insertChild?.(this, node, prepared.insertIndex), node]);
 		}
-		if (this.nodeType === NodeType$1.ELEMENT_NODE) this[HOOKS].insertChild?.(this, child, insertIndex);
+		return effects;
+	}
+	enqueueInsertionReactions(insertion, destinationIsConnected) {
+		for (const prepared of insertion) {
+			const { nodes } = prepared;
+			if (nodes) {
+				if (prepared.shouldDisconnect) this.enqueueTreeReactions(nodes, "disconnectedCallback");
+				if (destinationIsConnected) this.enqueueTreeReactions(nodes, "connectedCallback");
+			}
+		}
+	}
+	enqueueTreeReactions(nodes, callbackName) {
+		enqueueTreeReactions(nodes, callbackName);
 	}
 };
+function removeChildForAdoption(parent, child, adoption, destination) {
+	if (child.parentNode !== parent) throw Error(`not a child of this node`);
+	const disconnectedNodes = parent[IS_CONNECTED] ? adoption.treeNodes : void 0;
+	const previousSibling = child[PREV];
+	const nextSibling = child[NEXT];
+	const childNodesIndex = detachChild(parent, child);
+	if (disconnectedNodes) for (const node of disconnectedNodes) node[IS_CONNECTED] = false;
+	adoptNodes(adoption.nodes, destination);
+	if (childListObserversActive) queueMutationRecord({
+		type: "childList",
+		target: parent,
+		removedNodes: mutationNodeList(child),
+		previousSibling,
+		nextSibling
+	});
+	if (disconnectedNodes) enqueueTreeReactions(disconnectedNodes, "disconnectedCallback");
+	const effects = [];
+	if (parent.nodeType === 1 && !isCoveredByPendingPublication(parent)) effects.push([() => parent[HOOKS].removeChild?.(parent, child, childNodesIndex)]);
+	performHookEffects(effects);
+}
+function detachChild(parent, child) {
+	const previous = child[PREV];
+	const next = child[NEXT];
+	if (previous) previous[NEXT] = next;
+	else parent[CHILD] = next;
+	if (next) next[PREV] = previous;
+	const childNodesIndex = parent.childNodes.indexOf(child);
+	parent.childNodes.splice(childNodesIndex, 1);
+	if (isElementNode(child)) parent.children.splice(parent.children.indexOf(child), 1);
+	child[PARENT] = null;
+	child[NEXT] = null;
+	child[PREV] = null;
+	return childNodesIndex;
+}
+function enqueueTreeReactions(nodes, callbackName) {
+	for (const node of nodes) {
+		const callback = node[callbackName];
+		if (typeof callback === "function") enqueueCustomElementReaction(node, () => callback.call(node));
+	}
+}
+//#endregion
+//#region node_modules/@remote-dom/polyfill/build/esm/attribute-reactions.mjs
+function enqueueAttributeReaction(element, localName, oldValue, newValue, namespace) {
+	const { observedAttributes } = element.constructor;
+	const { attributeChangedCallback } = element;
+	if (attributeChangedCallback == null || observedAttributes == null || !observedAttributes.includes(localName)) return;
+	enqueueCustomElementReaction(element, () => attributeChangedCallback.call(element, localName, oldValue, newValue, namespace));
+}
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/NamedNodeMap.mjs
 var NamedNodeMap = class {
@@ -751,12 +1535,21 @@ var NamedNodeMap = class {
 		this[OWNER_ELEMENT] = ownerElement;
 	}
 	getNamedItem(name) {
-		return this.getNamedItemNS(null, name);
+		const qualifiedName = String(name);
+		const normalizedName = this[OWNER_ELEMENT][NS] === "http://www.w3.org/1999/xhtml" ? asciiLowercase(qualifiedName) : qualifiedName;
+		let attr = this[CHILD];
+		while (attr) {
+			if (attr.name === normalizedName) return attr;
+			attr = attr[NEXT];
+		}
+		return null;
 	}
-	getNamedItemNS(namespaceURI, name) {
+	getNamedItemNS(namespaceURI, localName) {
+		const namespace = normalizeNamespace(namespaceURI);
+		const normalizedLocalName = String(localName);
 		let attr = this[CHILD];
 		while (attr) {
-			if (attr.name === name && attr[NS] == namespaceURI) return attr;
+			if (attr.localName === normalizedLocalName && attr[NS] === namespace) return attr;
 			attr = attr[NEXT];
 		}
 		return null;
@@ -780,18 +1573,35 @@ var NamedNodeMap = class {
 		return index;
 	}
 	removeNamedItem(name) {
-		return this.removeNamedItemNS(null, name);
+		const qualifiedName = String(name);
+		const normalizedName = this[OWNER_ELEMENT][NS] === "http://www.w3.org/1999/xhtml" ? asciiLowercase(qualifiedName) : qualifiedName;
+		return performWithCustomElementReactions(() => this.removeNamedItemImmediately((attr) => attr.name === normalizedName));
+	}
+	removeNamedItemNS(namespaceURI, localName) {
+		const namespace = normalizeNamespace(namespaceURI);
+		const normalizedLocalName = String(localName);
+		return performWithCustomElementReactions(() => this.removeNamedItemImmediately((attr) => attr.localName === normalizedLocalName && attr[NS] === namespace));
 	}
-	removeNamedItemNS(namespaceURI, name) {
+	removeNamedItemImmediately(matches) {
 		const ownerElement = this[OWNER_ELEMENT];
 		let attr = this[CHILD];
 		let prev = null;
 		while (attr != null) {
-			if (attr.name === name && attr[NS] == namespaceURI) {
+			if (matches(attr)) {
 				if (prev) prev[NEXT] = attr[NEXT];
 				if (this[CHILD] === attr) this[CHILD] = attr[NEXT];
-				updateElementAttribute(ownerElement, attr.name, attr.value, null);
-				ownerElement[HOOKS].removeAttribute?.(ownerElement, name, namespaceURI);
+				const oldValue = attr.value;
+				attr[NEXT] = null;
+				attr[OWNER_ELEMENT] = null;
+				if (attributeObserversActive) queueMutationRecord({
+					type: "attributes",
+					target: ownerElement,
+					attributeName: attr.name,
+					attributeNamespace: attr[NS],
+					oldValue
+				});
+				ownerElement[HOOKS].removeAttribute?.(ownerElement, attr.name, attr[NS]);
+				enqueueAttributeReaction(ownerElement, attr.localName, oldValue, null, attr[NS]);
 				return attr;
 			}
 			prev = attr;
@@ -800,32 +1610,47 @@ var NamedNodeMap = class {
 		return null;
 	}
 	setNamedItem(attr) {
+		return performWithCustomElementReactions(() => this.setNamedItemImmediately(attr));
+	}
+	setNamedItemImmediately(attr) {
 		const ownerElement = this[OWNER_ELEMENT];
+		const currentOwner = attr[OWNER_ELEMENT];
+		if (currentOwner != null && currentOwner !== ownerElement) throw createDOMException("The attribute is already in use by another element.", "InUseAttributeError");
 		let old = null;
 		let child = this[CHILD];
-		attr[OWNER_ELEMENT] = ownerElement;
-		if (child == null) this[CHILD] = attr;
-		else {
-			let prev;
-			while (child) {
-				if (child.name === attr.name && child[NS] == attr[NS]) {
-					if (prev) prev[NEXT] = attr;
-					else this[CHILD] = attr;
-					attr[NEXT] = child[NEXT];
-					child[NEXT] = null;
-					old = child;
-					break;
-				}
-				prev = child;
-				child = child[NEXT];
+		let prev = null;
+		while (child) {
+			if (child.localName === attr.localName && child[NS] === attr[NS]) {
+				if (child === attr) return child;
+				if (prev) prev[NEXT] = attr;
+				else this[CHILD] = attr;
+				attr[NEXT] = child[NEXT];
+				child[NEXT] = null;
+				old = child;
+				break;
 			}
+			prev = child;
+			child = child[NEXT];
+		}
+		if (old == null) {
 			if (prev) prev[NEXT] = attr;
 			else this[CHILD] = attr;
 		}
-		if (!old || old.value !== attr.value) {
-			updateElementAttribute(ownerElement, attr.name, old?.value ?? null, attr.value);
-			ownerElement[HOOKS].setAttribute?.(ownerElement, attr.name, attr.value, attr[NS]);
-		}
+		attr[OWNER_ELEMENT] = ownerElement;
+		attr[OWNER_DOCUMENT] = ownerElement[OWNER_DOCUMENT];
+		if (old) old[OWNER_ELEMENT] = null;
+		const valueChanged = old == null || old.value !== attr.value;
+		const qualifiedNameChanged = old != null && old.name !== attr.name;
+		if (valueChanged && attributeObserversActive) queueMutationRecord({
+			type: "attributes",
+			target: ownerElement,
+			attributeName: attr.name,
+			attributeNamespace: attr[NS],
+			oldValue: old?.value ?? null
+		});
+		if (qualifiedNameChanged) ownerElement[HOOKS].removeAttribute?.(ownerElement, old.name, old[NS]);
+		if (valueChanged || qualifiedNameChanged) ownerElement[HOOKS].setAttribute?.(ownerElement, attr.name, attr.value, attr[NS]);
+		if (valueChanged) enqueueAttributeReaction(ownerElement, attr.localName, old?.value ?? null, attr.value, attr[NS]);
 		return old;
 	}
 	setNamedItemNS(attr) {
@@ -839,17 +1664,10 @@ var NamedNodeMap = class {
 		}
 	}
 };
-function updateElementAttribute(element, name, oldValue, newValue) {
-	const { observedAttributes } = element.constructor;
-	const { attributeChangedCallback } = element;
-	if (name === "slot") element.slot = newValue ?? "";
-	if (attributeChangedCallback == null || observedAttributes == null || !observedAttributes.includes(name)) return;
-	return attributeChangedCallback.call(element, name, oldValue, newValue);
-}
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/Attr.mjs
 var Attr = class extends Node$2 {
-	nodeType = (() => NodeType$1.ATTRIBUTE_NODE)();
+	nodeType = 2;
 	[NS] = null;
 	[NEXT] = null;
 	[OWNER_ELEMENT] = null;
@@ -867,15 +1685,39 @@ var Attr = class extends Node$2 {
 		return this[NAME];
 	}
 	set name(_readonly) {}
+	get localName() {
+		if (this[NS] == null) return this[NAME];
+		const separator = this[NAME].indexOf(":");
+		return separator < 0 ? this[NAME] : this[NAME].slice(separator + 1);
+	}
+	get prefix() {
+		if (this[NS] == null) return null;
+		const separator = this[NAME].indexOf(":");
+		return separator < 0 ? null : this[NAME].slice(0, separator);
+	}
 	get value() {
 		return this[VALUE];
 	}
 	set value(value) {
 		const str = String(value);
-		this[VALUE] = str;
 		const ownerElement = this[OWNER_ELEMENT];
-		if (!ownerElement) return;
-		this[HOOKS].setAttribute?.(ownerElement, this[NAME], str, this[NS]);
+		if (!ownerElement) {
+			this[VALUE] = str;
+			return;
+		}
+		performWithCustomElementReactions(() => {
+			const oldValue = this[VALUE];
+			this[VALUE] = str;
+			if (attributeObserversActive && oldValue !== str) queueMutationRecord({
+				type: "attributes",
+				target: ownerElement,
+				attributeName: this[NAME],
+				attributeNamespace: this[NS],
+				oldValue
+			});
+			this[HOOKS].setAttribute?.(ownerElement, this[NAME], str, this[NS]);
+			enqueueAttributeReaction(ownerElement, this.localName, oldValue, str, this[NS]);
+		});
 	}
 	get nodeValue() {
 		return this.value;
@@ -895,83 +1737,223 @@ var Attr = class extends Node$2 {
 };
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/serialization.mjs
-var elementTokenizer = /(?:<([a-z][a-z0-9-:]*)((?:[\s]+[^<>'"=\s]+(?:=(['"])[^]*?\3|=[^>'"\s]*|))*)[\s]*(\/?)\s*>|<\/([a-z][a-z0-9-:]*)>|<!--(.*?)-->|([^&<>]+))/gi;
-var attributeTokenizer = /\s([^<>'"=\n\s]+)(?:=(["'])([\s\S]*?)\2|=([^>'"\n\s]*)|)/g;
+var CHARACTER_REFERENCES = {
+	amp: "&",
+	AMP: "&",
+	apos: "'",
+	gt: ">",
+	GT: ">",
+	lt: "<",
+	LT: "<",
+	quot: "\"",
+	QUOT: "\""
+};
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+var ELEMENT_TOKENIZER = /(?:<([a-z][a-z0-9-:]*)((?:[\s]+[^<>'"=/\s]+(?:=(['"])[^]*?\3|=[^>'"\s]*|))*)[\s]*(\/?)\s*>|<\/([a-z][a-z0-9-:]*)>|<!--(.*?)-->|([^<>]+))/gi;
+var ATTRIBUTE_TOKENIZER = /\s([^<>'"=/\n\s]+)(?:=(["'])([\s\S]*?)\2|=([^>'"\n\s]*)|)/g;
+var SVG_HTML_BREAKOUTS = "|b|big|blockquote|body|br|center|code|dd|div|dl|dt|em|embed|h1|h2|h3|h4|h5|h6|head|hr|i|img|li|listing|menu|meta|nobr|ol|p|pre|ruby|s|small|span|strong|strike|sub|sup|table|tt|u|ul|var|";
+var SVG_HTML_FONT_ATTRIBUTE = /^(?:color|face|size)$/i;
+function decodeCharacterReferences(value) {
+	return value.replace(/&(?:(amp|AMP|apos|gt|GT|lt|LT|quot|QUOT)|#(\d+)|#[xX]([\da-fA-F]+));/g, (reference, name, decimal, hexadecimal) => {
+		if (name) return CHARACTER_REFERENCES[name];
+		const codePoint = Number.parseInt(decimal ?? hexadecimal, decimal ? 10 : 16);
+		try {
+			return String.fromCodePoint(codePoint);
+		} catch {
+			return reference;
+		}
+	});
+}
+function isVoidElement(element) {
+	return element.namespaceURI === "http://www.w3.org/1999/xhtml" && VOID_ELEMENTS.has(element.localName);
+}
+function isHtmlIntegrationPoint(element) {
+	const name = element.localName;
+	return element[NS] === "http://www.w3.org/2000/svg" && (name === "foreignObject" || name === "desc" || name === "title");
+}
+function isSvgHtmlBreakout(tag, attributes) {
+	if (SVG_HTML_BREAKOUTS.includes(`|${tag}|`)) return true;
+	if (tag !== "font") return false;
+	for (const attribute of attributes.matchAll(ATTRIBUTE_TOKENIZER)) if (SVG_HTML_FONT_ATTRIBUTE.test(attribute[1])) return true;
+	return false;
+}
 function parseHtml(html, contextNode) {
 	const document = contextNode.ownerDocument;
 	const root = document.createDocumentFragment();
-	const stack = [root];
+	const stack = [];
 	let parent = root;
-	let token;
-	elementTokenizer.lastIndex = 0;
-	while (token = elementTokenizer.exec(html)) {
+	for (const token of html.matchAll(ELEMENT_TOKENIZER)) {
 		const tag = token[1];
 		if (tag) {
-			const node = document.createElement(tag);
 			const attrs = token[2];
-			attributeTokenizer.lastIndex = 0;
-			let t;
-			while (t = attributeTokenizer.exec(attrs)) node.setAttribute(t[1], t[3] || t[4] || "");
+			const normalizedTag = asciiLowercase(tag);
+			const openElement = stack[stack.length - 1]?.element ?? contextNode;
+			let namespace = openElement[NS] === "http://www.w3.org/2000/svg" ? SVG_NAMESPACE : HTML_NAMESPACE;
+			if (normalizedTag === "svg") namespace = SVG_NAMESPACE;
+			else if (namespace === "http://www.w3.org/2000/svg") {
+				if (isHtmlIntegrationPoint(openElement)) namespace = HTML_NAMESPACE;
+				else if (isSvgHtmlBreakout(normalizedTag, attrs)) {
+					while (stack.length > 0) {
+						const frame = stack[stack.length - 1];
+						if (frame.element[NS] !== "http://www.w3.org/2000/svg" || isHtmlIntegrationPoint(frame.element)) break;
+						stack.pop();
+						parent = frame.target;
+					}
+					namespace = HTML_NAMESPACE;
+				}
+			}
+			const name = namespace === "http://www.w3.org/1999/xhtml" ? normalizedTag : tag;
+			const node = document[CREATE_ELEMENT](name, namespace, null, name);
+			for (const attribute of attrs.matchAll(ATTRIBUTE_TOKENIZER)) node.setAttribute(attribute[1], decodeCharacterReferences(attribute[3] || attribute[4] || ""));
 			parent.append(node);
-			stack.push(parent);
-			parent = node;
-		} else if (token[5]) parent = stack.pop() || root;
-		else if (token[6]) parent.append(document.createComment(token[6]));
-		else parent.append(token[7]);
+			if (isVoidElement(node) || namespace !== "http://www.w3.org/1999/xhtml" && token[4]) continue;
+			stack.push({
+				element: node,
+				target: parent
+			});
+			parent = namespace === "http://www.w3.org/1999/xhtml" && normalizedTag === "template" ? node.content : node;
+		} else if (token[5]) {
+			const closingTag = asciiLowercase(token[5]);
+			for (let index = stack.length - 1; index >= 0; index--) {
+				const frame = stack[index];
+				const frameName = asciiLowercase(frame.element[NAME]);
+				if (frameName === closingTag) {
+					parent = frame.target;
+					stack.length = index;
+					break;
+				}
+				if (frame.element[NS] === "http://www.w3.org/1999/xhtml" && frameName === "template") break;
+			}
+		} else if (token[6]) parent.append(document.createComment(token[6]));
+		else parent.append(decodeCharacterReferences(token[7]));
 	}
 	return root;
 }
 function serializeChildren(parentNode) {
-	let out = "";
-	let child = parentNode[CHILD];
-	while (child) {
-		out += serializeNode(child);
-		child = child[NEXT];
-	}
-	return out;
+	return serialize([{
+		type: "content",
+		child: parentNode[CHILD]
+	}]);
 }
 function serializeNode(node) {
-	switch (node.nodeType) {
-		case NodeType$1.ELEMENT_NODE: {
-			const el = node;
-			let out = `<${el[NAME]}`;
-			let attr = el[ATTRIBUTES]?.[CHILD];
-			while (attr) {
-				out += ` ${attr[NAME]}`;
-				let value = attr[VALUE];
-				if (value !== "") {
-					value = String(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;");
-					out += `="${value}"`;
-				}
-				attr = attr[NEXT];
-			}
-			out += ">";
-			out += serializeChildren(el);
-			out += `</${el[NAME]}>`;
-			return out;
+	return serialize([{
+		type: "opening",
+		node
+	}]);
+}
+function serialize(workItems) {
+	const chunks = [];
+	let workItem;
+	while (workItem = workItems.pop()) switch (workItem.type) {
+		case "opening": {
+			const node = workItem.node;
+			switch (node.nodeType) {
+				case 1: {
+					const el = node;
+					chunks.push(`<${el[NAME]}`);
+					let attr = el[ATTRIBUTES]?.[CHILD];
+					while (attr) {
+						chunks.push(` ${attr[NAME]}`);
+						let value = attr[VALUE];
+						if (value !== "") {
+							value = String(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+							chunks.push(`="${value}"`);
+						}
+						attr = attr[NEXT];
+					}
+					chunks.push(">");
+					if (isVoidElement(el)) break;
+					const content = el.namespaceURI === "http://www.w3.org/1999/xhtml" && el.localName === "template" ? el[CONTENT] : el;
+					workItems.push({
+						type: "closing",
+						name: el[NAME]
+					});
+					workItems.push({
+						type: "content",
+						child: content?.[CHILD] ?? null
+					});
+					break;
+				}
+				case 3: {
+					const text = node;
+					chunks.push(text[DATA].replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+					break;
+				}
+				case 8: {
+					const text = node;
+					chunks.push(`<!--${text[DATA]}-->`);
+					break;
+				}
+			}
+			break;
 		}
-		case NodeType$1.TEXT_NODE: return node[DATA].replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-		case NodeType$1.COMMENT_NODE: return `<!--${node[DATA]}-->`;
+		case "content": {
+			const child = workItem.child;
+			if (child) {
+				workItems.push({
+					type: "content",
+					child: child[NEXT]
+				});
+				workItems.push({
+					type: "opening",
+					node: child
+				});
+			}
+			break;
+		}
+		case "closing": chunks.push(`</${workItem.name}>`);
 	}
-	return "";
+	return chunks.join("");
 }
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/Element.mjs
 var Element$2 = class extends ParentNode {
-	nodeType = (() => NodeType$1.ELEMENT_NODE)();
-	[NS] = (() => NamespaceURI.XHTML)();
+	nodeType = 1;
+	[NS] = HTML_NAMESPACE;
+	[PREFIX] = null;
 	get namespaceURI() {
 		return this[NS];
 	}
+	get prefix() {
+		return this[PREFIX];
+	}
+	get localName() {
+		const prefix = this[PREFIX];
+		return prefix == null ? this[NAME] : this[NAME].slice(prefix.length + 1);
+	}
+	get nodeName() {
+		return this[NS] === "http://www.w3.org/1999/xhtml" ? asciiUppercase(this[NAME]) : this[NAME];
+	}
 	get tagName() {
 		return this.nodeName;
 	}
+	get id() {
+		return this.getAttributeNS(null, "id") ?? "";
+	}
+	set id(id) {
+		this.setAttribute("id", String(id));
+	}
 	get slot() {
-		return this.getAttribute("slot") ?? "";
+		return this.getAttributeNS(null, "slot") ?? "";
 	}
 	set slot(slot) {
 		const finalSlot = String(slot);
-		if (this.getAttribute("slot") !== finalSlot) this.attributes.setNamedItem(new Attr("slot", finalSlot));
+		if (this.getAttributeNS(null, "slot") !== finalSlot) this.attributes.setNamedItem(new Attr("slot", finalSlot));
 	}
 	get attributes() {
 		let attributes = this[ATTRIBUTES];
@@ -984,9 +1966,15 @@ var Element$2 = class extends ParentNode {
 	getAttributeNames() {
 		return [...this.attributes].map((attr) => attr.name);
 	}
+	getElementsByTagName(qualifiedName) {
+		return getElementsByTagName(this, qualifiedName);
+	}
 	get firstElementChild() {
 		return this.children[0] ?? null;
 	}
+	getElementsByClassName(classNames) {
+		return getElementsByClassName(this, classNames);
+	}
 	get lastElementChild() {
 		return this.children[this.children.length - 1] ?? null;
 	}
@@ -1001,10 +1989,37 @@ var Element$2 = class extends ParentNode {
 		return sib;
 	}
 	setAttribute(name, value) {
-		this.attributes.setNamedItem(new Attr(name, String(value)));
-	}
-	setAttributeNS(namespace, name, value) {
-		this.attributes.setNamedItemNS(new Attr(name, String(value), namespace));
+		const qualifiedName = String(name);
+		const normalizedValue = String(value);
+		validateAttributeLocalName(qualifiedName);
+		const normalizedName = this[NS] === "http://www.w3.org/1999/xhtml" ? asciiLowercase(qualifiedName) : qualifiedName;
+		const attribute = this.attributes.getNamedItemNS(null, normalizedName);
+		if (attribute) attribute.value = normalizedValue;
+		else this.attributes.setNamedItem(new Attr(normalizedName, normalizedValue));
+	}
+	setAttributeNS(namespace, qualifiedName, value) {
+		const normalizedNamespace = normalizeNamespace(namespace);
+		const normalizedQualifiedName = String(qualifiedName);
+		const normalizedValue = String(value);
+		const name = validateAndExtractQualifiedName(normalizedNamespace, normalizedQualifiedName, "attribute");
+		const attribute = this.attributes.getNamedItemNS(name.namespace, name.localName);
+		if (attribute) attribute.value = normalizedValue;
+		else this.attributes.setNamedItemNS(new Attr(name.qualifiedName, normalizedValue, name.namespace));
+	}
+	toggleAttribute(name, force) {
+		const qualifiedName = String(name);
+		validateAttributeLocalName(qualifiedName);
+		const normalizedName = this[NS] === "http://www.w3.org/1999/xhtml" ? asciiLowercase(qualifiedName) : qualifiedName;
+		const attribute = this.attributes.getNamedItemNS(null, normalizedName);
+		const normalizedForce = force === void 0 ? void 0 : Boolean(force);
+		if (attribute == null) {
+			if (normalizedForce === false) return false;
+			this.attributes.setNamedItem(new Attr(normalizedName, ""));
+			return true;
+		}
+		if (normalizedForce === true) return true;
+		this.attributes.removeNamedItemNS(null, normalizedName);
+		return false;
 	}
 	getAttribute(name) {
 		const attr = this.attributes.getNamedItem(name);
@@ -1021,7 +2036,9 @@ var Element$2 = class extends ParentNode {
 		return this.attributes.getNamedItemNS(namespace, name) != null;
 	}
 	removeAttribute(name) {
-		this.attributes.removeNamedItem(name);
+		const qualifiedName = String(name);
+		const normalizedName = this[NS] === "http://www.w3.org/1999/xhtml" ? asciiLowercase(qualifiedName) : qualifiedName;
+		this.attributes.removeNamedItemNS(null, normalizedName);
 	}
 	removeAttributeNS(namespace, name) {
 		this.attributes.removeNamedItemNS(namespace, name);
@@ -1043,7 +2060,7 @@ var Element$2 = class extends ParentNode {
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/SVGElement.mjs
 var SVGElement = class SVGElement extends Element$2 {
-	[NS] = (() => NamespaceURI.SVG)();
+	[NS] = SVG_NAMESPACE;
 	get ownerSVGElement() {
 		let root = null;
 		let parent = this.parentNode;
@@ -1063,9 +2080,16 @@ var CharacterData = class extends ChildNode {
 		this[DATA] = data == null ? "" : String(data);
 	}
 	setData(data) {
+		const shouldQueueMutation = characterDataObserversActive;
+		const oldValue = shouldQueueMutation ? this[DATA] : null;
 		let str = "";
 		if (data != null) str = typeof data === "string" ? data : String(data);
 		this[DATA] = str;
+		if (shouldQueueMutation && oldValue !== str) queueMutationRecord({
+			type: "characterData",
+			target: this,
+			oldValue
+		});
 		this[HOOKS].setText?.(this, str);
 	}
 	get data() {
@@ -1078,7 +2102,7 @@ var CharacterData = class extends ChildNode {
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/Text.mjs
 var Text = class extends CharacterData {
-	nodeType = (() => NodeType$1.TEXT_NODE)();
+	nodeType = 3;
 	[NAME] = "#text";
 };
 //#endregion
@@ -1090,9 +2114,12 @@ var Comment = class extends CharacterData {
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/DocumentFragment.mjs
 var DocumentFragment = class extends ParentNode {
-	nodeType = (() => NodeType$1.DOCUMENT_FRAGMENT_NODE)();
+	nodeType = 11;
 	[NAME] = "#document-fragment";
-	[OWNER_DOCUMENT] = (() => typeof window !== "undefined" ? window.document : null)();
+	[OWNER_DOCUMENT] = typeof window !== "undefined" ? window.document : null;
+	getElementById(elementId) {
+		return getElementById(this, elementId);
+	}
 };
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/HTMLTemplateElement.mjs
@@ -1101,6 +2128,7 @@ var HTMLTemplateElement = class extends Element$2 {
 		let content = this[CONTENT];
 		if (!content) {
 			content = this.ownerDocument.createDocumentFragment();
+			content[HOST] = this;
 			this[CONTENT] = content;
 		}
 		return content;
@@ -1126,7 +2154,7 @@ var HTMLHtmlElement = class extends Element$2 {};
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/Document.mjs
 var Document$1 = class extends ParentNode {
-	nodeType = (() => NodeType$1.DOCUMENT_NODE)();
+	nodeType = 9;
 	[NAME] = "#document";
 	[IS_CONNECTED] = true;
 	constructor(defaultView) {
@@ -1140,15 +2168,28 @@ var Document$1 = class extends ParentNode {
 		this.documentElement.appendChild(this.head);
 		this.documentElement.appendChild(this.body);
 	}
+	get textContent() {
+		return null;
+	}
+	set textContent(data) {}
+	getElementsByClassName(classNames) {
+		return getElementsByClassName(this, classNames);
+	}
 	createElement(localName) {
-		return createElement(this, localName);
+		const name = String(localName);
+		validateElementLocalName(name);
+		return createElement(this, asciiLowercase(name));
+	}
+	createElementNS(namespaceURI, qualifiedName) {
+		const name = validateAndExtractQualifiedName(namespaceURI, qualifiedName, "element");
+		return createElement(this, name.qualifiedName, name.namespace, name.prefix, name.localName);
 	}
-	createElementNS(namespaceURI, localName) {
-		return createElement(this, localName, namespaceURI);
+	[CREATE_ELEMENT](qualifiedName, namespace, prefix, localName) {
+		return createElement(this, qualifiedName, namespace, prefix, localName);
 	}
 	createTextNode(data) {
 		const text = createNode(new Text(data), this);
-		this[HOOKS].createText?.(text, String(data));
+		this[HOOKS].createText?.(text, text.data);
 		return text;
 	}
 	createComment(data) {
@@ -1160,14 +2201,25 @@ var Document$1 = class extends ParentNode {
 	createEvent() {
 		return new Event("");
 	}
+	getElementById(elementId) {
+		return getElementById(this, elementId);
+	}
+	getElementsByTagName(qualifiedName) {
+		return getElementsByTagName(this, qualifiedName);
+	}
 	importNode(node, deep) {
+		if (node.nodeType === 9) throw createDOMException("Cannot import a document node", "NotSupportedError");
 		return cloneNode(node, deep, this);
 	}
 	adoptNode(node) {
 		if (node[OWNER_DOCUMENT] === this) return node;
-		node.parentNode?.removeChild(node);
-		adoptNode(node, this);
-		return node;
+		const adoption = collectAdoptionSnapshot(node);
+		return performWithCustomElementReactions(() => {
+			const parent = node.parentNode;
+			if (parent) removeChildForAdoption(parent, node, adoption, this);
+			else adoptNodes(adoption.nodes, this);
+			return node;
+		});
 	}
 };
 function createNode(node, ownerDocument) {
@@ -1178,28 +2230,26 @@ function createNode(node, ownerDocument) {
 	});
 	return node;
 }
-function createElement(ownerDocument, name, namespace) {
+function createElement(ownerDocument, qualifiedName, namespace = HTML_NAMESPACE, prefix = null, localName = qualifiedName) {
 	let element;
-	const lowerName = String(name).toLowerCase();
-	if (namespace === NamespaceURI.SVG) element = new SVGElement();
-	else if (lowerName === "template") element = new HTMLTemplateElement();
-	else {
-		const CustomElement = ownerDocument.defaultView.customElements.get(name);
+	if (namespace === "http://www.w3.org/2000/svg") element = new SVGElement();
+	else if (namespace === "http://www.w3.org/1999/xhtml" && localName === "template") element = new HTMLTemplateElement();
+	else if (namespace === "http://www.w3.org/1999/xhtml") {
+		const CustomElement = ownerDocument.defaultView.customElements.get(localName);
 		element = CustomElement ? new CustomElement() : new Element$2();
-	}
-	return setupElement(element, ownerDocument, name, namespace);
+	} else element = new Element$2();
+	return setupElement(element, ownerDocument, qualifiedName, namespace, prefix);
 }
-function setupElement(element, ownerDocument, name, namespace) {
+function setupElement(element, ownerDocument, qualifiedName, namespace = HTML_NAMESPACE, prefix = null) {
 	createNode(element, ownerDocument);
-	Object.defineProperty(element, NAME, { value: name });
-	if (namespace) Object.defineProperty(element, NS, { value: namespace });
+	Object.defineProperties(element, {
+		[NAME]: { value: qualifiedName },
+		[NS]: { value: namespace },
+		[PREFIX]: { value: prefix }
+	});
 	ownerDocument[HOOKS].createElement?.(element, namespace);
 	return element;
 }
-function adoptNode(node, document) {
-	node[OWNER_DOCUMENT] = document;
-	if (isParentNode(node)) for (const child of node.childNodes) adoptNode(child, document);
-}
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/CustomEvent.mjs
 var CustomEvent = class extends Event {
@@ -1210,7 +2260,7 @@ var CustomEvent = class extends Event {
 	*/
 	constructor(type, eventInitDict) {
 		super(type, eventInitDict);
-		this.detail = eventInitDict?.detail;
+		this.detail = eventInitDict?.detail ?? null;
 	}
 	/**
 	* Returns any custom data event was created with. Typically used for synthetic events.
@@ -1219,7 +2269,7 @@ var CustomEvent = class extends Event {
 	*/
 	initCustomEvent(type, bubbles, cancelable, detail) {
 		super.initEvent(type, bubbles, cancelable);
-		this.detail = detail;
+		this.detail = detail ?? null;
 	}
 };
 //#endregion
@@ -1273,10 +2323,30 @@ var ClipboardEvent = class extends Event {
 var HTMLElement = class extends Element$2 {};
 //#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/CustomElementRegistry.mjs
+var VALID_CUSTOM_ELEMENT_NAME = /^[a-z][^A-Z\u0000\t\n\f\r />]*-[^A-Z\u0000\t\n\f\r />]*$/u;
+var RESERVED_CUSTOM_ELEMENT_NAMES = /* @__PURE__ */ new Set([
+	"annotation-xml",
+	"color-profile",
+	"font-face",
+	"font-face-src",
+	"font-face-uri",
+	"font-face-format",
+	"font-face-name",
+	"missing-glyph"
+]);
+function isValidCustomElementName(name) {
+	return VALID_CUSTOM_ELEMENT_NAME.test(name) && !RESERVED_CUSTOM_ELEMENT_NAMES.has(name);
+}
+function createInvalidCustomElementNameError(name) {
+	return createDOMException(`Invalid custom element name: "${name}"`, "SyntaxError");
+}
 var CustomElementRegistryImplementation = class {
-	registry = (() => /* @__PURE__ */ new Map())();
-	listenersByName = (() => /* @__PURE__ */ new Map())();
+	registry = /* @__PURE__ */ new Map();
+	listenersByName = /* @__PURE__ */ new Map();
 	define(name, Constructor, _options) {
+		if (!isValidCustomElementName(name)) throw createInvalidCustomElementNameError(name);
+		if (this.registry.has(name)) throw createDOMException(`A custom element named "${name}" has already been defined`, "NotSupportedError");
+		if (this.getName(Constructor) != null) throw createDOMException("This constructor has already been registered in this custom element registry", "NotSupportedError");
 		this.registry.set(name, Constructor);
 		const listeners = this.listenersByName.get(name);
 		if (listeners == null) return;
@@ -1291,6 +2361,7 @@ var CustomElementRegistryImplementation = class {
 		return null;
 	}
 	whenDefined(name) {
+		if (!isValidCustomElementName(name)) return Promise.reject(createInvalidCustomElementNameError(name));
 		const Constructor = this.registry.get(name);
 		if (Constructor != null) return Promise.resolve(Constructor);
 		let listeners = this.listenersByName.get(name);
@@ -1303,47 +2374,109 @@ var CustomElementRegistryImplementation = class {
 		});
 	}
 	upgrade(_root) {}
+	initialize(_root) {}
 };
 //#endregion
-//#region node_modules/@remote-dom/polyfill/build/esm/MutationObserver.mjs
-var MutationObserver = class {};
-//#endregion
 //#region node_modules/@remote-dom/polyfill/build/esm/Window.mjs
+var EVENT_HANDLER_PROPERTIES = ["onerror", "onunhandledrejection"];
+var POLYFILL_GLOBAL_PROPERTY = Symbol.for("@remote-dom/polyfill/global-property");
+function windowPropertyDescriptors(window) {
+	return Object.getOwnPropertyDescriptors(window);
+}
+function eventTargetPropertyDescriptors(window) {
+	const properties = {};
+	for (const [property, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(EventTarget.prototype))) if (property !== "constructor" && typeof descriptor.value === "function") {
+		descriptor.value = markPolyfillGlobalProperty(descriptor.value.bind(window));
+		properties[property] = descriptor;
+	}
+	return properties;
+}
+function eventHandlerPropertyDescriptors(window) {
+	const properties = {};
+	for (const property of EVENT_HANDLER_PROPERTIES) properties[property] = {
+		configurable: true,
+		enumerable: true,
+		get: markPolyfillGlobalProperty(() => window[property]),
+		set: markPolyfillGlobalProperty((handler) => {
+			window[property] = handler;
+		})
+	};
+	return properties;
+}
+function globalPropertyDescriptors(window) {
+	return Object.assign(windowPropertyDescriptors(window), eventTargetPropertyDescriptors(window), eventHandlerPropertyDescriptors(window));
+}
+function markPolyfillGlobalProperty(value) {
+	Object.defineProperty(value, POLYFILL_GLOBAL_PROPERTY, { value: true });
+	return value;
+}
+function installMissingGlobalProperties(target, properties) {
+	for (const property of Reflect.ownKeys(properties)) {
+		const currentDescriptor = findPropertyDescriptor(target, property);
+		if (currentDescriptor == null || isPolyfillGlobalProperty(currentDescriptor)) Object.defineProperty(target, property, properties[property]);
+	}
+}
+function findPropertyDescriptor(target, property) {
+	let currentTarget = target;
+	while (currentTarget) {
+		const descriptor = Object.getOwnPropertyDescriptor(currentTarget, property);
+		if (descriptor) return descriptor;
+		currentTarget = Object.getPrototypeOf(currentTarget);
+	}
+}
+function isPolyfillGlobalProperty(descriptor) {
+	return [
+		descriptor.value,
+		descriptor.get,
+		descriptor.set
+	].some((value) => typeof value === "function" && value[POLYFILL_GLOBAL_PROPERTY] === true);
+}
 var Window = class extends EventTarget {
 	[HOOKS] = {};
+	[EXTENSIONS] = [];
+	[HOOKS_DISPATCH] = createHooksDispatcher(this);
 	name = "";
 	window = this;
 	parent = this;
 	self = this;
 	top = this;
-	document = (() => new Document$1(this))();
-	customElements = (() => new CustomElementRegistryImplementation())();
-	location = (() => globalThis.location)();
-	navigator = (() => globalThis.navigator)();
-	Event = (() => Event)();
-	ErrorEvent = (() => ErrorEvent)();
-	PromiseRejectionEvent = (() => PromiseRejectionEvent)();
-	ToggleEvent = (() => ToggleEvent)();
-	FocusEvent = (() => FocusEvent)();
-	ClipboardEvent = (() => ClipboardEvent)();
-	EventTarget = (() => EventTarget)();
-	CustomEvent = (() => CustomEvent)();
-	Node = (() => Node$2)();
-	ParentNode = (() => ParentNode)();
-	ChildNode = (() => ChildNode)();
-	DocumentFragment = (() => DocumentFragment)();
-	Document = (() => Document$1)();
-	CharacterData = (() => CharacterData)();
-	Comment = (() => Comment)();
-	Text = (() => Text)();
-	Element = (() => Element$2)();
-	HTMLElement = (() => HTMLElement)();
-	SVGElement = (() => SVGElement)();
-	HTMLTemplateElement = (() => HTMLTemplateElement)();
-	MutationObserver = (() => MutationObserver)();
+	document = new Document$1(this);
+	customElements = new CustomElementRegistryImplementation();
+	location = globalThis.location;
+	navigator = globalThis.navigator;
+	Event = Event;
+	ErrorEvent = ErrorEvent;
+	PromiseRejectionEvent = PromiseRejectionEvent;
+	ToggleEvent = ToggleEvent;
+	FocusEvent = FocusEvent;
+	ClipboardEvent = ClipboardEvent;
+	EventTarget = EventTarget;
+	CustomEvent = CustomEvent;
+	Node = Node$2;
+	ParentNode = ParentNode;
+	ChildNode = ChildNode;
+	DocumentFragment = DocumentFragment;
+	Document = Document$1;
+	CharacterData = CharacterData;
+	Comment = Comment;
+	Text = Text;
+	Element = Element$2;
+	HTMLElement = HTMLElement;
+	SVGElement = SVGElement;
+	HTMLTemplateElement = HTMLTemplateElement;
+	MutationObserver = MutationObserver;
 	#currentOnErrorHandler = null;
 	#currentOriginalOnErrorHandler = null;
 	#currentOnUnhandledRejectionHandler = null;
+	static with(...extensions) {
+		const BaseWindow = this;
+		return class ExtendedWindow extends BaseWindow {
+			constructor() {
+				super();
+				for (const extension of extensions) installExtension(this, extension);
+			}
+		};
+	}
 	get onerror() {
 		return this.#currentOriginalOnErrorHandler;
 	}
@@ -1371,26 +2504,50 @@ var Window = class extends EventTarget {
 		} else this.#currentOnUnhandledRejectionHandler = null;
 	}
 	static setGlobal(window) {
-		const properties = Object.getOwnPropertyDescriptors(window);
+		const currentSelf = globalThis.self;
+		const currentWindow = globalThis.window;
+		const properties = windowPropertyDescriptors(window);
+		const missingProperties = Object.assign(eventTargetPropertyDescriptors(window), eventHandlerPropertyDescriptors(window));
 		delete properties.self;
 		Object.defineProperties(globalThis, properties);
-		if (typeof globalThis.self === "undefined") Object.defineProperty(globalThis, "self", {
+		installMissingGlobalProperties(globalThis, missingProperties);
+		if (typeof currentSelf === "undefined" || currentSelf === currentWindow && currentSelf !== globalThis) Object.defineProperty(globalThis, "self", {
 			value: window,
 			configurable: true,
 			writable: true,
 			enumerable: true
 		});
-		else Object.defineProperties(self, properties);
+		else if (currentSelf !== globalThis) {
+			Object.defineProperties(currentSelf, properties);
+			installMissingGlobalProperties(currentSelf, missingProperties);
+		}
 	}
 	static setGlobalThis(window) {
 		for (const property in window) if (window[property] === window) window[property] = globalThis;
-		const properties = Object.getOwnPropertyDescriptors(window);
-		const eventTargetPrototypeProperties = Object.getOwnPropertyDescriptors(EventTarget.prototype);
-		for (const descriptor of Object.values(eventTargetPrototypeProperties)) if (typeof descriptor.value === "function") descriptor.value = descriptor.value.bind(window);
-		Object.defineProperties(globalThis, properties);
-		Object.defineProperties(globalThis, eventTargetPrototypeProperties);
+		Object.defineProperties(globalThis, globalPropertyDescriptors(window));
 	}
 };
+function installExtension(window, extension) {
+	window[EXTENSIONS].push(extension(window) ?? {});
+}
+function createHooksDispatcher(window) {
+	return {
+		createElement: dispatchHook.bind(null, window, "createElement"),
+		setAttribute: dispatchHook.bind(null, window, "setAttribute"),
+		removeAttribute: dispatchHook.bind(null, window, "removeAttribute"),
+		createText: dispatchHook.bind(null, window, "createText"),
+		setText: dispatchHook.bind(null, window, "setText"),
+		insertChild: dispatchHook.bind(null, window, "insertChild"),
+		removeChild: dispatchHook.bind(null, window, "removeChild"),
+		addEventListener: dispatchHook.bind(null, window, "addEventListener"),
+		removeEventListener: dispatchHook.bind(null, window, "removeEventListener")
+	};
+}
+function dispatchHook(window, name, ...args) {
+	for (const hooks of window[EXTENSIONS]) hooks[name]?.apply(hooks, args);
+	const hooks = window[HOOKS];
+	hooks[name]?.apply(hooks, args);
+}
 //#endregion
 //#region node_modules/@volar/jsdelivr/lib/npm.js
 var require_npm = /* @__PURE__ */ __commonJSMin(((exports) => {