@gjsify/dom-elements 0.1.0

package/lib/types/character-data.d.ts

@@ -0,0 +1,24 @@
+import { Node } from './node.js';
+/**
+ * CharacterData base class for Text and Comment nodes.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/CharacterData
+ */
+export declare class CharacterData extends Node {
+    private _data;
+    constructor(data?: string);
+    get data(): string;
+    set data(value: string);
+    get textContent(): string;
+    set textContent(value: string);
+    get nodeValue(): string;
+    set nodeValue(value: string);
+    get length(): number;
+    appendData(data: string): void;
+    deleteData(offset: number, count: number): void;
+    insertData(offset: number, data: string): void;
+    replaceData(offset: number, count: number, data: string): void;
+    substringData(offset: number, count: number): string;
+    cloneNode(_deep?: boolean): CharacterData;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/comment.d.ts

@@ -0,0 +1,12 @@
+import { CharacterData } from './character-data.js';
+/**
+ * Comment node.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/Comment
+ */
+export declare class Comment extends CharacterData {
+    constructor(data?: string);
+    get nodeName(): string;
+    cloneNode(_deep?: boolean): Comment;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/document-fragment.d.ts

@@ -0,0 +1,37 @@
+import { Node } from './node.js';
+import { Element } from './element.js';
+/**
+ * DocumentFragment.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/DocumentFragment
+ */
+export declare class DocumentFragment extends Node {
+    constructor();
+    get nodeName(): string;
+    /** Element children only (excludes text/comment nodes) */
+    get children(): Element[];
+    get childElementCount(): number;
+    get firstElementChild(): Element | null;
+    get lastElementChild(): Element | null;
+    get textContent(): string;
+    set textContent(value: string);
+    /**
+     * Append nodes or strings to this fragment.
+     */
+    append(...nodes: (Node | string)[]): void;
+    /**
+     * Prepend nodes or strings to this fragment.
+     */
+    prepend(...nodes: (Node | string)[]): void;
+    /**
+     * Replace all children with the given nodes.
+     */
+    replaceChildren(...nodes: (Node | string)[]): void;
+    /**
+     * Find an element by ID in this fragment's children.
+     */
+    getElementById(id: string): Element | null;
+    private _findById;
+    cloneNode(deep?: boolean): DocumentFragment;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/document.d.ts

@@ -0,0 +1,39 @@
+import { Node } from './node.js';
+import { Element } from './element.js';
+import { HTMLElement } from './html-element.js';
+import { Text } from './text.js';
+import { Comment } from './comment.js';
+import { DocumentFragment } from './document-fragment.js';
+import { Event } from '@gjsify/dom-events';
+type ElementFactory = () => HTMLElement;
+export declare class Document extends Node {
+    /** External packages register element factories here (e.g. @gjsify/iframe registers 'iframe') */
+    private static _elementFactories;
+    /** Stub body element */
+    readonly body: HTMLElement;
+    /** Stub head element */
+    readonly head: HTMLElement;
+    /** Stub documentElement */
+    readonly documentElement: HTMLElement;
+    /**
+     * Register a factory for a custom element tag name.
+     * Called as a side-effect by DOM packages to avoid circular dependencies.
+     *
+     * Example: `Document.registerElementFactory('iframe', () => new HTMLIFrameElement())`
+     */
+    static registerElementFactory(tagName: string, factory: ElementFactory): void;
+    createElementNS(_namespace: string | null, tagName: string): HTMLElement;
+    createElement(tagName: string): HTMLElement;
+    createTextNode(data: string): Text;
+    createComment(data: string): Comment;
+    createDocumentFragment(): DocumentFragment;
+    createEvent(type: string): Event;
+    /**
+     * Find an element by ID. Searches body's descendants.
+     */
+    getElementById(id: string): Element | null;
+    private _findById;
+    get [Symbol.toStringTag](): string;
+}
+export declare const document: Document;
+export {};

package/lib/types/dom-token-list.d.ts

@@ -0,0 +1,30 @@
+import type { Element } from './element.js';
+/**
+ * DOMTokenList — manages a set of space-separated tokens on an attribute.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList
+ */
+export declare class DOMTokenList {
+    private _ownerElement;
+    private _attributeName;
+    constructor(ownerElement: Element, attributeName: string);
+    private _getTokens;
+    private _setTokens;
+    get length(): number;
+    get value(): string;
+    set value(val: string);
+    item(index: number): string | null;
+    contains(token: string): boolean;
+    add(...tokens: string[]): void;
+    remove(...tokens: string[]): void;
+    toggle(token: string, force?: boolean): boolean;
+    replace(token: string, newToken: string): boolean;
+    supports(_token: string): boolean;
+    forEach(callback: (value: string, index: number, list: DOMTokenList) => void): void;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<string>;
+    entries(): IterableIterator<[number, string]>;
+    [Symbol.iterator](): IterableIterator<string>;
+    toString(): string;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/element.d.ts

@@ -0,0 +1,58 @@
+import { Event } from '@gjsify/dom-events';
+import { Node } from './node.js';
+import { NamedNodeMap } from './named-node-map.js';
+import * as PS from './property-symbol.js';
+/**
+ * DOM Element class.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/Element
+ */
+export declare class Element extends Node {
+    [PS.tagName]: string;
+    [PS.localName]: string;
+    [PS.namespaceURI]: string | null;
+    [PS.prefix]: string | null;
+    [PS.attributes]: NamedNodeMap;
+    [PS.propertyEventListeners]: Map<string, ((event: Event) => void) | null>;
+    constructor();
+    get tagName(): string;
+    get localName(): string;
+    get namespaceURI(): string | null;
+    get prefix(): string | null;
+    get nodeName(): string;
+    get attributes(): NamedNodeMap;
+    get id(): string;
+    set id(value: string);
+    get className(): string;
+    set className(value: string);
+    get children(): Element[];
+    get childElementCount(): number;
+    get firstElementChild(): Element | null;
+    get lastElementChild(): Element | null;
+    get previousElementSibling(): Element | null;
+    get nextElementSibling(): Element | null;
+    get textContent(): string;
+    set textContent(_value: string | null);
+    getAttribute(qualifiedName: string): string | null;
+    getAttributeNS(namespace: string | null, localName: string): string | null;
+    setAttribute(qualifiedName: string, value: string): void;
+    setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
+    removeAttribute(qualifiedName: string): void;
+    removeAttributeNS(namespace: string | null, localName: string): void;
+    hasAttribute(qualifiedName: string): boolean;
+    hasAttributeNS(namespace: string | null, localName: string): boolean;
+    getAttributeNode(qualifiedName: string): unknown;
+    setAttributeNode(attr: unknown): unknown;
+    removeAttributeNode(attr: unknown): unknown;
+    toggleAttribute(qualifiedName: string, force?: boolean): boolean;
+    hasAttributes(): boolean;
+    dispatchEvent(event: Event): boolean;
+    querySelector(_selectors: string): Element | null;
+    querySelectorAll(_selectors: string): Element[];
+    matches(_selectors: string): boolean;
+    closest(_selectors: string): Element | null;
+    getElementsByTagName(tagName: string): Element[];
+    getElementsByClassName(className: string): Element[];
+    cloneNode(deep?: boolean): Element;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/html-canvas-element.d.ts

@@ -0,0 +1,40 @@
+import { HTMLElement } from './html-element.js';
+/**
+ * HTMLCanvasElement base class.
+ *
+ * This is a DOM-spec-compliant stub. The GTK-backed implementation lives in
+ * `@gjsify/webgl` and extends this class, overriding `getContext()`.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement
+ */
+export declare class HTMLCanvasElement extends HTMLElement {
+    private static _contextFactories;
+    /**
+     * Register a rendering context factory for a given context type.
+     * Called by packages like @gjsify/canvas2d and @gjsify/webgl to plug in their implementations.
+     */
+    static registerContextFactory(contextId: string, factory: (canvas: HTMLCanvasElement, options?: any) => any): void;
+    oncontextlost: ((ev: Event) => any) | null;
+    oncontextrestored: ((ev: Event) => any) | null;
+    onwebglcontextcreationerror: ((ev: Event) => any) | null;
+    onwebglcontextlost: ((ev: Event) => any) | null;
+    onwebglcontextrestored: ((ev: Event) => any) | null;
+    /** Returns the width of the canvas element. Default: 300. */
+    get width(): number;
+    set width(value: number);
+    /** Returns the height of the canvas element. Default: 150. */
+    get height(): number;
+    set height(value: number);
+    /**
+     * Returns a rendering context.
+     * Checks the static context factory registry for a matching factory.
+     * Subclasses (e.g. @gjsify/webgl) may override and fall through via super.getContext().
+     */
+    getContext(contextId: string, options?: any): any;
+    /** Returns a data URL representing the canvas image. Stub — returns empty string. */
+    toDataURL(_type?: string, _quality?: any): string;
+    /** Converts the canvas to a Blob and passes it to the callback. Stub — returns empty Blob. */
+    toBlob(callback: ((blob: Blob | null) => void), _type?: string, _quality?: any): void;
+    /** Returns a MediaStream capturing the canvas. Stub — returns empty object. */
+    captureStream(_frameRequestRate?: number): any;
+}

package/lib/types/html-element.d.ts

@@ -0,0 +1,119 @@
+import { Event } from '@gjsify/dom-events';
+import { Element } from './element.js';
+/**
+ * Minimal CSSStyleDeclaration stub — stores property strings but has no effect.
+ * GTK manages layout; CSS values written here (e.g. by three.js WebGLRenderer.setSize)
+ * are silently accepted and ignored.
+ */
+export declare class CSSStyleDeclaration {
+    [key: string]: unknown;
+    cssText: string;
+}
+/**
+ * HTML Element base class.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement
+ */
+export declare class HTMLElement extends Element {
+    readonly style: CSSStyleDeclaration;
+    get title(): string;
+    set title(value: string);
+    get lang(): string;
+    set lang(value: string);
+    get dir(): string;
+    set dir(value: string);
+    get accessKey(): string;
+    set accessKey(value: string);
+    get accessKeyLabel(): string;
+    get hidden(): boolean;
+    set hidden(value: boolean);
+    get draggable(): boolean;
+    set draggable(value: boolean);
+    get spellcheck(): boolean;
+    set spellcheck(value: boolean);
+    get translate(): boolean;
+    set translate(value: boolean);
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    get contentEditable(): string;
+    set contentEditable(value: string);
+    get isContentEditable(): boolean;
+    get offsetHeight(): number;
+    get offsetWidth(): number;
+    get offsetLeft(): number;
+    get offsetTop(): number;
+    get offsetParent(): Element | null;
+    get clientHeight(): number;
+    get clientWidth(): number;
+    get clientLeft(): number;
+    get clientTop(): number;
+    get scrollHeight(): number;
+    get scrollWidth(): number;
+    get scrollTop(): number;
+    set scrollTop(_value: number);
+    get scrollLeft(): number;
+    set scrollLeft(_value: number);
+    click(): void;
+    blur(): void;
+    focus(): void;
+    get onclick(): ((event: Event) => void) | null;
+    set onclick(value: ((event: Event) => void) | null);
+    get ondblclick(): ((event: Event) => void) | null;
+    set ondblclick(value: ((event: Event) => void) | null);
+    get onload(): ((event: Event) => void) | null;
+    set onload(value: ((event: Event) => void) | null);
+    get onerror(): ((event: Event) => void) | null;
+    set onerror(value: ((event: Event) => void) | null);
+    get onabort(): ((event: Event) => void) | null;
+    set onabort(value: ((event: Event) => void) | null);
+    get onfocus(): ((event: Event) => void) | null;
+    set onfocus(value: ((event: Event) => void) | null);
+    get onblur(): ((event: Event) => void) | null;
+    set onblur(value: ((event: Event) => void) | null);
+    get onchange(): ((event: Event) => void) | null;
+    set onchange(value: ((event: Event) => void) | null);
+    get oninput(): ((event: Event) => void) | null;
+    set oninput(value: ((event: Event) => void) | null);
+    get onsubmit(): ((event: Event) => void) | null;
+    set onsubmit(value: ((event: Event) => void) | null);
+    get onreset(): ((event: Event) => void) | null;
+    set onreset(value: ((event: Event) => void) | null);
+    get onscroll(): ((event: Event) => void) | null;
+    set onscroll(value: ((event: Event) => void) | null);
+    get onresize(): ((event: Event) => void) | null;
+    set onresize(value: ((event: Event) => void) | null);
+    get onmousedown(): ((event: Event) => void) | null;
+    set onmousedown(value: ((event: Event) => void) | null);
+    get onmouseup(): ((event: Event) => void) | null;
+    set onmouseup(value: ((event: Event) => void) | null);
+    get onmousemove(): ((event: Event) => void) | null;
+    set onmousemove(value: ((event: Event) => void) | null);
+    get onmouseover(): ((event: Event) => void) | null;
+    set onmouseover(value: ((event: Event) => void) | null);
+    get onmouseout(): ((event: Event) => void) | null;
+    set onmouseout(value: ((event: Event) => void) | null);
+    get onmouseenter(): ((event: Event) => void) | null;
+    set onmouseenter(value: ((event: Event) => void) | null);
+    get onmouseleave(): ((event: Event) => void) | null;
+    set onmouseleave(value: ((event: Event) => void) | null);
+    get oncontextmenu(): ((event: Event) => void) | null;
+    set oncontextmenu(value: ((event: Event) => void) | null);
+    get onkeydown(): ((event: Event) => void) | null;
+    set onkeydown(value: ((event: Event) => void) | null);
+    get onkeyup(): ((event: Event) => void) | null;
+    set onkeyup(value: ((event: Event) => void) | null);
+    get ontouchstart(): ((event: Event) => void) | null;
+    set ontouchstart(value: ((event: Event) => void) | null);
+    get ontouchend(): ((event: Event) => void) | null;
+    set ontouchend(value: ((event: Event) => void) | null);
+    get ontouchmove(): ((event: Event) => void) | null;
+    set ontouchmove(value: ((event: Event) => void) | null);
+    get onpointerdown(): ((event: Event) => void) | null;
+    set onpointerdown(value: ((event: Event) => void) | null);
+    get onpointerup(): ((event: Event) => void) | null;
+    set onpointerup(value: ((event: Event) => void) | null);
+    get onpointermove(): ((event: Event) => void) | null;
+    set onpointermove(value: ((event: Event) => void) | null);
+    cloneNode(deep?: boolean): HTMLElement;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/html-image-element.d.ts

@@ -0,0 +1,65 @@
+import GdkPixbuf from '@girs/gdkpixbuf-2.0';
+import { HTMLElement } from './html-element.js';
+import type { ImageData } from './types/index.js';
+/**
+ * HTML Image Element.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement
+ */
+export declare class HTMLImageElement extends HTMLElement {
+    private _complete;
+    private _naturalHeight;
+    private _naturalWidth;
+    protected _pixbuf?: GdkPixbuf.Pixbuf;
+    constructor();
+    get complete(): boolean;
+    get naturalHeight(): number;
+    get naturalWidth(): number;
+    get currentSrc(): string;
+    get x(): number;
+    get y(): number;
+    get alt(): string;
+    set alt(value: string);
+    get crossOrigin(): string | null;
+    set crossOrigin(value: string | null);
+    get decoding(): string;
+    set decoding(value: string);
+    get loading(): string;
+    set loading(value: string);
+    get referrerPolicy(): string;
+    set referrerPolicy(value: string);
+    get sizes(): string;
+    set sizes(value: string);
+    get src(): string;
+    set src(src: string);
+    get srcset(): string;
+    set srcset(value: string);
+    get useMap(): string;
+    set useMap(value: string);
+    get height(): number;
+    set height(value: number);
+    get width(): number;
+    set width(value: number);
+    get isMap(): boolean;
+    set isMap(value: boolean);
+    /**
+     * Decode the image. Returns a promise that resolves when the image is decoded.
+     */
+    decode(): Promise<void>;
+    /**
+     * Clone this node.
+     */
+    cloneNode(deep?: boolean): HTMLImageElement;
+    /**
+     * Get the pixels of the loaded GdkPixbuf as ImageData.
+     * Always returns RGBA (4 channels) — matches standard browser ImageData behaviour
+     * and what WebGL expects for texSubImage2D with format=RGBA.
+     * JPEG and other non-alpha formats are promoted to RGBA via add_alpha().
+     */
+    getImageData(): ImageData | null;
+    /**
+     * Check if this image is backed by a GdkPixbuf.
+     */
+    isPixbuf(): boolean;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/image.d.ts

@@ -0,0 +1,17 @@
+import { HTMLImageElement } from './html-image-element.js';
+/**
+ * Image as constructor.
+ *
+ * Reference:
+ * https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/Image.
+ */
+export default class Image extends HTMLImageElement {
+    /**
+     * Constructor.
+     *
+     * @param [width] Width.
+     * @param [height] Height.
+     */
+    constructor(width?: number | null, height?: number | null);
+}
+export { HTMLImageElement, Image };

package/lib/types/index.d.ts

@@ -0,0 +1,21 @@
+export { Attr } from './attr.js';
+export { NamedNodeMap } from './named-node-map.js';
+export { NodeList } from './node-list.js';
+export { Node } from './node.js';
+export { CharacterData } from './character-data.js';
+export { Text } from './text.js';
+export { Comment } from './comment.js';
+export { DocumentFragment } from './document-fragment.js';
+export { DOMTokenList } from './dom-token-list.js';
+export { Element } from './element.js';
+export { HTMLElement, CSSStyleDeclaration } from './html-element.js';
+export { HTMLCanvasElement } from './html-canvas-element.js';
+export { HTMLImageElement } from './html-image-element.js';
+export { Image } from './image.js';
+export { Document, document } from './document.js';
+export { MutationObserver } from './mutation-observer.js';
+export { ResizeObserver } from './resize-observer.js';
+export { IntersectionObserver } from './intersection-observer.js';
+export { NodeType } from './node-type.js';
+export { NamespaceURI } from './namespace-uri.js';
+export * as PropertySymbol from './property-symbol.js';

package/lib/types/intersection-observer.d.ts

@@ -0,0 +1,21 @@
+import type { Element } from './element.js';
+/**
+ * IntersectionObserver stub.
+ * Many libraries check for IntersectionObserver existence; this prevents crashes.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver
+ */
+export declare class IntersectionObserver {
+    readonly root: Element | null;
+    readonly rootMargin: string;
+    readonly thresholds: readonly number[];
+    constructor(_callback: (...args: unknown[]) => void, options?: {
+        root?: Element | null;
+        rootMargin?: string;
+        threshold?: number | number[];
+    });
+    observe(_target: Element): void;
+    unobserve(_target: Element): void;
+    disconnect(): void;
+    takeRecords(): unknown[];
+}

package/lib/types/mutation-observer.d.ts

@@ -0,0 +1,24 @@
+import type { Node } from './node.js';
+interface MutationObserverOptions {
+    childList?: boolean;
+    attributes?: boolean;
+    characterData?: boolean;
+    subtree?: boolean;
+    attributeOldValue?: boolean;
+    characterDataOldValue?: boolean;
+    attributeFilter?: string[];
+}
+/**
+ * MutationObserver stub.
+ * Many libraries check for MutationObserver existence; this prevents crashes.
+ * Does not actually observe DOM mutations (no layout engine).
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+ */
+export declare class MutationObserver {
+    constructor(_callback: (...args: unknown[]) => void);
+    observe(_target: Node, _options?: MutationObserverOptions): void;
+    disconnect(): void;
+    takeRecords(): unknown[];
+}
+export {};

package/lib/types/named-node-map.d.ts

@@ -0,0 +1,31 @@
+import { Attr } from './attr.js';
+import type { Element } from './element.js';
+/**
+ * Simplified NamedNodeMap for attribute storage.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap
+ */
+export declare class NamedNodeMap {
+    private _items;
+    private _ownerElement;
+    constructor(ownerElement: Element);
+    get length(): number;
+    item(index: number): Attr | null;
+    getNamedItem(qualifiedName: string): Attr | null;
+    getNamedItemNS(namespace: string | null, localName: string): Attr | null;
+    setNamedItem(attr: Attr): Attr | null;
+    setNamedItemNS(attr: Attr): Attr | null;
+    removeNamedItem(qualifiedName: string): Attr;
+    removeNamedItemNS(namespace: string | null, localName: string): Attr;
+    [Symbol.iterator](): IterableIterator<Attr>;
+    get [Symbol.toStringTag](): string;
+    /** @internal Add or replace an attribute by name. */
+    _setNamedItem(name: string, value: string, namespaceURI?: string | null, prefix?: string | null): void;
+    /** @internal Remove an attribute by name. Returns true if removed. */
+    _removeNamedItem(name: string): boolean;
+    /** @internal Remove an attribute by namespace + localName. Returns true if removed. */
+    _removeNamedItemNS(namespace: string | null, localName: string): boolean;
+    private _findByName;
+    private _setAttr;
+    private _removeAttr;
+}

package/lib/types/namespace-uri.d.ts

@@ -0,0 +1,7 @@
+export declare const NamespaceURI: {
+    readonly html: "http://www.w3.org/1999/xhtml";
+    readonly svg: "http://www.w3.org/2000/svg";
+    readonly mathML: "http://www.w3.org/1998/Math/MathML";
+    readonly xml: "http://www.w3.org/XML/1998/namespace";
+    readonly xmlns: "http://www.w3.org/2000/xmlns/";
+};

package/lib/types/node-list.d.ts

@@ -0,0 +1,18 @@
+import type { Node } from './node.js';
+/**
+ * Minimal NodeList backed by an external array.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/NodeList
+ */
+export declare class NodeList {
+    private _items;
+    constructor(items: Node[]);
+    get length(): number;
+    item(index: number): Node | null;
+    forEach(callback: (node: Node, index: number, list: NodeList) => void, thisArg?: unknown): void;
+    entries(): IterableIterator<[number, Node]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<Node>;
+    [Symbol.iterator](): IterableIterator<Node>;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/node-type.d.ts

@@ -0,0 +1,11 @@
+export declare const NodeType: {
+    readonly ELEMENT_NODE: 1;
+    readonly ATTRIBUTE_NODE: 2;
+    readonly TEXT_NODE: 3;
+    readonly CDATA_SECTION_NODE: 4;
+    readonly PROCESSING_INSTRUCTION_NODE: 7;
+    readonly COMMENT_NODE: 8;
+    readonly DOCUMENT_NODE: 9;
+    readonly DOCUMENT_TYPE_NODE: 10;
+    readonly DOCUMENT_FRAGMENT_NODE: 11;
+};

package/lib/types/node.d.ts

@@ -0,0 +1,63 @@
+import { EventTarget } from '@gjsify/dom-events';
+import { NodeList } from './node-list.js';
+import * as PS from './property-symbol.js';
+/**
+ * DOM Node base class.
+ *
+ * Reference: https://developer.mozilla.org/en-US/docs/Web/API/Node
+ */
+export declare class Node extends EventTarget {
+    static readonly ELEMENT_NODE: 1;
+    static readonly ATTRIBUTE_NODE: 2;
+    static readonly TEXT_NODE: 3;
+    static readonly CDATA_SECTION_NODE: 4;
+    static readonly PROCESSING_INSTRUCTION_NODE: 7;
+    static readonly COMMENT_NODE: 8;
+    static readonly DOCUMENT_NODE: 9;
+    static readonly DOCUMENT_TYPE_NODE: 10;
+    static readonly DOCUMENT_FRAGMENT_NODE: 11;
+    readonly ELEMENT_NODE: 1;
+    readonly ATTRIBUTE_NODE: 2;
+    readonly TEXT_NODE: 3;
+    readonly CDATA_SECTION_NODE: 4;
+    readonly PROCESSING_INSTRUCTION_NODE: 7;
+    readonly COMMENT_NODE: 8;
+    readonly DOCUMENT_NODE: 9;
+    readonly DOCUMENT_TYPE_NODE: 10;
+    readonly DOCUMENT_FRAGMENT_NODE: 11;
+    static readonly DOCUMENT_POSITION_DISCONNECTED = 1;
+    static readonly DOCUMENT_POSITION_PRECEDING = 2;
+    static readonly DOCUMENT_POSITION_FOLLOWING = 4;
+    static readonly DOCUMENT_POSITION_CONTAINS = 8;
+    static readonly DOCUMENT_POSITION_CONTAINED_BY = 16;
+    static readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32;
+    [PS.nodeType]: number;
+    [PS.parentNode]: Node | null;
+    [PS.childNodesList]: Node[];
+    [PS.elementChildren]: Node[];
+    [PS.isConnected]: boolean;
+    get nodeType(): number;
+    get nodeName(): string;
+    get parentNode(): Node | null;
+    get parentElement(): Node | null;
+    get childNodes(): NodeList;
+    get firstChild(): Node | null;
+    get lastChild(): Node | null;
+    get previousSibling(): Node | null;
+    get nextSibling(): Node | null;
+    get textContent(): string | null;
+    set textContent(_value: string | null);
+    get nodeValue(): string | null;
+    set nodeValue(_value: string | null);
+    get ownerDocument(): null;
+    get isConnected(): boolean;
+    hasChildNodes(): boolean;
+    contains(other: Node | null): boolean;
+    getRootNode(): Node;
+    appendChild(node: Node): Node;
+    removeChild(node: Node): Node;
+    insertBefore(newNode: Node, referenceNode: Node | null): Node;
+    replaceChild(newChild: Node, oldChild: Node): Node;
+    cloneNode(deep?: boolean): Node;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/property-symbol.d.ts

@@ -0,0 +1,14 @@
+export declare const nodeType: unique symbol;
+export declare const parentNode: unique symbol;
+export declare const childNodesList: unique symbol;
+export declare const elementChildren: unique symbol;
+export declare const isConnected: unique symbol;
+export declare const tagName: unique symbol;
+export declare const localName: unique symbol;
+export declare const namespaceURI: unique symbol;
+export declare const prefix: unique symbol;
+export declare const attributes: unique symbol;
+export declare const propertyEventListeners: unique symbol;
+export declare const name: unique symbol;
+export declare const value: unique symbol;
+export declare const ownerElement: unique symbol;