@native-dom/runtime 0.0.2

package/dist/index.js

@@ -0,0 +1,3685 @@
+import { createRequire } from "node:module";
+import { createDataset, DOMTokenList } from "./attributes.js";
+import { CSSMediaRule, CSSRule, CSSStyleDeclaration, CSSStyleRule, CSSStyleSheet } from "./css.js";
+import { CustomElementRegistry } from "./custom-elements.js";
+import { DOMException } from "./errors.js";
+import { ClipboardEvent, CustomEvent, Event, EventTarget, FocusEvent, InputEvent, KeyboardEvent, MediaQueryList, MediaQueryListEvent, MouseEvent, PointerEvent, PopStateEvent, SubmitEvent, Touch, TouchEvent, UIEvent } from "./events.js";
+import { DOMRect, DOMRectReadOnly, ValidityState } from "./geometry.js";
+import { History } from "./history.js";
+import { IntersectionObserver, IntersectionObserverEntry, ResizeObserver } from "./observers.js";
+import { getRuntimeStats, prepareNativeDocument, recordNativeCall, recordOperation, recordWrapperCreated, resetRuntimeStats, runtimeStats, setRuntimeStatsEnabled } from "./stats.js";
+import { DataTransfer, DataTransferItemList, FileList, Location, Navigator, Screen, ScreenOrientation, Storage, URL } from "./platform.js";
+export { ClipboardEvent, CSSMediaRule, CSSRule, CSSStyleDeclaration, CSSStyleRule, CSSStyleSheet, CustomEvent, CustomElementRegistry, DataTransfer, DataTransferItemList, DOMException, DOMTokenList, DOMRect, DOMRectReadOnly, Event, EventTarget, FileList, FocusEvent, getRuntimeStats, History, InputEvent, IntersectionObserver, IntersectionObserverEntry, KeyboardEvent, Location, MediaQueryList, MediaQueryListEvent, MouseEvent, Navigator, PointerEvent, PopStateEvent, resetRuntimeStats, ResizeObserver, Screen, ScreenOrientation, setRuntimeStatsEnabled, Storage, SubmitEvent, Touch, TouchEvent, UIEvent, ValidityState, URL, };
+const require = createRequire(import.meta.url);
+const nativeCore = require("@native-dom/native-core");
+const { parseHtmlDocumentNative } = nativeCore;
+const hostSetTimeout = globalThis.setTimeout.bind(globalThis);
+const hostClearTimeout = globalThis.clearTimeout.bind(globalThis);
+const hostSetInterval = globalThis.setInterval.bind(globalThis);
+const hostClearInterval = globalThis.clearInterval.bind(globalThis);
+const hostQueueMicrotask = globalThis.queueMicrotask.bind(globalThis);
+const HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+const MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML";
+export const NodeFilter = {
+    FILTER_ACCEPT: 1,
+    FILTER_REJECT: 2,
+    FILTER_SKIP: 3,
+    SHOW_ALL: 0xffffffff,
+    SHOW_ELEMENT: 0x1,
+    SHOW_ATTRIBUTE: 0x2,
+    SHOW_TEXT: 0x4,
+    SHOW_CDATA_SECTION: 0x8,
+    SHOW_ENTITY_REFERENCE: 0x10,
+    SHOW_ENTITY: 0x20,
+    SHOW_PROCESSING_INSTRUCTION: 0x40,
+    SHOW_COMMENT: 0x80,
+    SHOW_DOCUMENT: 0x100,
+    SHOW_DOCUMENT_TYPE: 0x200,
+    SHOW_DOCUMENT_FRAGMENT: 0x400,
+    SHOW_NOTATION: 0x800
+};
+export class Selection {
+    #ranges = [];
+    get rangeCount() {
+        return this.#ranges.length;
+    }
+    get anchorNode() {
+        return this.#ranges[0]?.startContainer ?? null;
+    }
+    get focusNode() {
+        return this.#ranges[0]?.endContainer ?? null;
+    }
+    get isCollapsed() {
+        return this.rangeCount === 0 || this.#ranges.every((range) => range.collapsed);
+    }
+    addRange(range) {
+        this.#ranges = [range];
+    }
+    removeAllRanges() {
+        this.#ranges = [];
+    }
+    getRangeAt(index) {
+        const range = this.#ranges[index];
+        if (!range) {
+            throw new DOMException("Selection range index is out of bounds", "IndexSizeError");
+        }
+        return range;
+    }
+    toString() {
+        return this.#ranges.map((range) => String(range)).join("");
+    }
+}
+export class FormData {
+    #entries = [];
+    constructor(form) {
+        if (!form) {
+            return;
+        }
+        if (!(form instanceof HTMLElement) || form.localName !== "form") {
+            throw new TypeError("FormData constructor argument must be a form element");
+        }
+        for (const element of form.elements ?? []) {
+            const entry = formDataEntryFor(element);
+            if (entry) {
+                this.#entries.push(entry);
+            }
+        }
+    }
+    append(name, value) {
+        this.#entries.push([String(name), String(value)]);
+    }
+    delete(name) {
+        const normalizedName = String(name);
+        for (let index = this.#entries.length - 1; index >= 0; index--) {
+            if (this.#entries[index][0] === normalizedName) {
+                this.#entries.splice(index, 1);
+            }
+        }
+    }
+    get(name) {
+        return this.#entries.find(([entryName]) => entryName === String(name))?.[1] ?? null;
+    }
+    getAll(name) {
+        return this.#entries
+            .filter(([entryName]) => entryName === String(name))
+            .map(([, value]) => value);
+    }
+    has(name) {
+        return this.#entries.some(([entryName]) => entryName === String(name));
+    }
+    set(name, value) {
+        const normalizedName = String(name);
+        const firstIndex = this.#entries.findIndex(([entryName]) => entryName === normalizedName);
+        if (firstIndex === -1) {
+            this.append(normalizedName, value);
+            return;
+        }
+        this.#entries[firstIndex] = [normalizedName, String(value)];
+        for (let index = this.#entries.length - 1; index > firstIndex; index--) {
+            if (this.#entries[index][0] === normalizedName) {
+                this.#entries.splice(index, 1);
+            }
+        }
+    }
+    forEach(callback, thisArg) {
+        for (const [name, value] of this.#entries) {
+            callback.call(thisArg, value, name, this);
+        }
+    }
+    entries() {
+        return this.#entries[Symbol.iterator]();
+    }
+    keys() {
+        return this.#entries.map(([name]) => name)[Symbol.iterator]();
+    }
+    values() {
+        return this.#entries.map(([, value]) => value)[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}
+export class Range {
+    static START_TO_START = 0;
+    static START_TO_END = 1;
+    static END_TO_END = 2;
+    static END_TO_START = 3;
+    START_TO_START = Range.START_TO_START;
+    START_TO_END = Range.START_TO_END;
+    END_TO_END = Range.END_TO_END;
+    END_TO_START = Range.END_TO_START;
+    startContainer;
+    startOffset = 0;
+    endContainer;
+    endOffset = 0;
+    #document;
+    constructor(document) {
+        this.#document = document;
+        this.startContainer = document;
+        this.endContainer = document;
+    }
+    get collapsed() {
+        return this.startContainer === this.endContainer && this.startOffset === this.endOffset;
+    }
+    get commonAncestorContainer() {
+        let current = this.startContainer;
+        while (current) {
+            if (current.contains(this.endContainer)) {
+                return current;
+            }
+            current = current.parentNode;
+        }
+        return this.#document;
+    }
+    setStart(node, offset) {
+        this.startContainer = node;
+        this.startOffset = offset;
+    }
+    setEnd(node, offset) {
+        this.endContainer = node;
+        this.endOffset = offset;
+    }
+    setStartBefore(node) {
+        const parent = node.parentNode;
+        if (!parent) {
+            throw new DOMException("Node has no parent.", "InvalidNodeTypeError");
+        }
+        this.setStart(parent, nodeIndex(node));
+    }
+    setStartAfter(node) {
+        const parent = node.parentNode;
+        if (!parent) {
+            throw new DOMException("Node has no parent.", "InvalidNodeTypeError");
+        }
+        this.setStart(parent, nodeIndex(node) + 1);
+    }
+    setEndBefore(node) {
+        const parent = node.parentNode;
+        if (!parent) {
+            throw new DOMException("Node has no parent.", "InvalidNodeTypeError");
+        }
+        this.setEnd(parent, nodeIndex(node));
+    }
+    setEndAfter(node) {
+        const parent = node.parentNode;
+        if (!parent) {
+            throw new DOMException("Node has no parent.", "InvalidNodeTypeError");
+        }
+        this.setEnd(parent, nodeIndex(node) + 1);
+    }
+    selectNode(node) {
+        const parent = node.parentNode;
+        if (!parent) {
+            throw new DOMException("Node has no parent.", "InvalidNodeTypeError");
+        }
+        const index = nodeIndex(node);
+        this.setStart(parent, index);
+        this.setEnd(parent, index + 1);
+    }
+    selectNodeContents(node) {
+        this.setStart(node, 0);
+        this.setEnd(node, rangeNodeLength(node));
+    }
+    collapse(toStart = false) {
+        if (toStart) {
+            this.setEnd(this.startContainer, this.startOffset);
+        }
+        else {
+            this.setStart(this.endContainer, this.endOffset);
+        }
+    }
+    cloneRange() {
+        const range = new Range(this.#document);
+        range.setStart(this.startContainer, this.startOffset);
+        range.setEnd(this.endContainer, this.endOffset);
+        return range;
+    }
+    cloneContents() {
+        const fragment = this.#document.createDocumentFragment();
+        if (this.startContainer !== this.endContainer) {
+            return fragment;
+        }
+        if (this.startContainer.nodeType === Node.TEXT_NODE) {
+            fragment.appendChild(this.#document.createTextNode((this.startContainer.nodeValue ?? "").slice(this.startOffset, this.endOffset)));
+            return fragment;
+        }
+        const children = [...this.startContainer.childNodes].slice(this.startOffset, this.endOffset);
+        for (const child of children) {
+            fragment.appendChild(this.#document.importNode(child, true));
+        }
+        return fragment;
+    }
+    deleteContents() {
+        if (this.startContainer !== this.endContainer || this.startContainer.nodeType === Node.TEXT_NODE) {
+            return;
+        }
+        const children = [...this.startContainer.childNodes].slice(this.startOffset, this.endOffset);
+        for (const child of children) {
+            this.startContainer.removeChild(child);
+        }
+        this.collapse(true);
+    }
+    insertNode(node) {
+        if (this.startContainer.nodeType === Node.TEXT_NODE) {
+            this.startContainer.parentNode?.insertBefore(node, this.startContainer);
+            return;
+        }
+        this.startContainer.insertBefore(node, this.startContainer.childNodes.item(this.startOffset));
+    }
+    createContextualFragment(html) {
+        return fragmentFromHtml(this.#document, html);
+    }
+    detach() { }
+    toString() {
+        return this.cloneContents().textContent;
+    }
+}
+function rangeNodeLength(node) {
+    return node.nodeType === Node.TEXT_NODE || node.nodeType === Node.COMMENT_NODE
+        ? (node.nodeValue ?? "").length
+        : node.childNodes.length;
+}
+function nodeIndex(node) {
+    return node.parentNode ? [...node.parentNode.childNodes].indexOf(node) : -1;
+}
+export class Window extends EventTarget {
+    #animationFrameHandle = 0;
+    #animationFrames = new Map();
+    #timeouts = new Set();
+    #intervals = new Set();
+    #closed = false;
+    #selection = new Selection();
+    document;
+    Window = Window;
+    window = this;
+    self = this;
+    top = this;
+    parent = this;
+    location;
+    history;
+    Image;
+    navigator = new Navigator();
+    screen = new Screen();
+    localStorage = new Storage();
+    sessionStorage = new Storage();
+    URL = URL;
+    URLSearchParams = globalThis.URLSearchParams;
+    Blob = globalThis.Blob;
+    File = globalThis.File;
+    Headers = globalThis.Headers;
+    Request = globalThis.Request;
+    Response = globalThis.Response;
+    AbortController = globalThis.AbortController;
+    fetch = globalThis.fetch.bind(globalThis);
+    customElements = new CustomElementRegistry();
+    innerWidth = 1024;
+    innerHeight = 768;
+    outerWidth = 1024;
+    outerHeight = 768;
+    queueMicrotask = hostQueueMicrotask;
+    devicePixelRatio = 1;
+    FormData = FormData;
+    Storage = Storage;
+    Node = Node;
+    Element = Element;
+    HTMLElement = HTMLElement;
+    HTMLHtmlElement = HTMLHtmlElement;
+    HTMLBodyElement = HTMLBodyElement;
+    SVGElement = SVGElement;
+    MathMLElement = MathMLElement;
+    DocumentFragment = DocumentFragment;
+    ShadowRoot = ShadowRoot;
+    HTMLButtonElement = HTMLButtonElement;
+    HTMLCanvasElement = HTMLCanvasElement;
+    HTMLFormElement = HTMLFormElement;
+    HTMLIFrameElement = HTMLElement;
+    HTMLImageElement = HTMLImageElement;
+    HTMLInputElement = HTMLInputElement;
+    HTMLLinkElement = HTMLLinkElement;
+    HTMLOptionElement = HTMLOptionElement;
+    HTMLScriptElement = HTMLScriptElement;
+    HTMLSelectElement = HTMLSelectElement;
+    HTMLStyleElement = HTMLStyleElement;
+    HTMLTableCellElement = HTMLTableCellElement;
+    HTMLTableElement = HTMLTableElement;
+    HTMLTableRowElement = HTMLTableRowElement;
+    HTMLTableSectionElement = HTMLTableSectionElement;
+    HTMLTemplateElement = HTMLTemplateElement;
+    HTMLTextAreaElement = HTMLTextAreaElement;
+    HTMLCollection = NativeNodeList;
+    NodeList = NativeNodeList;
+    Document = Document;
+    Text = Text;
+    Comment = Comment;
+    DOMParser = DOMParser;
+    DocumentType = DocumentType;
+    DOMRect = DOMRect;
+    DOMRectReadOnly = DOMRectReadOnly;
+    EventTarget = EventTarget;
+    Event = Event;
+    CustomEvent = CustomEvent;
+    UIEvent = UIEvent;
+    MouseEvent = MouseEvent;
+    PointerEvent = PointerEvent;
+    KeyboardEvent = KeyboardEvent;
+    InputEvent = InputEvent;
+    FocusEvent = FocusEvent;
+    SubmitEvent = SubmitEvent;
+    PopStateEvent = PopStateEvent;
+    ClipboardEvent = ClipboardEvent;
+    Touch = Touch;
+    TouchEvent = TouchEvent;
+    ResizeObserver = ResizeObserver;
+    IntersectionObserver = IntersectionObserver;
+    IntersectionObserverEntry = IntersectionObserverEntry;
+    Selection = Selection;
+    DataTransfer = DataTransfer;
+    DataTransferItemList = DataTransferItemList;
+    FileList = FileList;
+    MutationObserver = MutationObserver;
+    DOMException = DOMException;
+    Range = Range;
+    TreeWalker = TreeWalker;
+    NodeIterator = NodeIterator;
+    ValidityState = ValidityState;
+    NodeFilter = NodeFilter;
+    Location = Location;
+    History = History;
+    Navigator = Navigator;
+    Screen = Screen;
+    ScreenOrientation = ScreenOrientation;
+    MediaQueryList = MediaQueryList;
+    MediaQueryListEvent = MediaQueryListEvent;
+    NamedNodeMap = NamedNodeMap;
+    XMLSerializer = XMLSerializer;
+    CSSStyleDeclaration = CSSStyleDeclaration;
+    CSSRule = CSSRule;
+    CSSStyleRule = CSSStyleRule;
+    CSSMediaRule = CSSMediaRule;
+    CSSStyleSheet = CSSStyleSheet;
+    CustomElementRegistry = CustomElementRegistry;
+    constructor(html = "", url = "about:blank") {
+        super();
+        this.location = new Location(url);
+        this.history = new History(this.location, this);
+        this.document = new Document(this, html);
+        this.Image = createImageConstructor(this.document);
+    }
+    setTimeout(handler, timeout, ...arguments_) {
+        const handle = hostSetTimeout(() => {
+            this.#timeouts.delete(handle);
+            if (this.#closed) {
+                return;
+            }
+            if (typeof handler === "function") {
+                handler(...arguments_);
+            }
+            else {
+                globalThis.Function(String(handler))();
+            }
+        }, timeout);
+        this.#timeouts.add(handle);
+        return handle;
+    }
+    clearTimeout(handle) {
+        if (handle === undefined) {
+            return;
+        }
+        this.#timeouts.delete(handle);
+        hostClearTimeout(handle);
+    }
+    setInterval(handler, timeout, ...arguments_) {
+        const handle = hostSetInterval(() => {
+            if (this.#closed) {
+                return;
+            }
+            if (typeof handler === "function") {
+                handler(...arguments_);
+            }
+            else {
+                globalThis.Function(String(handler))();
+            }
+        }, timeout);
+        this.#intervals.add(handle);
+        return handle;
+    }
+    clearInterval(handle) {
+        if (handle === undefined) {
+            return;
+        }
+        this.#intervals.delete(handle);
+        hostClearInterval(handle);
+    }
+    getComputedStyle(element, _pseudoElement) {
+        const style = new CSSStyleDeclaration(element.getAttribute("style") ?? "");
+        if (element.hasAttribute("hidden")) {
+            style.display = "none";
+        }
+        if (!style.display) {
+            style.display = defaultDisplayFor(element.localName);
+        }
+        if (!style.visibility) {
+            style.visibility = inheritedVisibility(element);
+        }
+        return style;
+    }
+    requestAnimationFrame(callback) {
+        const id = ++this.#animationFrameHandle;
+        const handle = hostSetTimeout(() => {
+            this.#animationFrames.delete(id);
+            callback(Date.now());
+        }, 16);
+        this.#animationFrames.set(id, handle);
+        return id;
+    }
+    cancelAnimationFrame(id) {
+        const handle = this.#animationFrames.get(id);
+        if (handle) {
+            hostClearTimeout(handle);
+            this.#animationFrames.delete(id);
+        }
+    }
+    matchMedia(query) {
+        return new MediaQueryList(String(query), false);
+    }
+    getSelection() {
+        return this.#selection;
+    }
+    close() {
+        this.#closed = true;
+        for (const handle of this.#timeouts) {
+            hostClearTimeout(handle);
+        }
+        this.#timeouts.clear();
+        for (const handle of this.#intervals) {
+            hostClearInterval(handle);
+        }
+        this.#intervals.clear();
+        for (const handle of this.#animationFrames.values()) {
+            hostClearTimeout(handle);
+        }
+        this.#animationFrames.clear();
+    }
+    cancelAsync() {
+        this.close();
+    }
+}
+function inheritedVisibility(element) {
+    let current = element;
+    while (current) {
+        const visibility = new CSSStyleDeclaration(current.getAttribute("style") ?? "").visibility;
+        if (visibility) {
+            return visibility;
+        }
+        current = current.parentElement;
+    }
+    return "";
+}
+function defaultDisplayFor(localName) {
+    switch (localName) {
+        case "body":
+        case "div":
+        case "form":
+        case "main":
+        case "option":
+        case "p":
+        case "section":
+            return "block";
+        case "button":
+        case "input":
+        case "select":
+        case "textarea":
+            return "inline-block";
+        case "table":
+            return "table";
+        case "tbody":
+            return "table-row-group";
+        case "tr":
+            return "table-row";
+        case "th":
+        case "td":
+            return "table-cell";
+        default:
+            return "";
+    }
+}
+export class Node extends EventTarget {
+    static ELEMENT_NODE = 1;
+    static TEXT_NODE = 3;
+    static COMMENT_NODE = 8;
+    static DOCUMENT_NODE = 9;
+    static DOCUMENT_TYPE_NODE = 10;
+    static DOCUMENT_FRAGMENT_NODE = 11;
+    static DOCUMENT_POSITION_DISCONNECTED = 1;
+    static DOCUMENT_POSITION_PRECEDING = 2;
+    static DOCUMENT_POSITION_FOLLOWING = 4;
+    static DOCUMENT_POSITION_CONTAINS = 8;
+    static DOCUMENT_POSITION_CONTAINED_BY = 16;
+    static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32;
+    _document;
+    _id;
+    #nodeName;
+    #textContentCache = "";
+    #textContentCacheVersion = -1;
+    constructor(document, id, nodeName = null) {
+        super();
+        this._document = document;
+        this._id = id;
+        this.#nodeName = nodeName;
+    }
+    get nodeName() {
+        this.#nodeName ??= this._document._native.nodeName(this._id);
+        return this.#nodeName;
+    }
+    get nodeType() {
+        switch (this.nodeName) {
+            case "#document":
+                return 9;
+            case "#document-type":
+                return 10;
+            case "#document-fragment":
+                return 11;
+            case "#text":
+                return 3;
+            case "#comment":
+                return 8;
+            default:
+                return 1;
+        }
+    }
+    get nodeValue() {
+        return this._document._native.nodeValue(this._id);
+    }
+    set nodeValue(value) {
+        if (runtimeStats.enabled) {
+            recordOperation("nodeValueSet");
+        }
+        if (!hasMutationObservers()) {
+            this._document._native.setNodeValue(this._id, value ?? "");
+            if (this.nodeType === 3 || this.nodeType === 8) {
+                this._document._bumpMutationVersion();
+            }
+            return;
+        }
+        const oldValue = this.nodeValue;
+        this._document._native.setNodeValue(this._id, value ?? "");
+        if (this.nodeType === 3 || this.nodeType === 8) {
+            this._document._bumpMutationVersion();
+            notifyMutation({
+                type: "characterData",
+                target: this,
+                addedNodes: [],
+                removedNodes: [],
+                attributeName: null,
+                oldValue
+            });
+        }
+    }
+    get textContent() {
+        if (this.nodeType === 3 || this.nodeType === 8) {
+            return this.nodeValue ?? "";
+        }
+        const mutationVersion = this._document._mutationVersion();
+        if (this.#textContentCacheVersion === mutationVersion) {
+            return this.#textContentCache;
+        }
+        const value = this._document._native.textContent(this._id);
+        this.#textContentCache = value;
+        this.#textContentCacheVersion = mutationVersion;
+        return value;
+    }
+    set textContent(value) {
+        if (runtimeStats.enabled) {
+            recordOperation("textContentSet");
+        }
+        if (this.nodeType === 3 || this.nodeType === 8) {
+            if (!hasActiveMutationObservers) {
+                this._document._native.setNodeValue(this._id, value);
+                this._document._bumpMutationVersion();
+                return;
+            }
+            const oldValue = this.nodeValue;
+            this._document._native.setNodeValue(this._id, value);
+            this._document._bumpMutationVersion();
+            notifyMutation({
+                type: "characterData",
+                target: this,
+                addedNodes: [],
+                removedNodes: [],
+                attributeName: null,
+                oldValue
+            });
+            return;
+        }
+        if (hasActiveMutationObservers) {
+            while (this.firstChild) {
+                this.removeChild(this.firstChild);
+            }
+            if (value !== "") {
+                this.appendChild(this._document.createTextNode(value));
+            }
+            return;
+        }
+        this._document._native.setTextContent(this._id, value);
+        this._document._bumpMutationVersion();
+    }
+    get ownerDocument() {
+        return this._document;
+    }
+    get parentNode() {
+        const id = this._document._native.parentNode(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get parentElement() {
+        const parent = this.parentNode;
+        return parent instanceof Element ? parent : null;
+    }
+    get isConnected() {
+        return this._document._native.isConnected(this._id);
+    }
+    get firstChild() {
+        const id = this._document._native.firstChild(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get lastChild() {
+        const id = this._document._native.lastChild(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get nextSibling() {
+        const id = this._document._native.nextSibling(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get previousSibling() {
+        const id = this._document._native.previousSibling(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get previousElementSibling() {
+        const id = this._document._native.previousElementSibling(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get nextElementSibling() {
+        const id = this._document._native.nextElementSibling(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get childNodes() {
+        return new NativeNodeList(this._document, this._document._native.childNodes(this._id));
+    }
+    hasChildNodes() {
+        return this.firstChild !== null;
+    }
+    appendChild(child) {
+        if (runtimeStats.enabled) {
+            recordOperation("appendChild");
+        }
+        child = this.#adoptForMutation(child);
+        const hasObservers = hasActiveMutationObservers;
+        if (child instanceof DocumentFragment) {
+            if (!hasObservers) {
+                if (this._document._native.appendDocumentFragment(this._id, child._nativeId)) {
+                    this._document._bumpMutationVersion();
+                }
+                return child;
+            }
+            while (child.firstChild) {
+                this.appendChild(child.firstChild);
+            }
+            return child;
+        }
+        const hasCustomElements = this._document._hasCustomElementDefinitions();
+        if (!hasObservers && !hasCustomElements) {
+            this._document._native.appendChild(this._id, child._nativeId);
+            this._document._bumpMutationVersion();
+            return child;
+        }
+        const oldParent = hasCustomElements ? child.parentNode : null;
+        const wasConnected = hasCustomElements && child.isConnected;
+        this._document._native.appendChild(this._id, child._nativeId);
+        this._document._bumpMutationVersion();
+        if (hasCustomElements) {
+            notifyCustomElementReparented(child, oldParent, wasConnected);
+        }
+        if (hasObservers) {
+            notifyMutation({
+                type: "childList",
+                target: this,
+                addedNodes: [child],
+                removedNodes: [],
+                attributeName: null,
+                oldValue: null
+            });
+        }
+        return child;
+    }
+    append(...nodes) {
+        for (const node of nodes) {
+            this.appendChild(this.#toNode(node));
+        }
+    }
+    prepend(...nodes) {
+        const reference = this.firstChild;
+        for (const node of nodes) {
+            this.insertBefore(this.#toNode(node), reference);
+        }
+    }
+    insertBefore(child, referenceNode) {
+        if (runtimeStats.enabled) {
+            recordOperation("insertBefore");
+        }
+        child = this.#adoptForMutation(child);
+        if (referenceNode) {
+            this.#assertSameDocument(referenceNode);
+        }
+        const hasObservers = hasActiveMutationObservers;
+        if (child instanceof DocumentFragment) {
+            if (!hasObservers) {
+                const moved = this._document._native.insertDocumentFragment(this._id, child._nativeId, referenceNode?._nativeId ?? null);
+                if (moved) {
+                    this._document._bumpMutationVersion();
+                }
+                return child;
+            }
+            while (child.firstChild) {
+                this.insertBefore(child.firstChild, referenceNode);
+            }
+            return child;
+        }
+        const hasCustomElements = this._document._hasCustomElementDefinitions();
+        if (!hasObservers && !hasCustomElements) {
+            this._document._native.insertBefore(this._id, child._nativeId, referenceNode?._nativeId ?? null);
+            this._document._bumpMutationVersion();
+            return child;
+        }
+        const oldParent = hasCustomElements ? child.parentNode : null;
+        const wasConnected = hasCustomElements && child.isConnected;
+        this._document._native.insertBefore(this._id, child._nativeId, referenceNode?._nativeId ?? null);
+        this._document._bumpMutationVersion();
+        if (hasCustomElements) {
+            notifyCustomElementReparented(child, oldParent, wasConnected);
+        }
+        if (hasObservers) {
+            notifyMutation({
+                type: "childList",
+                target: this,
+                addedNodes: [child],
+                removedNodes: [],
+                attributeName: null,
+                oldValue: null
+            });
+        }
+        return child;
+    }
+    removeChild(child) {
+        if (runtimeStats.enabled) {
+            recordOperation("removeChild");
+        }
+        this.#assertSameDocument(child);
+        const hasCustomElements = this._document._hasCustomElementDefinitions();
+        const wasConnected = hasCustomElements && child.isConnected;
+        const hasObservers = hasMutationObservers();
+        if (!hasObservers) {
+            this._document._native.removeChild(this._id, child._nativeId);
+            this._document._bumpMutationVersion();
+            if (hasCustomElements && wasConnected) {
+                notifyCustomElementDisconnected(child);
+            }
+            return child;
+        }
+        const previousSibling = child.previousSibling;
+        const nextSibling = child.nextSibling;
+        this._document._native.removeChild(this._id, child._nativeId);
+        this._document._bumpMutationVersion();
+        if (hasCustomElements && wasConnected) {
+            notifyCustomElementDisconnected(child);
+        }
+        notifyMutation({
+            type: "childList",
+            target: this,
+            addedNodes: [],
+            removedNodes: [child],
+            attributeName: null,
+            oldValue: null,
+            previousSibling,
+            nextSibling
+        });
+        return child;
+    }
+    replaceChild(newChild, oldChild) {
+        if (runtimeStats.enabled) {
+            recordOperation("replaceChild");
+        }
+        newChild = this.#adoptForMutation(newChild);
+        this.#assertSameDocument(oldChild);
+        if (newChild === oldChild) {
+            return oldChild;
+        }
+        if (newChild instanceof DocumentFragment) {
+            this.insertBefore(newChild, oldChild);
+            this.removeChild(oldChild);
+            return oldChild;
+        }
+        if (!hasMutationObservers()) {
+            const hasCustomElements = this._document._hasCustomElementDefinitions();
+            const oldWasConnected = hasCustomElements && oldChild.isConnected;
+            const newOldParent = hasCustomElements ? newChild.parentNode : null;
+            const newWasConnected = hasCustomElements && newChild.isConnected;
+            this._document._native.replaceChild(this._id, newChild._nativeId, oldChild._nativeId);
+            this._document._bumpMutationVersion();
+            if (hasCustomElements && oldWasConnected) {
+                notifyCustomElementDisconnected(oldChild);
+            }
+            if (hasCustomElements) {
+                notifyCustomElementReparented(newChild, newOldParent, newWasConnected);
+            }
+            return oldChild;
+        }
+        this.insertBefore(newChild, oldChild);
+        this.removeChild(oldChild);
+        return oldChild;
+    }
+    replaceChildren(...nodes) {
+        if (runtimeStats.enabled) {
+            recordOperation("replaceChildren");
+        }
+        if (hasMutationObservers()) {
+            while (this.firstChild) {
+                this.removeChild(this.firstChild);
+            }
+            this.append(...nodes);
+            return;
+        }
+        this._document._native.clearChildren(this._id);
+        this._document._bumpMutationVersion();
+        this.append(...nodes);
+    }
+    cloneNode(deep = false) {
+        return this._document._wrap(this._document._native.cloneNode(this._id, deep));
+    }
+    contains(other) {
+        if (!other || other._document !== this._document) {
+            return false;
+        }
+        return this._document._native.contains(this._id, other._nativeId);
+    }
+    getRootNode() {
+        let current = this;
+        while (current.parentNode) {
+            current = current.parentNode;
+        }
+        return current;
+    }
+    isSameNode(other) {
+        return this === other;
+    }
+    isEqualNode(other) {
+        if (!other || this.nodeType !== other.nodeType || this.nodeName !== other.nodeName) {
+            return false;
+        }
+        if (this.nodeValue !== other.nodeValue) {
+            return false;
+        }
+        if (this instanceof Element || other instanceof Element) {
+            if (!(this instanceof Element) || !(other instanceof Element)) {
+                return false;
+            }
+            const attributeNames = this.getAttributeNames();
+            const otherAttributeNames = other.getAttributeNames();
+            if (attributeNames.length !== otherAttributeNames.length) {
+                return false;
+            }
+            for (const name of attributeNames) {
+                if (this.getAttribute(name) !== other.getAttribute(name)) {
+                    return false;
+                }
+            }
+        }
+        const children = [...this.childNodes];
+        const otherChildren = [...other.childNodes];
+        return (children.length === otherChildren.length &&
+            children.every((child, index) => child.isEqualNode(otherChildren[index])));
+    }
+    compareDocumentPosition(other) {
+        if (this === other) {
+            return 0;
+        }
+        if (other._document !== this._document) {
+            return (Node.DOCUMENT_POSITION_DISCONNECTED |
+                Node.DOCUMENT_POSITION_FOLLOWING |
+                Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC);
+        }
+        return this._document._native.compareDocumentPosition(this._id, other._nativeId);
+    }
+    normalize() {
+        if (runtimeStats.enabled) {
+            recordOperation("normalize");
+        }
+        if (!hasMutationObservers()) {
+            if (this._document._native.normalizeSubtree(this._id)) {
+                this._document._bumpMutationVersion();
+            }
+            return;
+        }
+        let child = this.firstChild;
+        while (child) {
+            const next = child.nextSibling;
+            if (child.nodeType !== Node.TEXT_NODE) {
+                child.normalize();
+                child = next;
+                continue;
+            }
+            let data = child.nodeValue ?? "";
+            let sibling = next;
+            while (sibling?.nodeType === Node.TEXT_NODE) {
+                data += sibling.nodeValue ?? "";
+                const siblingToRemove = sibling;
+                sibling = sibling.nextSibling;
+                this.removeChild(siblingToRemove);
+            }
+            if (data === "") {
+                this.removeChild(child);
+            }
+            else if (child.nodeValue !== data) {
+                child.nodeValue = data;
+            }
+            child = sibling;
+        }
+    }
+    remove() {
+        this.parentNode?.removeChild(this);
+    }
+    before(...nodes) {
+        const parent = this.parentNode;
+        if (!parent) {
+            return;
+        }
+        for (const node of nodes) {
+            parent.insertBefore(this.#toNode(node), this);
+        }
+    }
+    after(...nodes) {
+        const parent = this.parentNode;
+        if (!parent) {
+            return;
+        }
+        const reference = this.nextSibling;
+        for (const node of nodes) {
+            parent.insertBefore(this.#toNode(node), reference);
+        }
+    }
+    replaceWith(...nodes) {
+        const parent = this.parentNode;
+        if (!parent) {
+            return;
+        }
+        for (const node of nodes) {
+            parent.insertBefore(this.#toNode(node), this);
+        }
+        parent.removeChild(this);
+    }
+    _eventPath() {
+        const path = [this];
+        let current = this.parentNode;
+        while (current) {
+            path.push(current);
+            current = current.parentNode;
+        }
+        path.push(this._document.defaultView);
+        return path;
+    }
+    get _nativeId() {
+        return this._id;
+    }
+    #assertSameDocument(node) {
+        if (node._document !== this._document) {
+            throw new Error("Cross-document node mutations are not implemented");
+        }
+    }
+    #adoptForMutation(node) {
+        const targetDocument = this._document;
+        return !targetDocument || node._document === targetDocument
+            ? node
+            : importNodeIntoDocument(targetDocument, node, true);
+    }
+    #toNode(node) {
+        return typeof node === "string" ? this._document.createTextNode(node) : node;
+    }
+}
+Object.defineProperties(Node.prototype, {
+    ELEMENT_NODE: { value: Node.ELEMENT_NODE },
+    TEXT_NODE: { value: Node.TEXT_NODE },
+    COMMENT_NODE: { value: Node.COMMENT_NODE },
+    DOCUMENT_NODE: { value: Node.DOCUMENT_NODE },
+    DOCUMENT_TYPE_NODE: { value: Node.DOCUMENT_TYPE_NODE },
+    DOCUMENT_FRAGMENT_NODE: { value: Node.DOCUMENT_FRAGMENT_NODE },
+    DOCUMENT_POSITION_DISCONNECTED: { value: Node.DOCUMENT_POSITION_DISCONNECTED },
+    DOCUMENT_POSITION_PRECEDING: { value: Node.DOCUMENT_POSITION_PRECEDING },
+    DOCUMENT_POSITION_FOLLOWING: { value: Node.DOCUMENT_POSITION_FOLLOWING },
+    DOCUMENT_POSITION_CONTAINS: { value: Node.DOCUMENT_POSITION_CONTAINS },
+    DOCUMENT_POSITION_CONTAINED_BY: { value: Node.DOCUMENT_POSITION_CONTAINED_BY },
+    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: {
+        value: Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC
+    }
+});
+function nativeDocumentOrder(root) {
+    const document = root.ownerDocument;
+    if (!document) {
+        throw new Error("Node has no owner document");
+    }
+    return {
+        document,
+        ids: document._native.documentOrderIds(root._nativeId)
+    };
+}
+export class NamedNodeMap extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(attributes = []) {
+        super();
+        for (const attribute of attributes) {
+            this.push(attribute);
+        }
+    }
+    item(index) {
+        return this[index] ?? null;
+    }
+    getNamedItem(name) {
+        const normalizedName = String(name).toLowerCase();
+        return this.find((attribute) => attribute.name === normalizedName) ?? null;
+    }
+    getNamedItemNS(_namespace, localName) {
+        const normalizedName = String(localName).toLowerCase();
+        return this.find((attribute) => attribute.localName === normalizedName) ?? null;
+    }
+}
+export class MutationRecord {
+    type;
+    target;
+    addedNodes;
+    removedNodes;
+    attributeName;
+    oldValue;
+    previousSibling;
+    nextSibling;
+    constructor(init) {
+        this.type = init.type;
+        this.target = init.target;
+        this.addedNodes = init.addedNodes;
+        this.removedNodes = init.removedNodes;
+        this.attributeName = init.attributeName;
+        this.oldValue = init.oldValue;
+        this.previousSibling = init.previousSibling ?? null;
+        this.nextSibling = init.nextSibling ?? null;
+    }
+}
+const mutationObservers = new Set();
+let hasActiveMutationObservers = false;
+function hasMutationObservers() {
+    if (runtimeStats.enabled) {
+        recordOperation("observerChecks");
+    }
+    return hasActiveMutationObservers;
+}
+export class MutationObserver {
+    #callback;
+    #observed = new Map();
+    #records = [];
+    #scheduled = false;
+    constructor(callback) {
+        this.#callback = callback;
+    }
+    observe(target, options) {
+        if (!target) {
+            throw new TypeError("Failed to execute 'observe' on 'MutationObserver': The first parameter \"target\" should be of type \"Node\".");
+        }
+        this.#observed.set(target, normalizeMutationObserverOptions(options));
+        mutationObservers.add(this);
+        hasActiveMutationObservers = true;
+    }
+    disconnect() {
+        this.#observed.clear();
+        this.#records = [];
+        mutationObservers.delete(this);
+        hasActiveMutationObservers = mutationObservers.size > 0;
+    }
+    takeRecords() {
+        const records = this.#records;
+        this.#records = [];
+        return records;
+    }
+    _enqueue(record) {
+        const matched = this.#matchingOptions(record);
+        if (!matched) {
+            return;
+        }
+        this.#records.push(new MutationRecord({
+            ...record,
+            oldValue: (record.type === "attributes" && matched.attributeOldValue) ||
+                (record.type === "characterData" && matched.characterDataOldValue)
+                ? record.oldValue
+                : null
+        }));
+        if (!this.#scheduled) {
+            this.#scheduled = true;
+            queueMicrotask(() => {
+                this.#scheduled = false;
+                const records = this.takeRecords();
+                if (records.length > 0) {
+                    this.#callback(records, this);
+                }
+            });
+        }
+    }
+    #matchingOptions(record) {
+        for (const [target, options] of this.#observed) {
+            if (record.target !== target && !(options.subtree && target.contains(record.target))) {
+                continue;
+            }
+            if (record.type === "childList" && options.childList) {
+                return options;
+            }
+            if (record.type === "attributes" && options.attributes) {
+                if (options.attributeFilter &&
+                    (!record.attributeName || !options.attributeFilter.includes(record.attributeName))) {
+                    continue;
+                }
+                return options;
+            }
+            if (record.type === "characterData" && options.characterData) {
+                return options;
+            }
+        }
+        return null;
+    }
+}
+function normalizeMutationObserverOptions(options) {
+    if (!options) {
+        throw new TypeError("Failed to execute 'observe' on 'MutationObserver': The options object must set at least one of 'attributes', 'characterData', or 'childList' to true.");
+    }
+    if (options.attributeOldValue && options.attributes === false) {
+        throw new TypeError("Failed to execute 'observe' on 'MutationObserver': The options object may only set 'attributeOldValue' to true when 'attributes' is true or not present.");
+    }
+    if (options.attributeFilter && options.attributes === false) {
+        throw new TypeError("Failed to execute 'observe' on 'MutationObserver': The options object may only set 'attributeFilter' when 'attributes' is true or not present.");
+    }
+    if (options.characterDataOldValue && options.characterData === false) {
+        throw new TypeError("Failed to execute 'observe' on 'MutationObserver': The options object may only set 'characterDataOldValue' to true when 'characterData' is true or not present.");
+    }
+    const normalized = {
+        ...options,
+        attributes: options.attributes ?? (options.attributeOldValue || options.attributeFilter ? true : undefined),
+        characterData: options.characterData ?? (options.characterDataOldValue ? true : undefined),
+        attributeFilter: options.attributeFilter?.map((name) => name.toLowerCase())
+    };
+    if (!normalized.childList && !normalized.attributes && !normalized.characterData) {
+        throw new TypeError("Failed to execute 'observe' on 'MutationObserver': The options object must set at least one of 'attributes', 'characterData', or 'childList' to true.");
+    }
+    return normalized;
+}
+function notifyMutation(record) {
+    if (mutationObservers.size === 0) {
+        return;
+    }
+    const mutationRecord = new MutationRecord(record);
+    for (const observer of mutationObservers) {
+        observer._enqueue(mutationRecord);
+    }
+}
+export class DOMImplementation {
+    #document;
+    constructor(document = null) {
+        this.#document = document;
+    }
+    createHTMLDocument(_title = "") {
+        return new Window().document;
+    }
+    createDocumentType(name, publicId = "", systemId = "") {
+        const document = this.#document ?? new Window().document;
+        return document._wrap(document._native.createDocumentType(String(name), String(publicId), String(systemId)));
+    }
+}
+export class DOMParser {
+    parseFromString(markup, _type) {
+        return new Window(String(markup)).document;
+    }
+}
+export class XMLSerializer {
+    serializeToString(node) {
+        if (node instanceof Document) {
+            return addRootHtmlNamespace(node.documentElement.outerHTML);
+        }
+        if (node instanceof Element) {
+            return addRootHtmlNamespace(node.outerHTML);
+        }
+        const document = node instanceof Document ? node : node.ownerDocument;
+        return document?._native.serializeNode(node._nativeId) ?? "";
+    }
+}
+function addRootHtmlNamespace(markup) {
+    if (/^<[^\s>]+[\s>]/.test(markup) && !/^<[^\s>]+\s[^>]*\bxmlns=/.test(markup)) {
+        return markup.replace(/^<([^\s>]+)/, '<$1 xmlns="http://www.w3.org/1999/xhtml"');
+    }
+    return markup;
+}
+let customElementConstruction = null;
+function parseDocumentCookie(cookieText) {
+    const [pair] = cookieText.split(";");
+    const trimmedPair = pair?.trim() ?? "";
+    if (!trimmedPair) {
+        return null;
+    }
+    const equalsIndex = trimmedPair.indexOf("=");
+    if (equalsIndex === -1) {
+        return {
+            hasValue: false,
+            name: trimmedPair,
+            value: ""
+        };
+    }
+    const name = trimmedPair.slice(0, equalsIndex).trim();
+    if (!name) {
+        return null;
+    }
+    return {
+        hasValue: true,
+        name,
+        value: trimmedPair.slice(equalsIndex + 1).trim()
+    };
+}
+export class Document extends Node {
+    defaultView;
+    implementation;
+    _native;
+    #wrappers = new Map();
+    #activeElement = null;
+    #documentNodeId;
+    #documentElementId;
+    #headId;
+    #bodyId;
+    #mutationVersion = 0;
+    #namespaces = new Map();
+    #cookies = new Map();
+    #queryAllCache = new Map();
+    #lastQueryAllRootId = null;
+    #lastQueryAllSelector = "";
+    #lastQueryAllVersion = -1;
+    #lastQueryAllIds = [];
+    #queryOneCache = new Map();
+    #lastQueryOneRootId = null;
+    #lastQueryOneSelector = "";
+    #lastQueryOneVersion = -1;
+    #lastQueryOneId = null;
+    #classNameCache = new Map();
+    #lastClassNameRootId = null;
+    #lastClassNameSelector = "";
+    #lastClassNameVersion = -1;
+    #lastClassNameIds = [];
+    #matchesCache = new Map();
+    #lastMatchesId = null;
+    #lastMatchesSelector = "";
+    #lastMatchesVersion = -1;
+    #lastMatchesResult = false;
+    #closestCache = new Map();
+    #lastClosestId = null;
+    #lastClosestSelector = "";
+    #lastClosestVersion = -1;
+    #lastClosestResult = null;
+    #customElementRegistryVersion = -1;
+    #hasCustomElementDefinitions = false;
+    constructor(defaultView, html = "") {
+        if (runtimeStats.enabled) {
+            recordNativeCall("parseHtmlDocumentNative");
+        }
+        const native = prepareNativeDocument(parseHtmlDocumentNative(html));
+        const documentNodeId = native.documentNode();
+        super(undefined, documentNodeId, "#document");
+        this.defaultView = defaultView;
+        this._native = native;
+        this.#documentNodeId = documentNodeId;
+        this.#documentElementId = native.documentElement();
+        this.#headId = native.head();
+        this.#bodyId = native.body();
+        this.implementation = new DOMImplementation(this);
+        Object.defineProperty(this, "_document", {
+            configurable: false,
+            value: this
+        });
+        if (runtimeStats.enabled) {
+            recordWrapperCreated("#document");
+        }
+    }
+    get documentElement() {
+        return this._wrap(this.#documentElementId, "HTML");
+    }
+    get doctype() {
+        const id = this._native.documentType();
+        return id == null ? null : this._wrap(id);
+    }
+    get head() {
+        return this._wrap(this.#headId, "HEAD");
+    }
+    get body() {
+        return this._wrap(this.#bodyId, "BODY");
+    }
+    get URL() {
+        return this.defaultView.location.href;
+    }
+    get documentURI() {
+        return this.URL;
+    }
+    get characterSet() {
+        return "UTF-8";
+    }
+    get charset() {
+        return this.characterSet;
+    }
+    get inputEncoding() {
+        return this.characterSet;
+    }
+    get contentType() {
+        return "text/html";
+    }
+    get readyState() {
+        return "interactive";
+    }
+    get visibilityState() {
+        return "visible";
+    }
+    get hidden() {
+        return this.visibilityState !== "visible";
+    }
+    get cookie() {
+        return [...this.#cookies.values()]
+            .map((cookie) => (cookie.hasValue ? `${cookie.name}=${cookie.value}` : cookie.name))
+            .join("; ");
+    }
+    set cookie(value) {
+        const cookie = parseDocumentCookie(String(value));
+        if (!cookie) {
+            return;
+        }
+        this.#cookies.delete(cookie.name);
+        this.#cookies.set(cookie.name, cookie);
+    }
+    get styleSheets() {
+        return [...this.querySelectorAll("style")]
+            .filter((element) => element instanceof HTMLStyleElement)
+            .map((element) => element.sheet)
+            .filter((sheet) => sheet !== null);
+    }
+    hasFocus() {
+        return true;
+    }
+    get title() {
+        return this.head.querySelector("title")?.textContent ?? "";
+    }
+    set title(value) {
+        let title = this.head.querySelector("title");
+        if (!title) {
+            title = this.createElement("title");
+            this.head.appendChild(title);
+        }
+        title.textContent = String(value);
+    }
+    get ownerDocument() {
+        return null;
+    }
+    get activeElement() {
+        return this.#activeElement ?? this.body;
+    }
+    querySelector(selector) {
+        const id = this._querySelector(this.#documentNodeId, selector);
+        return id == null ? null : this._wrap(id);
+    }
+    querySelectorAll(selector) {
+        return new NativeNodeList(this, this._querySelectorAll(this.#documentNodeId, selector));
+    }
+    getElementById(id) {
+        const nativeId = this._native.elementById(this.#documentNodeId, String(id));
+        return nativeId == null ? null : this._wrap(nativeId);
+    }
+    createElement(localName) {
+        if (runtimeStats.enabled) {
+            recordOperation("createElement");
+        }
+        const normalizedName = String(localName).toLowerCase();
+        const id = this._native.createElement(normalizedName);
+        const nodeName = normalizedName.toUpperCase();
+        const definition = normalizedName.includes("-") && this._hasCustomElementDefinitions()
+            ? this.defaultView.customElements._definitionFor(normalizedName)
+            : undefined;
+        if (definition) {
+            const previousConstruction = customElementConstruction;
+            customElementConstruction = {
+                document: this,
+                id,
+                nodeName
+            };
+            try {
+                const element = new definition.constructor();
+                this._storeWrapper(id, element);
+                return element;
+            }
+            finally {
+                customElementConstruction = previousConstruction;
+            }
+        }
+        return this._wrapCreatedHTMLElement(id, nodeName);
+    }
+    createElementNS(namespaceURI, qualifiedName) {
+        if (runtimeStats.enabled) {
+            recordOperation("createElementNS");
+        }
+        const id = this._native.createElement(qualifiedName);
+        if (namespaceURI) {
+            this.#namespaces.set(id, namespaceURI);
+        }
+        return this._wrap(id, qualifiedName.toUpperCase());
+    }
+    createTextNode(value) {
+        if (runtimeStats.enabled) {
+            recordOperation("createTextNode");
+        }
+        const id = this._native.createTextNode(value);
+        const node = new Text(this, id, "#text");
+        this.#wrappers.set(id, node);
+        if (runtimeStats.enabled) {
+            recordWrapperCreated("#text");
+        }
+        return node;
+    }
+    createComment(value) {
+        if (runtimeStats.enabled) {
+            recordOperation("createComment");
+        }
+        const id = this._native.createComment(value);
+        const node = new Comment(this, id, "#comment");
+        this.#wrappers.set(id, node);
+        if (runtimeStats.enabled) {
+            recordWrapperCreated("#comment");
+        }
+        return node;
+    }
+    createDocumentFragment() {
+        if (runtimeStats.enabled) {
+            recordOperation("createDocumentFragment");
+        }
+        const id = this._native.createDocumentFragment();
+        const fragment = new DocumentFragment(this, id, "#document-fragment");
+        this.#wrappers.set(id, fragment);
+        if (runtimeStats.enabled) {
+            recordWrapperCreated("#document-fragment");
+        }
+        return fragment;
+    }
+    createRange() {
+        return new Range(this);
+    }
+    createEvent(eventInterface) {
+        switch (String(eventInterface).toLowerCase()) {
+            case "customevent":
+                return new CustomEvent("");
+            case "event":
+            case "events":
+            case "htmlevents":
+                return new Event("");
+            case "uievent":
+            case "uievents":
+                return new UIEvent("");
+            case "mouseevent":
+            case "mouseevents":
+                return new MouseEvent("");
+            case "pointerevent":
+            case "pointerevents":
+                return new PointerEvent("");
+            case "keyboardevent":
+            case "keyboardevents":
+                return new KeyboardEvent("");
+            case "focusevent":
+            case "focusevents":
+                return new FocusEvent("");
+            case "inputevent":
+            case "inputevents":
+                return new InputEvent("");
+            case "clipboardevent":
+            case "clipboardevents":
+                return new ClipboardEvent("");
+            case "touchevent":
+            case "touchevents":
+                return new TouchEvent("");
+            default:
+                throw new DOMException(`The event interface "${eventInterface}" is not supported.`, "NotSupportedError");
+        }
+    }
+    getSelection() {
+        return this.defaultView.getSelection();
+    }
+    createTreeWalker(root, whatToShow = NodeFilter.SHOW_ALL, filter = null) {
+        return new TreeWalker(root, whatToShow, filter);
+    }
+    createNodeIterator(root, whatToShow = NodeFilter.SHOW_ALL, filter = null) {
+        return new NodeIterator(root, whatToShow, filter);
+    }
+    importNode(node, deep = false) {
+        return importNodeIntoDocument(this, node, deep);
+    }
+    adoptNode(node) {
+        if (node instanceof Document) {
+            throw new DOMException("Document nodes cannot be adopted.", "NotSupportedError");
+        }
+        if (node.ownerDocument === this) {
+            node.parentNode?.removeChild(node);
+            return node;
+        }
+        const adopted = importNodeIntoDocument(this, node, true);
+        node.parentNode?.removeChild(node);
+        return adopted;
+    }
+    getElementsByTagName(tagName) {
+        return this.querySelectorAll(tagName);
+    }
+    getElementsByClassName(classNames) {
+        return new NativeNodeList(this, this._elementsByClassName(this.#documentNodeId, String(classNames)));
+    }
+    getElementsByName(name) {
+        return new NativeNodeList(this, this._native.elementsByName(this.#documentNodeId, String(name)));
+    }
+    _setActiveElement(element) {
+        this.#activeElement = element;
+    }
+    _replaceWithHtml(html) {
+        if (runtimeStats.enabled) {
+            recordNativeCall("parseHtmlDocumentNative");
+        }
+        this._native = prepareNativeDocument(parseHtmlDocumentNative(html));
+        this.#wrappers = new Map();
+        this.#activeElement = null;
+        this.#documentNodeId = this._native.documentNode();
+        this.#documentElementId = this._native.documentElement();
+        this.#headId = this._native.head();
+        this.#bodyId = this._native.body();
+        this.#namespaces.clear();
+        this.#mutationVersion++;
+        this.#queryAllCache.clear();
+        this.#queryOneCache.clear();
+        this.#classNameCache.clear();
+        this.#matchesCache.clear();
+        this.#closestCache.clear();
+        this.#lastQueryAllRootId = null;
+        this.#lastQueryOneRootId = null;
+        this.#lastClassNameRootId = null;
+        this.#lastMatchesId = null;
+        this.#lastClosestId = null;
+        this._id = this.#documentNodeId;
+    }
+    _mutationVersion() {
+        return this.#mutationVersion;
+    }
+    _documentNodeId() {
+        return this.#documentNodeId;
+    }
+    _storeWrapper(id, node) {
+        this.#wrappers.set(id, node);
+    }
+    _hasCustomElementDefinitions() {
+        if (runtimeStats.enabled) {
+            recordOperation("customElementCheckCalls");
+        }
+        const registry = this.defaultView.customElements;
+        const version = registry._version();
+        if (version !== this.#customElementRegistryVersion) {
+            if (runtimeStats.enabled) {
+                recordOperation("customElementRegistryReads");
+            }
+            this.#customElementRegistryVersion = version;
+            this.#hasCustomElementDefinitions = registry._hasDefinitions();
+        }
+        return this.#hasCustomElementDefinitions;
+    }
+    _bumpMutationVersion() {
+        if (runtimeStats.enabled) {
+            recordOperation("mutationBumps");
+        }
+        this.#mutationVersion++;
+        // Cache entries are version-tagged, so hot mutation loops only need to
+        // advance the version. Periodic pruning bounds stale entries.
+        if ((this.#mutationVersion & 1023) === 0 &&
+            (this.#queryAllCache.size > 0 ||
+                this.#queryOneCache.size > 0 ||
+                this.#classNameCache.size > 0 ||
+                this.#matchesCache.size > 0 ||
+                this.#closestCache.size > 0)) {
+            this.#queryAllCache.clear();
+            this.#queryOneCache.clear();
+            this.#classNameCache.clear();
+            this.#matchesCache.clear();
+            this.#closestCache.clear();
+        }
+    }
+    _namespaceFor(id) {
+        return this.#namespaces.get(id) ?? HTML_NAMESPACE;
+    }
+    _querySelectorAll(rootId, selector) {
+        if (this.#lastQueryAllVersion === this.#mutationVersion &&
+            this.#lastQueryAllRootId === rootId &&
+            this.#lastQueryAllSelector === selector) {
+            return this.#lastQueryAllIds;
+        }
+        const key = `${rootId}\u0000${selector}`;
+        const cached = this.#queryAllCache.get(key);
+        if (cached?.version === this.#mutationVersion) {
+            this.#lastQueryAllRootId = rootId;
+            this.#lastQueryAllSelector = selector;
+            this.#lastQueryAllVersion = this.#mutationVersion;
+            this.#lastQueryAllIds = cached.ids;
+            return cached.ids;
+        }
+        const ids = this._native.querySelectorAll(rootId, selector);
+        this.#queryAllCache.set(key, {
+            version: this.#mutationVersion,
+            ids
+        });
+        this.#lastQueryAllRootId = rootId;
+        this.#lastQueryAllSelector = selector;
+        this.#lastQueryAllVersion = this.#mutationVersion;
+        this.#lastQueryAllIds = ids;
+        return ids;
+    }
+    _querySelector(rootId, selector) {
+        if (this.#lastQueryOneVersion === this.#mutationVersion &&
+            this.#lastQueryOneRootId === rootId &&
+            this.#lastQueryOneSelector === selector) {
+            return this.#lastQueryOneId;
+        }
+        const key = `${rootId}\u0000${selector}`;
+        const cached = this.#queryOneCache.get(key);
+        if (cached?.version === this.#mutationVersion) {
+            this.#lastQueryOneRootId = rootId;
+            this.#lastQueryOneSelector = selector;
+            this.#lastQueryOneVersion = this.#mutationVersion;
+            this.#lastQueryOneId = cached.id;
+            return cached.id;
+        }
+        const id = this._native.querySelector(rootId, selector) ?? null;
+        this.#queryOneCache.set(key, {
+            version: this.#mutationVersion,
+            id
+        });
+        this.#lastQueryOneRootId = rootId;
+        this.#lastQueryOneSelector = selector;
+        this.#lastQueryOneVersion = this.#mutationVersion;
+        this.#lastQueryOneId = id;
+        return id;
+    }
+    _elementsByClassName(rootId, classNames) {
+        if (this.#lastClassNameVersion === this.#mutationVersion &&
+            this.#lastClassNameRootId === rootId &&
+            this.#lastClassNameSelector === classNames) {
+            return this.#lastClassNameIds;
+        }
+        const key = `${rootId}\u0000${classNames}`;
+        const cached = this.#classNameCache.get(key);
+        if (cached?.version === this.#mutationVersion) {
+            this.#lastClassNameRootId = rootId;
+            this.#lastClassNameSelector = classNames;
+            this.#lastClassNameVersion = this.#mutationVersion;
+            this.#lastClassNameIds = cached.ids;
+            return cached.ids;
+        }
+        const ids = this._native.elementsByClassName(rootId, classNames);
+        this.#classNameCache.set(key, {
+            version: this.#mutationVersion,
+            ids
+        });
+        this.#lastClassNameRootId = rootId;
+        this.#lastClassNameSelector = classNames;
+        this.#lastClassNameVersion = this.#mutationVersion;
+        this.#lastClassNameIds = ids;
+        return ids;
+    }
+    _matchesSelector(id, selector) {
+        if (this.#lastMatchesVersion === this.#mutationVersion &&
+            this.#lastMatchesId === id &&
+            this.#lastMatchesSelector === selector) {
+            return this.#lastMatchesResult;
+        }
+        const key = `${id}\u0000${selector}`;
+        const cached = this.#matchesCache.get(key);
+        if (cached?.version === this.#mutationVersion) {
+            this.#lastMatchesId = id;
+            this.#lastMatchesSelector = selector;
+            this.#lastMatchesVersion = this.#mutationVersion;
+            this.#lastMatchesResult = cached.result;
+            return cached.result;
+        }
+        const result = this._native.matchesSelector(id, selector);
+        this.#matchesCache.set(key, {
+            version: this.#mutationVersion,
+            result
+        });
+        this.#lastMatchesId = id;
+        this.#lastMatchesSelector = selector;
+        this.#lastMatchesVersion = this.#mutationVersion;
+        this.#lastMatchesResult = result;
+        return result;
+    }
+    _closest(id, selector) {
+        if (this.#lastClosestVersion === this.#mutationVersion &&
+            this.#lastClosestId === id &&
+            this.#lastClosestSelector === selector) {
+            return this.#lastClosestResult;
+        }
+        const key = `${id}\u0000${selector}`;
+        const cached = this.#closestCache.get(key);
+        if (cached?.version === this.#mutationVersion) {
+            this.#lastClosestId = id;
+            this.#lastClosestSelector = selector;
+            this.#lastClosestVersion = this.#mutationVersion;
+            this.#lastClosestResult = cached.id;
+            return cached.id;
+        }
+        const result = this._native.closest(id, selector) ?? null;
+        this.#closestCache.set(key, {
+            version: this.#mutationVersion,
+            id: result
+        });
+        this.#lastClosestId = id;
+        this.#lastClosestSelector = selector;
+        this.#lastClosestVersion = this.#mutationVersion;
+        this.#lastClosestResult = result;
+        return result;
+    }
+    _wrapCreatedHTMLElement(id, nodeName) {
+        const wrapper = createHTMLElementWrapper(this, id, nodeName);
+        this.#wrappers.set(id, wrapper);
+        if (runtimeStats.enabled) {
+            recordWrapperCreated(nodeName);
+        }
+        return wrapper;
+    }
+    _wrap(id, knownNodeName = null) {
+        if (id === this.#documentNodeId) {
+            if (runtimeStats.enabled) {
+                runtimeStats.wrappers.documentHits++;
+            }
+            return this;
+        }
+        const existing = this.#wrappers.get(id);
+        if (existing) {
+            if (runtimeStats.enabled) {
+                runtimeStats.wrappers.cacheHits++;
+            }
+            return existing;
+        }
+        if (knownNodeName != null) {
+            const wrapper = knownNodeName === "#text"
+                ? new Text(this, id, knownNodeName)
+                : knownNodeName === "#comment"
+                    ? new Comment(this, id, knownNodeName)
+                    : knownNodeName === "#document-fragment"
+                        ? new DocumentFragment(this, id, knownNodeName)
+                        : this.#namespaces.get(id) === SVG_NAMESPACE
+                            ? new SVGElement(this, id, knownNodeName)
+                            : this.#namespaces.get(id) === MATHML_NAMESPACE
+                                ? new MathMLElement(this, id, knownNodeName)
+                                : createHTMLElementWrapper(this, id, knownNodeName);
+            this.#wrappers.set(id, wrapper);
+            if (runtimeStats.enabled) {
+                recordWrapperCreated(knownNodeName);
+            }
+            return wrapper;
+        }
+        const nodeType = this._native.nodeType(id);
+        const nodeName = this._native.nodeName(id);
+        const wrapper = nodeType === Node.TEXT_NODE
+            ? new Text(this, id, nodeName)
+            : nodeType === Node.COMMENT_NODE
+                ? new Comment(this, id, nodeName)
+                : nodeType === Node.DOCUMENT_TYPE_NODE
+                    ? new DocumentType(this, id, nodeName)
+                    : nodeType === Node.DOCUMENT_FRAGMENT_NODE
+                        ? new DocumentFragment(this, id, nodeName)
+                        : this.#namespaces.get(id) === SVG_NAMESPACE
+                            ? new SVGElement(this, id, nodeName)
+                            : this.#namespaces.get(id) === MATHML_NAMESPACE
+                                ? new MathMLElement(this, id, nodeName)
+                                : createHTMLElementWrapper(this, id, nodeName);
+        this.#wrappers.set(id, wrapper);
+        if (runtimeStats.enabled) {
+            recordWrapperCreated(nodeName);
+        }
+        return wrapper;
+    }
+}
+function importNodeIntoDocument(document, node, deep) {
+    switch (node.nodeType) {
+        case Node.ELEMENT_NODE: {
+            const element = node;
+            const clone = document.createElement(element.localName);
+            for (const attribute of element.attributes) {
+                clone.setAttribute(attribute.name, attribute.value);
+            }
+            if (deep) {
+                appendImportedChildren(document, clone, element instanceof HTMLTemplateElement ? element.content : element);
+            }
+            return clone;
+        }
+        case Node.TEXT_NODE:
+            return document.createTextNode(node.nodeValue ?? "");
+        case Node.COMMENT_NODE:
+            return document.createComment(node.nodeValue ?? "");
+        case Node.DOCUMENT_TYPE_NODE: {
+            const documentType = node;
+            return document.implementation.createDocumentType(documentType.name, documentType.publicId, documentType.systemId);
+        }
+        case Node.DOCUMENT_FRAGMENT_NODE: {
+            const fragment = document.createDocumentFragment();
+            if (deep) {
+                appendImportedChildren(document, fragment, node);
+            }
+            return fragment;
+        }
+        default: {
+            const fragment = document.createDocumentFragment();
+            if (deep) {
+                appendImportedChildren(document, fragment, node);
+            }
+            return fragment;
+        }
+    }
+}
+function appendImportedChildren(document, clone, source) {
+    for (const child of source.childNodes) {
+        clone.appendChild(importNodeIntoDocument(document, child, true));
+    }
+}
+function createHTMLElementWrapper(document, id, nodeName) {
+    switch (nodeName) {
+        case "BUTTON":
+            return new HTMLButtonElement(document, id, nodeName);
+        case "CANVAS":
+            return new HTMLCanvasElement(document, id, nodeName);
+        case "FORM":
+            return new HTMLFormElement(document, id, nodeName);
+        case "HTML":
+            return new HTMLHtmlElement(document, id, nodeName);
+        case "BODY":
+            return new HTMLBodyElement(document, id, nodeName);
+        case "IMG":
+            return new HTMLImageElement(document, id, nodeName);
+        case "INPUT":
+            return new HTMLInputElement(document, id, nodeName);
+        case "LINK":
+            return new HTMLLinkElement(document, id, nodeName);
+        case "OPTION":
+            return new HTMLOptionElement(document, id, nodeName);
+        case "SCRIPT":
+            return new HTMLScriptElement(document, id, nodeName);
+        case "SELECT":
+            return new HTMLSelectElement(document, id, nodeName);
+        case "STYLE":
+            return new HTMLStyleElement(document, id, nodeName);
+        case "TABLE":
+            return new HTMLTableElement(document, id, nodeName);
+        case "TBODY":
+        case "TFOOT":
+        case "THEAD":
+            return new HTMLTableSectionElement(document, id, nodeName);
+        case "TD":
+        case "TH":
+            return new HTMLTableCellElement(document, id, nodeName);
+        case "TEMPLATE":
+            return new HTMLTemplateElement(document, id, nodeName);
+        case "TR":
+            return new HTMLTableRowElement(document, id, nodeName);
+        case "TEXTAREA":
+            return new HTMLTextAreaElement(document, id, nodeName);
+        default:
+            return new HTMLElement(document, id, nodeName);
+    }
+}
+export class Element extends Node {
+    #classList = null;
+    #dataset = null;
+    #localName = null;
+    #shadowRoot = null;
+    #style = null;
+    get children() {
+        return new NativeNodeList(this._document, this._document._native.elementChildren(this._id));
+    }
+    get childElementCount() {
+        return this._document._native.childElementCount(this._id);
+    }
+    get firstElementChild() {
+        const id = this._document._native.firstElementChild(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get lastElementChild() {
+        const id = this._document._native.lastElementChild(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get previousElementSibling() {
+        const id = this._document._native.previousElementSibling(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get nextElementSibling() {
+        const id = this._document._native.nextElementSibling(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get tagName() {
+        return this.nodeName;
+    }
+    get localName() {
+        this.#localName ??= this.nodeName.toLowerCase();
+        return this.#localName;
+    }
+    get namespaceURI() {
+        return this._document._namespaceFor(this._id);
+    }
+    get shadowRoot() {
+        return this.#shadowRoot?.mode === "open" ? this.#shadowRoot : null;
+    }
+    attachShadow(init) {
+        if (this.#shadowRoot) {
+            throw new DOMException("Shadow root has already been attached.", "DOMException");
+        }
+        const mode = init.mode;
+        if (mode !== "open" && mode !== "closed") {
+            throw new TypeError("Shadow root mode must be \"open\" or \"closed\".");
+        }
+        const root = new ShadowRoot(this._document, this._document._native.createDocumentFragment(), this, mode);
+        this.#shadowRoot = root;
+        return root;
+    }
+    get innerHTML() {
+        return this._document._native.serializeChildren(this._id);
+    }
+    set innerHTML(html) {
+        if (!hasMutationObservers()) {
+            this._document._native.setInnerHtml(this._id, html);
+            this._document._bumpMutationVersion();
+            return;
+        }
+        const removedNodes = [...this.childNodes];
+        this._document._native.setInnerHtml(this._id, html);
+        this._document._bumpMutationVersion();
+        notifyMutation({
+            type: "childList",
+            target: this,
+            addedNodes: [...this.childNodes],
+            removedNodes,
+            attributeName: null,
+            oldValue: null
+        });
+    }
+    get outerHTML() {
+        return this._document._native.serializeNode(this._id);
+    }
+    set outerHTML(html) {
+        const parentId = this._document._native.parentNode(this._id);
+        if (parentId == null) {
+            return;
+        }
+        if (!hasMutationObservers() && !this._document._hasCustomElementDefinitions()) {
+            if (this._document._native.replaceWithHtmlFragment(this._id, html, "div")) {
+                this._document._bumpMutationVersion();
+            }
+            return;
+        }
+        const parent = this._document._wrap(parentId);
+        const fragment = fragmentFromHtml(this._document, html);
+        parent.insertBefore(fragment, this);
+        parent.removeChild(this);
+    }
+    get id() {
+        return this.getAttribute("id") ?? "";
+    }
+    set id(value) {
+        this.setAttribute("id", value);
+    }
+    get className() {
+        return this.getAttribute("class") ?? "";
+    }
+    set className(value) {
+        this.setAttribute("class", value);
+    }
+    get classList() {
+        this.#classList ??= new DOMTokenList(this, "class");
+        return this.#classList;
+    }
+    get dataset() {
+        this.#dataset ??= createDataset(this);
+        return this.#dataset;
+    }
+    get style() {
+        this.#style ??= new CSSStyleDeclaration(this.getAttribute("style") ?? "", this);
+        return this.#style;
+    }
+    get clientWidth() {
+        return elementBox(this).width;
+    }
+    get clientHeight() {
+        return elementBox(this).height;
+    }
+    get scrollWidth() {
+        return this.clientWidth;
+    }
+    get scrollHeight() {
+        return this.clientHeight;
+    }
+    get offsetWidth() {
+        return elementBox(this).width;
+    }
+    get offsetHeight() {
+        return elementBox(this).height;
+    }
+    getBoundingClientRect() {
+        const box = elementBox(this);
+        return new DOMRect(box.left, box.top, box.width, box.height);
+    }
+    getClientRects() {
+        if (this.ownerDocument && this.isConnected && elementDisplay(this) !== "none") {
+            return [this.getBoundingClientRect()];
+        }
+        return [];
+    }
+    setAttribute(name, value) {
+        if (runtimeStats.enabled) {
+            recordOperation("setAttribute");
+        }
+        const normalizedName = this.#normalizeAttributeName(name);
+        const stringValue = String(value);
+        const hasObservers = hasMutationObservers();
+        const hasCustomElements = this._document._hasCustomElementDefinitions();
+        if (!hasObservers && !hasCustomElements) {
+            this._document._native.setAttribute(this._id, normalizedName, stringValue);
+            this._document._bumpMutationVersion();
+            return;
+        }
+        const oldValue = this.getAttribute(normalizedName);
+        this._document._native.setAttribute(this._id, normalizedName, stringValue);
+        this._document._bumpMutationVersion();
+        if (hasCustomElements) {
+            notifyCustomElementAttributeChanged(this, normalizedName, oldValue, stringValue);
+        }
+        if (hasObservers) {
+            notifyMutation({
+                type: "attributes",
+                target: this,
+                addedNodes: [],
+                removedNodes: [],
+                attributeName: normalizedName,
+                oldValue
+            });
+        }
+    }
+    getAttribute(name) {
+        return this._document._native.getAttribute(this._id, this.#normalizeAttributeName(name));
+    }
+    getAttributeNode(name) {
+        const normalizedName = this.#normalizeAttributeName(name);
+        const value = this.getAttribute(normalizedName);
+        return value == null
+            ? null
+            : {
+                localName: normalizedName,
+                name: normalizedName,
+                value
+            };
+    }
+    hasAttribute(name) {
+        return this.getAttribute(name) !== null;
+    }
+    hasAttributes() {
+        return this.getAttributeNames().length > 0;
+    }
+    getAttributeNames() {
+        return this._document._native.attributeNames(this._id);
+    }
+    get attributes() {
+        return new NamedNodeMap(this.getAttributeNames().map((name) => ({
+            localName: name,
+            name,
+            value: this.getAttribute(name) ?? ""
+        })));
+    }
+    matches(selector) {
+        try {
+            return this._document._matchesSelector(this._id, selector);
+        }
+        catch {
+            return false;
+        }
+    }
+    scrollIntoView(_arg) { }
+    removeAttribute(name) {
+        if (runtimeStats.enabled) {
+            recordOperation("removeAttribute");
+        }
+        const normalizedName = this.#normalizeAttributeName(name);
+        const oldValue = this.getAttribute(normalizedName);
+        if (oldValue === null) {
+            return;
+        }
+        if (!hasMutationObservers()) {
+            this._document._native.removeAttribute(this._id, normalizedName);
+            this._document._bumpMutationVersion();
+            notifyCustomElementAttributeChanged(this, normalizedName, oldValue, null);
+            return;
+        }
+        this._document._native.removeAttribute(this._id, normalizedName);
+        this._document._bumpMutationVersion();
+        notifyCustomElementAttributeChanged(this, normalizedName, oldValue, null);
+        notifyMutation({
+            type: "attributes",
+            target: this,
+            addedNodes: [],
+            removedNodes: [],
+            attributeName: normalizedName,
+            oldValue
+        });
+    }
+    toggleAttribute(name, force) {
+        if (force === true) {
+            this.setAttribute(name, "");
+            return true;
+        }
+        if (force === false) {
+            this.removeAttribute(name);
+            return false;
+        }
+        if (this.hasAttribute(name)) {
+            this.removeAttribute(name);
+            return false;
+        }
+        this.setAttribute(name, "");
+        return true;
+    }
+    querySelector(selector) {
+        const id = this._document._querySelector(this._id, selector);
+        return id == null ? null : this._document._wrap(id);
+    }
+    querySelectorAll(selector) {
+        return new NativeNodeList(this._document, this._document._querySelectorAll(this._id, selector));
+    }
+    closest(selector) {
+        try {
+            const id = this._document._closest(this._id, selector);
+            return id == null ? null : this._document._wrap(id);
+        }
+        catch {
+            return null;
+        }
+    }
+    getElementsByTagName(tagName) {
+        return this.querySelectorAll(tagName);
+    }
+    getElementsByClassName(classNames) {
+        return new NativeNodeList(this._document, this._document._elementsByClassName(this._id, String(classNames)));
+    }
+    insertAdjacentElement(position, element) {
+        return this.#insertAdjacentNode(position, element) ? element : null;
+    }
+    insertAdjacentHTML(position, html) {
+        if (!hasMutationObservers() && !this._document._hasCustomElementDefinitions()) {
+            const normalized = position.toLowerCase();
+            let moved = false;
+            switch (normalized) {
+                case "beforebegin": {
+                    const parentId = this._document._native.parentNode(this._id);
+                    if (parentId != null) {
+                        moved = this._document._native.insertHtmlFragment(parentId, this._id, html, "div");
+                    }
+                    break;
+                }
+                case "afterbegin":
+                    moved = this._document._native.insertHtmlFragment(this._id, this._document._native.firstChild(this._id), html, "div");
+                    break;
+                case "beforeend":
+                    moved = this._document._native.insertHtmlFragment(this._id, null, html, "div");
+                    break;
+                case "afterend": {
+                    const parentId = this._document._native.parentNode(this._id);
+                    if (parentId != null) {
+                        moved = this._document._native.insertHtmlFragment(parentId, this._document._native.nextSibling(this._id), html, "div");
+                    }
+                    break;
+                }
+                default:
+                    throw new DOMException("Position must be one of beforebegin, afterbegin, beforeend, or afterend", "SyntaxError");
+            }
+            if (moved) {
+                this._document._bumpMutationVersion();
+            }
+            return;
+        }
+        this.#insertAdjacentNode(position, fragmentFromHtml(this._document, html));
+    }
+    insertAdjacentText(position, data) {
+        this.#insertAdjacentNode(position, this._document.createTextNode(String(data)));
+    }
+    #insertAdjacentNode(position, node) {
+        switch (position.toLowerCase()) {
+            case "beforebegin":
+                return this.parentNode ? this.parentNode.insertBefore(node, this) : null;
+            case "afterbegin":
+                return this.insertBefore(node, this.firstChild);
+            case "beforeend":
+                return this.appendChild(node);
+            case "afterend":
+                return this.parentNode ? this.parentNode.insertBefore(node, this.nextSibling) : null;
+            default:
+                throw new DOMException("Position must be one of beforebegin, afterbegin, beforeend, or afterend", "SyntaxError");
+        }
+    }
+    #normalizeAttributeName(name) {
+        const value = String(name);
+        return this.namespaceURI === HTML_NAMESPACE ? value.toLowerCase() : value;
+    }
+}
+function elementBox(element) {
+    if (elementDisplay(element) === "none") {
+        return { left: 0, top: 0, width: 0, height: 0 };
+    }
+    const style = inlineStyleFor(element);
+    return {
+        left: pixelValue(style.getPropertyValue("left")),
+        top: pixelValue(style.getPropertyValue("top")),
+        width: pixelValue(style.getPropertyValue("width")),
+        height: pixelValue(style.getPropertyValue("height"))
+    };
+}
+function elementDisplay(element) {
+    if (element.hasAttribute("hidden")) {
+        return "none";
+    }
+    return inlineStyleFor(element).display;
+}
+function inlineStyleFor(element) {
+    return new CSSStyleDeclaration(element.getAttribute("style") ?? "");
+}
+function pixelValue(value) {
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function parseNonNegativeInteger(value, fallback) {
+    const parsed = Number.parseInt(value ?? "", 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function resolveElementUrl(element, value) {
+    if (!value) {
+        return "";
+    }
+    const base = element.ownerDocument?.URL ?? "about:blank";
+    if (base.startsWith("about:") || base.startsWith("data:")) {
+        return value;
+    }
+    try {
+        return new URL(value, base).href;
+    }
+    catch {
+        return value;
+    }
+}
+function fragmentFromHtml(document, html) {
+    return document._wrap(document._native.createHtmlFragment(String(html), "div"));
+}
+export class SVGElement extends Element {
+}
+export class MathMLElement extends Element {
+}
+const htmlElementState = new WeakMap();
+function getHTMLElementState(element) {
+    let state = htmlElementState.get(element);
+    if (!state) {
+        state = {};
+        htmlElementState.set(element, state);
+    }
+    return state;
+}
+export class HTMLElement extends Element {
+    constructor(document, id, nodeName = null) {
+        if (document && id !== undefined) {
+            super(document, id, nodeName);
+            return;
+        }
+        if (customElementConstruction) {
+            super(customElementConstruction.document, customElementConstruction.id, customElementConstruction.nodeName);
+            return;
+        }
+        const active = activeDocument();
+        super(active, active._native.createElement("div"), "DIV");
+    }
+    get innerText() {
+        return this.textContent;
+    }
+    set innerText(value) {
+        this.textContent = String(value);
+    }
+    get hidden() {
+        return this.hasAttribute("hidden");
+    }
+    set hidden(value) {
+        if (value) {
+            this.setAttribute("hidden", "");
+        }
+        else {
+            this.removeAttribute("hidden");
+        }
+    }
+    get type() {
+        return this.getAttribute("type") ?? (this.localName === "input" ? "text" : "");
+    }
+    set type(value) {
+        this.setAttribute("type", String(value));
+    }
+    get name() {
+        return this.getAttribute("name") ?? "";
+    }
+    set name(value) {
+        this.setAttribute("name", String(value));
+    }
+    get placeholder() {
+        return this.getAttribute("placeholder") ?? "";
+    }
+    set placeholder(value) {
+        this.setAttribute("placeholder", String(value));
+    }
+    get htmlFor() {
+        return this.getAttribute("for") ?? "";
+    }
+    set htmlFor(value) {
+        this.setAttribute("for", String(value));
+    }
+    get value() {
+        if (this.localName === "select") {
+            const option = this.options?.item(this.selectedIndex);
+            return option?.value ?? "";
+        }
+        if (this.localName === "option") {
+            return this.getAttribute("value") ?? this.textContent;
+        }
+        if (this.localName === "textarea") {
+            return htmlElementState.get(this)?.value ?? this.defaultValue;
+        }
+        return htmlElementState.get(this)?.value ?? this.defaultValue;
+    }
+    set value(value) {
+        if (this.localName === "select") {
+            const options = [...(this.options ?? [])];
+            const index = options.findIndex((option) => option.value === String(value));
+            if (index !== -1) {
+                this.selectedIndex = index;
+            }
+            return;
+        }
+        const nextValue = value === null ? "" : String(value);
+        if (this.localName === "input" &&
+            this.type.toLowerCase() === "number" &&
+            nextValue !== "" &&
+            !isValidNumberValue(nextValue)) {
+            getHTMLElementState(this).value = "";
+            return;
+        }
+        getHTMLElementState(this).value = nextValue;
+    }
+    get defaultValue() {
+        if (this.localName === "textarea") {
+            return this.textContent;
+        }
+        return this.getAttribute("value") ?? "";
+    }
+    set defaultValue(value) {
+        if (this.localName === "textarea") {
+            this.textContent = String(value);
+            return;
+        }
+        this.setAttribute("value", String(value));
+    }
+    get checked() {
+        return htmlElementState.get(this)?.checked ?? this.defaultChecked;
+    }
+    set checked(value) {
+        getHTMLElementState(this).checked = value;
+    }
+    get defaultChecked() {
+        return this.hasAttribute("checked");
+    }
+    set defaultChecked(value) {
+        this.#toggleBooleanAttribute("checked", value);
+    }
+    get readOnly() {
+        return this.hasAttribute("readonly");
+    }
+    set readOnly(value) {
+        this.#toggleBooleanAttribute("readonly", value);
+    }
+    get multiple() {
+        return this.hasAttribute("multiple");
+    }
+    set multiple(value) {
+        this.#toggleBooleanAttribute("multiple", value);
+    }
+    get selected() {
+        return htmlElementState.get(this)?.selected ?? this.hasAttribute("selected");
+    }
+    set selected(value) {
+        getHTMLElementState(this).selected = value;
+    }
+    get selectedIndex() {
+        const options = [...(this.options ?? [])];
+        if (options.length === 0) {
+            return -1;
+        }
+        const selectedIndex = options.findIndex((option) => option.selected);
+        return selectedIndex === -1 ? 0 : selectedIndex;
+    }
+    set selectedIndex(value) {
+        const options = [...(this.options ?? [])];
+        options.forEach((option, index) => {
+            option.selected = index === value;
+        });
+    }
+    get options() {
+        if (this.localName !== "select") {
+            return undefined;
+        }
+        return new NativeNodeList(this._document, [...this.querySelectorAll("option")].map((option) => option._nativeId));
+    }
+    get text() {
+        return this.textContent;
+    }
+    set text(value) {
+        this.textContent = String(value);
+    }
+    get form() {
+        if (!isFormAssociatedElement(this)) {
+            return null;
+        }
+        const formId = this.getAttribute("form");
+        if (formId) {
+            const form = this._document.getElementById(formId);
+            return form instanceof HTMLElement && form.localName === "form" ? form : null;
+        }
+        const form = this.closest("form");
+        return form instanceof HTMLElement ? form : null;
+    }
+    get elements() {
+        if (this.localName !== "form") {
+            return undefined;
+        }
+        const selector = "button, fieldset, input, object, output, select, textarea";
+        const descendants = [...this.querySelectorAll(selector)];
+        const external = this.id
+            ? [...this._document.querySelectorAll("[form]")]
+                .filter((element) => element.getAttribute("form") === this.id)
+            : [];
+        return new NativeNodeList(this._document, [...descendants, ...external]
+            .filter((element) => element instanceof HTMLElement)
+            .filter((element) => element.form === this)
+            .map((element) => element._nativeId));
+    }
+    get control() {
+        if (this.localName !== "label") {
+            return null;
+        }
+        if (this.htmlFor) {
+            const control = this._document.getElementById(this.htmlFor);
+            return control instanceof HTMLElement ? control : null;
+        }
+        return [...this.querySelectorAll("button, input, meter, output, progress, select, textarea")]
+            .filter(isLabelableElement)[0] ?? null;
+    }
+    get labels() {
+        if (!isLabelableElement(this)) {
+            return undefined;
+        }
+        const labels = [...this._document.querySelectorAll("label")].filter((label) => label instanceof HTMLElement && label.control === this);
+        return new NativeNodeList(this._document, labels.map((label) => label._nativeId));
+    }
+    get validity() {
+        if (!hasValidityState(this)) {
+            return undefined;
+        }
+        return new ValidityState({
+            customError: (htmlElementState.get(this)?.customValidityMessage ?? "") !== "",
+            rangeOverflow: this.#isRangeOverflow(),
+            rangeUnderflow: this.#isRangeUnderflow(),
+            tooLong: this.#isTooLong(),
+            tooShort: this.#isTooShort(),
+            typeMismatch: this.#isTypeMismatch(),
+            valueMissing: this.#isValueMissing()
+        });
+    }
+    get validationMessage() {
+        return htmlElementState.get(this)?.customValidityMessage ?? "";
+    }
+    get willValidate() {
+        if (this.localName !== "input" && this.localName !== "select") {
+            return undefined;
+        }
+        if (isDisabledFormElement(this) || this.readOnly) {
+            return false;
+        }
+        return !(this.localName === "input" && this.type.toLowerCase() === "hidden");
+    }
+    setCustomValidity(message) {
+        getHTMLElementState(this).customValidityMessage = String(message);
+    }
+    checkValidity() {
+        if (this.localName === "form") {
+            return [...(this.elements ?? [])].every((element) => element.checkValidity());
+        }
+        if (!hasValidityState(this)) {
+            return true;
+        }
+        if (isDisabledFormElement(this) ||
+            this.readOnly ||
+            (this.localName === "input" && this.type.toLowerCase() === "hidden")) {
+            return true;
+        }
+        return this.validity?.valid ?? true;
+    }
+    reportValidity() {
+        return this.checkValidity();
+    }
+    click() {
+        this.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+    }
+    submit() {
+        this.requestSubmit();
+    }
+    requestSubmit() {
+        if (this.localName !== "form") {
+            return;
+        }
+        if (!this.checkValidity()) {
+            return;
+        }
+        this.dispatchEvent(new SubmitEvent("submit", { bubbles: true, cancelable: true }));
+    }
+    reset() {
+        if (this.localName !== "form") {
+            return;
+        }
+        const event = new Event("reset", { bubbles: true, cancelable: true });
+        if (!this.dispatchEvent(event)) {
+            return;
+        }
+        for (const element of this.elements ?? []) {
+            element.#resetFormValue();
+        }
+    }
+    focus() {
+        if (this._document.activeElement === this) {
+            return;
+        }
+        const previous = this._document.activeElement;
+        if (previous instanceof HTMLElement && previous !== this._document.body) {
+            previous.#blurWithoutFocusCheck();
+        }
+        this._document._setActiveElement(this);
+        this.dispatchEvent(new FocusEvent("focus"));
+        this.dispatchEvent(new FocusEvent("focusin", { bubbles: true }));
+    }
+    blur() {
+        if (this._document.activeElement !== this) {
+            return;
+        }
+        this.#blurWithoutFocusCheck();
+    }
+    #blurWithoutFocusCheck() {
+        this._document._setActiveElement(null);
+        this.dispatchEvent(new FocusEvent("blur"));
+        this.dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
+    }
+    #toggleBooleanAttribute(name, value) {
+        if (value) {
+            this.setAttribute(name, "");
+        }
+        else {
+            this.removeAttribute(name);
+        }
+    }
+    #resetFormValue() {
+        if (this.localName === "input") {
+            const state = getHTMLElementState(this);
+            state.value = null;
+            state.checked = null;
+            return;
+        }
+        if (this.localName === "textarea") {
+            getHTMLElementState(this).value = null;
+            return;
+        }
+        if (this.localName === "select") {
+            for (const option of this.options ?? []) {
+                getHTMLElementState(option).selected = null;
+            }
+            const options = [...(this.options ?? [])];
+            const selectedIndex = options.findIndex((option) => option.hasAttribute("selected"));
+            this.selectedIndex = selectedIndex === -1 && options.length > 0 ? 0 : selectedIndex;
+        }
+    }
+    #isValueMissing() {
+        if (!["input", "select", "textarea"].includes(this.localName)) {
+            return false;
+        }
+        if (!this.hasAttribute("required")) {
+            return false;
+        }
+        if (this.localName === "input") {
+            const type = this.type.toLowerCase();
+            if (type === "checkbox" || type === "radio") {
+                return !this.checked;
+            }
+        }
+        return this.value === "";
+    }
+    #isTypeMismatch() {
+        if (this.localName !== "input" || this.value === "") {
+            return false;
+        }
+        if (this.type.toLowerCase() === "email") {
+            return !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(this.value);
+        }
+        return false;
+    }
+    #isRangeUnderflow() {
+        if (this.localName !== "input" || this.type.toLowerCase() !== "number" || this.value === "") {
+            return false;
+        }
+        const min = Number.parseFloat(this.getAttribute("min") ?? "");
+        return Number.isFinite(min) && Number.parseFloat(this.value) < min;
+    }
+    #isRangeOverflow() {
+        if (this.localName !== "input" || this.type.toLowerCase() !== "number" || this.value === "") {
+            return false;
+        }
+        const max = Number.parseFloat(this.getAttribute("max") ?? "");
+        return Number.isFinite(max) && Number.parseFloat(this.value) > max;
+    }
+    #isTooShort() {
+        if (!["input", "textarea"].includes(this.localName) || this.value === "") {
+            return false;
+        }
+        const minLength = Number.parseInt(this.getAttribute("minlength") ?? "", 10);
+        return Number.isFinite(minLength) && this.value.length < minLength;
+    }
+    #isTooLong() {
+        if (!["input", "textarea"].includes(this.localName) || this.value === "") {
+            return false;
+        }
+        const maxLength = Number.parseInt(this.getAttribute("maxlength") ?? "", 10);
+        return Number.isFinite(maxLength) && this.value.length > maxLength;
+    }
+}
+export class HTMLButtonElement extends HTMLElement {
+    get disabled() {
+        return this.hasAttribute("disabled");
+    }
+    set disabled(value) {
+        toggleBooleanAttribute(this, "disabled", value);
+    }
+}
+export class HTMLCanvasElement extends HTMLElement {
+    get width() {
+        return Number.parseInt(this.getAttribute("width") ?? "300", 10);
+    }
+    set width(value) {
+        this.setAttribute("width", String(value));
+    }
+    get height() {
+        return Number.parseInt(this.getAttribute("height") ?? "150", 10);
+    }
+    set height(value) {
+        this.setAttribute("height", String(value));
+    }
+    getContext(_contextId, ..._arguments_) {
+        return null;
+    }
+    toDataURL(_type, ..._arguments_) {
+        return "data:,";
+    }
+}
+export class HTMLFormElement extends HTMLElement {
+}
+export class HTMLHtmlElement extends HTMLElement {
+}
+export class HTMLBodyElement extends HTMLElement {
+}
+export class HTMLImageElement extends HTMLElement {
+    get alt() {
+        return this.getAttribute("alt") ?? "";
+    }
+    set alt(value) {
+        this.setAttribute("alt", String(value));
+    }
+    get src() {
+        return resolveElementUrl(this, this.getAttribute("src") ?? "");
+    }
+    set src(value) {
+        this.setAttribute("src", String(value));
+    }
+    get currentSrc() {
+        return this.src;
+    }
+    get srcset() {
+        return this.getAttribute("srcset") ?? "";
+    }
+    set srcset(value) {
+        this.setAttribute("srcset", String(value));
+    }
+    get sizes() {
+        return this.getAttribute("sizes") ?? "";
+    }
+    set sizes(value) {
+        this.setAttribute("sizes", String(value));
+    }
+    get width() {
+        return parseNonNegativeInteger(this.getAttribute("width"), 0);
+    }
+    set width(value) {
+        this.setAttribute("width", String(Math.max(0, Number(value) || 0)));
+    }
+    get height() {
+        return parseNonNegativeInteger(this.getAttribute("height"), 0);
+    }
+    set height(value) {
+        this.setAttribute("height", String(Math.max(0, Number(value) || 0)));
+    }
+    get naturalWidth() {
+        return 0;
+    }
+    get naturalHeight() {
+        return 0;
+    }
+    get complete() {
+        return false;
+    }
+    get loading() {
+        return this.getAttribute("loading") ?? "auto";
+    }
+    set loading(value) {
+        this.setAttribute("loading", String(value));
+    }
+    get decoding() {
+        return this.getAttribute("decoding") ?? "auto";
+    }
+    set decoding(value) {
+        this.setAttribute("decoding", String(value));
+    }
+    get crossOrigin() {
+        return this.getAttribute("crossorigin");
+    }
+    set crossOrigin(value) {
+        if (value === null) {
+            this.removeAttribute("crossorigin");
+            return;
+        }
+        this.setAttribute("crossorigin", String(value));
+    }
+    get referrerPolicy() {
+        return this.getAttribute("referrerpolicy") ?? "";
+    }
+    set referrerPolicy(value) {
+        this.setAttribute("referrerpolicy", String(value));
+    }
+}
+function createImageConstructor(document) {
+    const ImageConstructor = function Image(width, height) {
+        const element = document.createElement("img");
+        Object.setPrototypeOf(element, ImageConstructor.prototype);
+        if (width !== undefined) {
+            element.width = width;
+        }
+        if (height !== undefined) {
+            element.height = height;
+        }
+        return element;
+    };
+    Object.setPrototypeOf(ImageConstructor.prototype, HTMLImageElement.prototype);
+    Object.defineProperty(ImageConstructor.prototype, "constructor", {
+        configurable: true,
+        value: ImageConstructor,
+        writable: true
+    });
+    return ImageConstructor;
+}
+export class HTMLLinkElement extends HTMLElement {
+    #disabled;
+    get href() {
+        return resolveElementUrl(this, this.getAttribute("href") ?? "");
+    }
+    set href(value) {
+        this.setAttribute("href", String(value));
+    }
+    get rel() {
+        return this.getAttribute("rel") ?? "";
+    }
+    set rel(value) {
+        this.setAttribute("rel", String(value));
+    }
+    get as() {
+        return this.getAttribute("as") ?? "";
+    }
+    set as(value) {
+        this.setAttribute("as", String(value));
+    }
+    get type() {
+        return this.getAttribute("type") ?? "";
+    }
+    set type(value) {
+        this.setAttribute("type", String(value));
+    }
+    get media() {
+        return this.getAttribute("media") ?? "";
+    }
+    set media(value) {
+        this.setAttribute("media", String(value));
+    }
+    get crossOrigin() {
+        return this.getAttribute("crossorigin") ?? "";
+    }
+    set crossOrigin(value) {
+        this.setAttribute("crossorigin", String(value));
+    }
+    get referrerPolicy() {
+        return this.getAttribute("referrerpolicy") ?? "";
+    }
+    set referrerPolicy(value) {
+        this.setAttribute("referrerpolicy", String(value));
+    }
+    get disabled() {
+        return this.#disabled;
+    }
+    set disabled(value) {
+        this.#disabled = Boolean(value);
+    }
+    get sheet() {
+        return null;
+    }
+}
+export class HTMLScriptElement extends HTMLElement {
+    get src() {
+        return resolveElementUrl(this, this.getAttribute("src") ?? "");
+    }
+    set src(value) {
+        this.setAttribute("src", String(value));
+    }
+    get type() {
+        return this.getAttribute("type") ?? "";
+    }
+    set type(value) {
+        this.setAttribute("type", String(value));
+    }
+    get charset() {
+        return this.getAttribute("charset") ?? "";
+    }
+    set charset(value) {
+        this.setAttribute("charset", String(value));
+    }
+    get lang() {
+        return this.getAttribute("lang") ?? "";
+    }
+    set lang(value) {
+        this.setAttribute("lang", String(value));
+    }
+    get async() {
+        return this.hasAttribute("async");
+    }
+    set async(value) {
+        toggleBooleanAttribute(this, "async", value);
+    }
+    get defer() {
+        return this.hasAttribute("defer");
+    }
+    set defer(value) {
+        toggleBooleanAttribute(this, "defer", value);
+    }
+    get noModule() {
+        return this.hasAttribute("nomodule");
+    }
+    set noModule(value) {
+        toggleBooleanAttribute(this, "nomodule", value);
+    }
+    get crossOrigin() {
+        return this.getAttribute("crossorigin") ?? "";
+    }
+    set crossOrigin(value) {
+        this.setAttribute("crossorigin", String(value));
+    }
+    get integrity() {
+        return this.getAttribute("integrity") ?? "";
+    }
+    set integrity(value) {
+        this.setAttribute("integrity", String(value));
+    }
+    get referrerPolicy() {
+        return this.getAttribute("referrerpolicy") ?? "";
+    }
+    set referrerPolicy(value) {
+        this.setAttribute("referrerpolicy", String(value));
+    }
+    get text() {
+        return this.textContent;
+    }
+    set text(value) {
+        this.textContent = String(value);
+    }
+}
+export class HTMLTableElement extends HTMLElement {
+    get caption() {
+        return this.#directChild("caption");
+    }
+    get tHead() {
+        return this.#directChild("thead");
+    }
+    get tFoot() {
+        return this.#directChild("tfoot");
+    }
+    get tBodies() {
+        return collectionFromElements(this._document, [...this.children].filter((element) => element instanceof HTMLTableSectionElement && element.localName === "tbody"));
+    }
+    get rows() {
+        return collectionFromElements(this._document, [...this.querySelectorAll("tr")].filter((element) => element instanceof HTMLTableRowElement));
+    }
+    createTHead() {
+        return this.tHead ?? this.appendChild(this._document.createElement("thead"));
+    }
+    deleteTHead() {
+        this.tHead?.remove();
+    }
+    createTFoot() {
+        return this.tFoot ?? this.appendChild(this._document.createElement("tfoot"));
+    }
+    deleteTFoot() {
+        this.tFoot?.remove();
+    }
+    createTBody() {
+        return this.appendChild(this._document.createElement("tbody"));
+    }
+    insertRow(index = -1) {
+        const rows = [...this.rows];
+        const normalizedIndex = normalizeTableIndex(index, rows.length, true);
+        const row = this._document.createElement("tr");
+        if (normalizedIndex === rows.length) {
+            const bodies = [...this.tBodies];
+            const container = bodies[bodies.length - 1] ?? this.createTBody();
+            container.appendChild(row);
+            return row;
+        }
+        rows[normalizedIndex].parentNode?.insertBefore(row, rows[normalizedIndex]);
+        return row;
+    }
+    deleteRow(index) {
+        const rows = [...this.rows];
+        const normalizedIndex = normalizeTableIndex(index, rows.length, false);
+        rows[normalizedIndex]?.remove();
+    }
+    #directChild(localName) {
+        return ([...this.children].find((element) => element instanceof HTMLElement && element.localName === localName) ?? null);
+    }
+}
+export class HTMLTableSectionElement extends HTMLElement {
+    get rows() {
+        return collectionFromElements(this._document, [...this.children].filter((element) => element instanceof HTMLTableRowElement));
+    }
+    insertRow(index = -1) {
+        const rows = [...this.rows];
+        const normalizedIndex = normalizeTableIndex(index, rows.length, true);
+        const row = this._document.createElement("tr");
+        if (normalizedIndex === rows.length) {
+            this.appendChild(row);
+            return row;
+        }
+        this.insertBefore(row, rows[normalizedIndex]);
+        return row;
+    }
+    deleteRow(index) {
+        const rows = [...this.rows];
+        const normalizedIndex = normalizeTableIndex(index, rows.length, false);
+        rows[normalizedIndex]?.remove();
+    }
+}
+export class HTMLTableRowElement extends HTMLElement {
+    get cells() {
+        return collectionFromElements(this._document, [...this.children].filter((element) => element instanceof HTMLTableCellElement));
+    }
+    get rowIndex() {
+        const table = this.closest("table");
+        return table ? [...table.rows].indexOf(this) : -1;
+    }
+    get sectionRowIndex() {
+        const parent = this.parentElement;
+        if (parent instanceof HTMLTableSectionElement) {
+            return [...parent.rows].indexOf(this);
+        }
+        return -1;
+    }
+    insertCell(index = -1) {
+        const cells = [...this.cells];
+        const normalizedIndex = normalizeTableIndex(index, cells.length, true);
+        const cell = this._document.createElement("td");
+        if (normalizedIndex === cells.length) {
+            this.appendChild(cell);
+            return cell;
+        }
+        this.insertBefore(cell, cells[normalizedIndex]);
+        return cell;
+    }
+    deleteCell(index) {
+        const cells = [...this.cells];
+        const normalizedIndex = normalizeTableIndex(index, cells.length, false);
+        cells[normalizedIndex]?.remove();
+    }
+}
+export class HTMLTableCellElement extends HTMLElement {
+    get cellIndex() {
+        const parent = this.parentElement;
+        if (parent instanceof HTMLTableRowElement) {
+            return [...parent.cells].indexOf(this);
+        }
+        return -1;
+    }
+    get colSpan() {
+        return parseNonNegativeInteger(this.getAttribute("colspan"), 1) || 1;
+    }
+    set colSpan(value) {
+        this.setAttribute("colspan", String(Math.max(1, Number(value) || 1)));
+    }
+    get rowSpan() {
+        return parseNonNegativeInteger(this.getAttribute("rowspan"), 1) || 1;
+    }
+    set rowSpan(value) {
+        this.setAttribute("rowspan", String(Math.max(1, Number(value) || 1)));
+    }
+}
+function collectionFromElements(document, elements) {
+    return new NativeNodeList(document, elements.map((element) => element._nativeId));
+}
+function normalizeTableIndex(index, length, allowAppend) {
+    const normalizedIndex = Number(index);
+    if (!Number.isInteger(normalizedIndex)) {
+        throw new DOMException("The index is outside the allowed range.", "IndexSizeError");
+    }
+    if (normalizedIndex === -1) {
+        return allowAppend ? length : length - 1;
+    }
+    if (normalizedIndex < 0 || normalizedIndex > length || (!allowAppend && normalizedIndex === length)) {
+        throw new DOMException("The index is outside the allowed range.", "IndexSizeError");
+    }
+    return normalizedIndex;
+}
+function customElementDefinitionFor(element) {
+    return element.ownerDocument?.defaultView.customElements._definitionFor(element.localName);
+}
+function notifyCustomElementReparented(node, oldParent, wasConnected) {
+    const movedBetweenParents = oldParent !== null && oldParent !== node.parentNode;
+    const isConnected = node.isConnected;
+    if (wasConnected && (movedBetweenParents || !isConnected)) {
+        notifyCustomElementDisconnected(node);
+    }
+    if (isConnected && (!wasConnected || movedBetweenParents)) {
+        notifyCustomElementConnected(node);
+    }
+}
+function notifyCustomElementConnected(node) {
+    if (node instanceof Element) {
+        const callback = node.connectedCallback;
+        if (customElementDefinitionFor(node) && typeof callback === "function") {
+            callback.call(node);
+        }
+    }
+    for (const child of node.childNodes) {
+        notifyCustomElementConnected(child);
+    }
+}
+function notifyCustomElementDisconnected(node) {
+    if (node instanceof Element) {
+        const callback = node.disconnectedCallback;
+        if (customElementDefinitionFor(node) && typeof callback === "function") {
+            callback.call(node);
+        }
+    }
+    for (const child of node.childNodes) {
+        notifyCustomElementDisconnected(child);
+    }
+}
+function notifyCustomElementAttributeChanged(element, name, oldValue, newValue) {
+    const definition = customElementDefinitionFor(element);
+    if (!definition?.observedAttributes.includes(name)) {
+        return;
+    }
+    const callback = element.attributeChangedCallback;
+    if (typeof callback === "function") {
+        callback.call(element, name, oldValue, newValue);
+    }
+}
+export class HTMLTemplateElement extends HTMLElement {
+    #content;
+    constructor(document, id, nodeName) {
+        super(document, id, nodeName);
+        const contentId = document._native.templateContent(id);
+        this.#content =
+            contentId == null
+                ? document.createDocumentFragment()
+                : document._wrap(contentId, "#document-fragment");
+    }
+    get content() {
+        return this.#content;
+    }
+    get firstChild() {
+        return this.#content.firstChild;
+    }
+    get lastChild() {
+        return this.#content.lastChild;
+    }
+    get innerHTML() {
+        return this.#content.innerHTML;
+    }
+    set innerHTML(html) {
+        this.#content.innerHTML = html;
+    }
+    appendChild(child) {
+        return this.#content.appendChild(child);
+    }
+    append(...nodes) {
+        this.#content.append(...nodes);
+    }
+    prepend(...nodes) {
+        this.#content.prepend(...nodes);
+    }
+    insertBefore(child, referenceNode) {
+        return this.#content.insertBefore(child, referenceNode);
+    }
+    removeChild(child) {
+        return this.#content.removeChild(child);
+    }
+    replaceChild(newChild, oldChild) {
+        return this.#content.replaceChild(newChild, oldChild);
+    }
+    replaceChildren(...nodes) {
+        this.#content.replaceChildren(...nodes);
+    }
+}
+export class HTMLInputElement extends HTMLElement {
+    get accept() {
+        return this.getAttribute("accept") ?? "";
+    }
+    set accept(value) {
+        this.setAttribute("accept", String(value));
+    }
+    get files() {
+        return [];
+    }
+    get value() {
+        return super.value;
+    }
+    set value(value) {
+        super.value = value;
+    }
+    get checked() {
+        return super.checked;
+    }
+    set checked(value) {
+        super.checked = value;
+    }
+    get disabled() {
+        return this.hasAttribute("disabled");
+    }
+    set disabled(value) {
+        toggleBooleanAttribute(this, "disabled", value);
+    }
+    get multiple() {
+        return super.multiple;
+    }
+    set multiple(value) {
+        super.multiple = value;
+    }
+    get required() {
+        return this.hasAttribute("required");
+    }
+    set required(value) {
+        toggleBooleanAttribute(this, "required", value);
+    }
+}
+export class HTMLOptionElement extends HTMLElement {
+    get disabled() {
+        return this.hasAttribute("disabled");
+    }
+    set disabled(value) {
+        toggleBooleanAttribute(this, "disabled", value);
+    }
+}
+export class HTMLSelectElement extends HTMLElement {
+    get value() {
+        return super.value;
+    }
+    set value(value) {
+        super.value = value;
+    }
+    get disabled() {
+        return this.hasAttribute("disabled");
+    }
+    set disabled(value) {
+        toggleBooleanAttribute(this, "disabled", value);
+    }
+    get required() {
+        return this.hasAttribute("required");
+    }
+    set required(value) {
+        toggleBooleanAttribute(this, "required", value);
+    }
+}
+export class HTMLStyleElement extends HTMLElement {
+    #sheet = null;
+    #sheetText = "";
+    get disabled() {
+        return this.hasAttribute("disabled");
+    }
+    set disabled(value) {
+        toggleBooleanAttribute(this, "disabled", value);
+    }
+    get media() {
+        return this.getAttribute("media") ?? "";
+    }
+    set media(value) {
+        this.setAttribute("media", String(value));
+    }
+    get type() {
+        return this.getAttribute("type") ?? "";
+    }
+    set type(value) {
+        this.setAttribute("type", String(value));
+    }
+    get sheet() {
+        if (!this.isConnected) {
+            return null;
+        }
+        this.#sheet ??= new CSSStyleSheet();
+        const text = this.textContent;
+        if (text !== this.#sheetText) {
+            this.#sheet.replaceSync(text);
+            this.#sheetText = text;
+        }
+        return this.#sheet;
+    }
+}
+export class HTMLTextAreaElement extends HTMLElement {
+    get disabled() {
+        return this.hasAttribute("disabled");
+    }
+    set disabled(value) {
+        toggleBooleanAttribute(this, "disabled", value);
+    }
+    get required() {
+        return this.hasAttribute("required");
+    }
+    set required(value) {
+        toggleBooleanAttribute(this, "required", value);
+    }
+}
+function toggleBooleanAttribute(element, name, value) {
+    if (value) {
+        element.setAttribute(name, "");
+    }
+    else {
+        element.removeAttribute(name);
+    }
+}
+function isValidNumberValue(value) {
+    return value.trim() !== "" && Number.isFinite(Number(value));
+}
+function isLabelableElement(element) {
+    if (!(element instanceof HTMLElement)) {
+        return false;
+    }
+    if (element.localName === "input" && element.type.toLowerCase() === "hidden") {
+        return false;
+    }
+    return ["button", "meter", "output", "progress", "select", "textarea", "input"].includes(element.localName);
+}
+function isDisabledFormElement(element) {
+    return element.hasAttribute("disabled");
+}
+function hasValidityState(element) {
+    return (element instanceof HTMLElement &&
+        ["button", "input", "select", "textarea"].includes(element.localName));
+}
+function isFormAssociatedElement(element) {
+    return (element instanceof HTMLElement &&
+        ["button", "fieldset", "input", "object", "output", "select", "textarea"].includes(element.localName));
+}
+function formDataEntryFor(element) {
+    if (!["input", "select", "textarea"].includes(element.localName)) {
+        return null;
+    }
+    if (isDisabledFormElement(element) || !element.name) {
+        return null;
+    }
+    if (element.localName === "input") {
+        const type = element.type.toLowerCase();
+        if (["button", "file", "image", "reset", "submit"].includes(type)) {
+            return null;
+        }
+        if ((type === "checkbox" || type === "radio") && !element.checked) {
+            return null;
+        }
+        if ((type === "checkbox" || type === "radio") && !element.hasAttribute("value")) {
+            return [element.name, "on"];
+        }
+    }
+    return [element.name, element.value];
+}
+function activeDocument() {
+    const candidate = globalThis.document;
+    return candidate instanceof Document ? candidate : new Window().document;
+}
+export class Text extends Node {
+    constructor(documentOrData = "", id, nodeName = "#text") {
+        if (documentOrData instanceof Document && id !== undefined) {
+            super(documentOrData, id, nodeName);
+            return;
+        }
+        const document = activeDocument();
+        super(document, document._native.createTextNode(String(documentOrData ?? "")), "#text");
+    }
+    get data() {
+        return this.nodeValue ?? "";
+    }
+    set data(value) {
+        this.nodeValue = value;
+    }
+}
+export class Comment extends Node {
+    constructor(documentOrData = "", id, nodeName = "#comment") {
+        if (documentOrData instanceof Document && id !== undefined) {
+            super(documentOrData, id, nodeName);
+            return;
+        }
+        const document = activeDocument();
+        super(document, document._native.createComment(String(documentOrData ?? "")), "#comment");
+    }
+    get data() {
+        return this.nodeValue ?? "";
+    }
+    set data(value) {
+        this.nodeValue = value;
+    }
+}
+export class DocumentType extends Node {
+    constructor(document, id, nodeName = null) {
+        super(document, id, nodeName);
+    }
+    get name() {
+        return this._document._native.documentTypeName(this._id);
+    }
+    get publicId() {
+        return this._document._native.documentTypePublicId(this._id);
+    }
+    get systemId() {
+        return this._document._native.documentTypeSystemId(this._id);
+    }
+    get nodeType() {
+        return Node.DOCUMENT_TYPE_NODE;
+    }
+    get nodeValue() {
+        return null;
+    }
+    set nodeValue(_value) { }
+    get textContent() {
+        return "";
+    }
+    set textContent(_value) { }
+    get outerHTML() {
+        return this._document._native.serializeNode(this._id);
+    }
+}
+export class DocumentFragment extends Node {
+    constructor(document, id, nodeName = "#document-fragment") {
+        if (document instanceof Document && id !== undefined) {
+            super(document, id, nodeName);
+            return;
+        }
+        const active = activeDocument();
+        super(active, active._native.createDocumentFragment(), "#document-fragment");
+    }
+    get children() {
+        return new NativeNodeList(this._document, this._document._native.elementChildren(this._id));
+    }
+    get childElementCount() {
+        return this._document._native.childElementCount(this._id);
+    }
+    get firstElementChild() {
+        const id = this._document._native.firstElementChild(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get lastElementChild() {
+        const id = this._document._native.lastElementChild(this._id);
+        return id == null ? null : this._document._wrap(id);
+    }
+    get innerHTML() {
+        return this._document._native.serializeChildren(this._id);
+    }
+    set innerHTML(html) {
+        if (!hasMutationObservers()) {
+            this._document._native.setInnerHtml(this._id, html);
+            this._document._bumpMutationVersion();
+            return;
+        }
+        while (this.firstChild) {
+            this.removeChild(this.firstChild);
+        }
+        this.appendChild(fragmentFromHtml(this._document, html));
+    }
+    querySelector(selector) {
+        const id = this._document._querySelector(this._id, selector);
+        return id == null ? null : this._document._wrap(id);
+    }
+    querySelectorAll(selector) {
+        return new NativeNodeList(this._document, this._document._querySelectorAll(this._id, selector));
+    }
+    getElementById(id) {
+        const nativeId = this._document._native.elementById(this._id, String(id));
+        return nativeId == null ? null : this._document._wrap(nativeId);
+    }
+}
+export class ShadowRoot extends DocumentFragment {
+    delegatesFocus = false;
+    host;
+    mode;
+    constructor(document, id, host, mode) {
+        super(document, id, "#document-fragment");
+        this.host = host;
+        this.mode = mode;
+    }
+}
+export class TreeWalker {
+    currentNode;
+    root;
+    whatToShow;
+    filter;
+    #document;
+    #nodeIds;
+    #index = 0;
+    constructor(root, whatToShow = NodeFilter.SHOW_ALL, filter = null) {
+        this.root = root;
+        this.currentNode = root;
+        this.whatToShow = whatToShow;
+        this.filter = filter;
+        const order = nativeDocumentOrder(root);
+        this.#document = order.document;
+        this.#nodeIds = order.ids;
+    }
+    nextNode() {
+        for (let index = this.#index + 1; index < this.#nodeIds.length; index++) {
+            const node = this.#document._wrap(this.#nodeIds[index]);
+            if (this.#accepts(node)) {
+                this.#index = index;
+                this.currentNode = node;
+                return node;
+            }
+        }
+        return null;
+    }
+    previousNode() {
+        for (let index = this.#index - 1; index >= 0; index--) {
+            const node = this.#document._wrap(this.#nodeIds[index]);
+            if (this.#accepts(node)) {
+                this.#index = index;
+                this.currentNode = node;
+                return node;
+            }
+        }
+        return null;
+    }
+    #accepts(node) {
+        if (!(this.whatToShow & nodeFilterMaskFor(node))) {
+            return false;
+        }
+        if (!this.filter) {
+            return true;
+        }
+        const result = typeof this.filter === "function"
+            ? this.filter(node)
+            : this.filter.acceptNode(node);
+        return result === NodeFilter.FILTER_ACCEPT;
+    }
+}
+export class NodeIterator {
+    root;
+    whatToShow;
+    filter;
+    #document;
+    #nodeIds;
+    #index = -1;
+    constructor(root, whatToShow = NodeFilter.SHOW_ALL, filter = null) {
+        this.root = root;
+        this.whatToShow = whatToShow;
+        this.filter = filter;
+        const order = nativeDocumentOrder(root);
+        this.#document = order.document;
+        this.#nodeIds = order.ids;
+    }
+    nextNode() {
+        for (let index = this.#index + 1; index < this.#nodeIds.length; index++) {
+            const node = this.#document._wrap(this.#nodeIds[index]);
+            if (this.#accepts(node)) {
+                this.#index = index;
+                return node;
+            }
+        }
+        return null;
+    }
+    previousNode() {
+        for (let index = this.#index - 1; index >= 0; index--) {
+            const node = this.#document._wrap(this.#nodeIds[index]);
+            if (this.#accepts(node)) {
+                this.#index = index;
+                return node;
+            }
+        }
+        return null;
+    }
+    detach() { }
+    #accepts(node) {
+        if (!(this.whatToShow & nodeFilterMaskFor(node))) {
+            return false;
+        }
+        if (!this.filter) {
+            return true;
+        }
+        const result = typeof this.filter === "function"
+            ? this.filter(node)
+            : this.filter.acceptNode(node);
+        return result === NodeFilter.FILTER_ACCEPT;
+    }
+}
+function nodeFilterMaskFor(node) {
+    switch (node.nodeType) {
+        case Node.ELEMENT_NODE:
+            return NodeFilter.SHOW_ELEMENT;
+        case Node.TEXT_NODE:
+            return NodeFilter.SHOW_TEXT;
+        case Node.COMMENT_NODE:
+            return NodeFilter.SHOW_COMMENT;
+        case Node.DOCUMENT_NODE:
+            return NodeFilter.SHOW_DOCUMENT;
+        case Node.DOCUMENT_TYPE_NODE:
+            return NodeFilter.SHOW_DOCUMENT_TYPE;
+        case Node.DOCUMENT_FRAGMENT_NODE:
+            return NodeFilter.SHOW_DOCUMENT_FRAGMENT;
+        default:
+            return 0;
+    }
+}
+export class NativeNodeList {
+    #document;
+    #ids;
+    constructor(document, ids) {
+        this.#document = document;
+        this.#ids = ids;
+        return new Proxy(this, {
+            get(target, property) {
+                if (typeof property === "string" && isNodeListIndex(property, target.length)) {
+                    return target.item(Number(property));
+                }
+                const value = Reflect.get(target, property, target);
+                return typeof value === "function" ? value.bind(target) : value;
+            },
+            getOwnPropertyDescriptor(target, property) {
+                if (typeof property === "string" && isNodeListIndex(property, target.length)) {
+                    return {
+                        configurable: true,
+                        enumerable: true,
+                        value: target.item(Number(property))
+                    };
+                }
+                return Reflect.getOwnPropertyDescriptor(target, property);
+            },
+            has(target, property) {
+                return ((typeof property === "string" && isNodeListIndex(property, target.length)) ||
+                    Reflect.has(target, property));
+            },
+            ownKeys(target) {
+                return [
+                    ...Array.from({ length: target.length }, (_value, index) => String(index)),
+                    ...Reflect.ownKeys(target)
+                ];
+            }
+        });
+    }
+    get length() {
+        return this.#ids.length;
+    }
+    item(index) {
+        const id = this.#ids[index];
+        return id == null ? null : this.#document._wrap(id);
+    }
+    forEach(callback) {
+        for (let index = 0; index < this.length; index++) {
+            const value = this.item(index);
+            if (value) {
+                callback(value, index, this);
+            }
+        }
+    }
+    [Symbol.iterator]() {
+        let index = 0;
+        return {
+            next: () => {
+                const value = this.item(index++);
+                return value == null ? { done: true, value: undefined } : { done: false, value };
+            }
+        };
+    }
+}
+function isNodeListIndex(property, length) {
+    if (!/^(0|[1-9]\d*)$/.test(property)) {
+        return false;
+    }
+    const index = Number(property);
+    return Number.isSafeInteger(index) && index >= 0 && index < length;
+}
+//# sourceMappingURL=index.js.map