amateras 0.5.0 → 0.7.0

package/packages/css/src/structure/$CSSVariable.ts

@@ -0,0 +1,30 @@
+import { _document } from "@amateras/core/env";
+
+const documentElementStyle = _document.documentElement.style;
+
+export class $CSSVariable<V = string> {
+    name: string;
+    value: V;
+    constructor(key: string, value: V) {
+        this.name = key;
+        this.value = value;
+    }
+
+    set(value: string) {
+        documentElementStyle.setProperty(`${this.name}`, value);
+        return this;
+    }
+
+    reset() {
+        documentElementStyle.removeProperty(`${this.name}`);
+        return this;
+    }
+
+    default(value: string | $CSSVariable) {
+        return `var(${this.name}, ${value})`
+    }
+
+    toString() {
+        return `var(${this.name})`
+    }
+}

package/packages/dom/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@amateras/dom",
+    "peerDependencies": {
+      "@amateras/core": "workspace:*",
+      "@amateras/utils": "workspace:*"
+    },
+    "dependencies": {
+      "node-html-parser": "^7.0.1"
+    },
+    "imports": {
+      "#structure/*": "./src/structure/*.ts",
+      "#lib/*": "./src/lib/*.ts",
+      "#node/*": "./src/node/*.ts"
+    },
+    "exports": {
+      "./structure/*": "./src/structure/*.ts",
+      "./lib/*": "./src/lib/*.ts",
+      "./node/*": "./src/node/*.ts"
+    }
+}

package/packages/dom/src/lib/HTMLElementMap.ts

@@ -0,0 +1,213 @@
+import { HTMLAbbrElement } from "#structure/html/HTMLAbbrElement";
+import { HTMLAddressElement } from "#structure/html/HTMLAddressElement";
+import { HTMLAnchorElement } from "#structure/html/HTMLAnchorElement";
+import { HTMLAreaElement } from "#structure/html/HTMLAreaElement";
+import { HTMLArticleElement } from "#structure/html/HTMLArticleElement";
+import { HTMLAsideElement } from "#structure/html/HTMLAsideElement";
+import { HTMLAudioElement } from "#structure/html/HTMLAudioElement";
+import { HTMLBDIElement } from "#structure/html/HTMLBDIElement";
+import { HTMLBDOElement } from "#structure/html/HTMLBDOElement";
+import { HTMLBElement } from "#structure/html/HTMLBElement";
+import { HTMLBRElement } from "#structure/html/HTMLBRElement";
+import { HTMLBaseElement } from "#structure/html/HTMLBaseElement";
+import { HTMLBodyElement } from "#structure/html/HTMLBodyElement";
+import { HTMLButtonElement } from "#structure/html/HTMLButtonElement";
+import { HTMLCanvasElement } from "#structure/html/HTMLCanvasElement";
+import { HTMLCiteElement } from "#structure/html/HTMLCiteElement";
+import { HTMLCodeElement } from "#structure/html/HTMLCodeElement";
+import { HTMLDDElement } from "#structure/html/HTMLDDElement";
+import { HTMLDFNElement } from "#structure/html/HTMLDFNElement";
+import { HTMLDListElement } from "#structure/html/HTMLDListElement";
+import { HTMLDTElement } from "#structure/html/HTMLDTElement";
+import { HTMLDataElement } from "#structure/html/HTMLDataElement";
+import { HTMLDataListElement } from "#structure/html/HTMLDataListElement";
+import { HTMLDetailsElement } from "#structure/html/HTMLDetailsElement";
+import { HTMLDialogElement } from "#structure/html/HTMLDialogElement";
+import { HTMLDivElement } from "#structure/html/HTMLDivElement";
+import { HTMLEMElement } from "#structure/html/HTMLEMElement";
+import { HTMLEmbedElement } from "#structure/html/HTMLEmbedElement";
+import { HTMLFieldSetElement } from "#structure/html/HTMLFieldSetElement";
+import { HTMLFigCaptionElement } from "#structure/html/HTMLFigCaptionElement";
+import { HTMLFigureElement } from "#structure/html/HTMLFigureElement";
+import { HTMLFooterElement } from "#structure/html/HTMLFooterElement";
+import { HTMLFormElement } from "#structure/html/HTMLFormElement";
+import { HTMLHGroupElement } from "#structure/html/HTMLHGroupElement";
+import { HTMLHRElement } from "#structure/html/HTMLHRElement";
+import { HTMLHeadElement } from "#structure/html/HTMLHeadElement";
+import { HTMLHeaderElement } from "#structure/html/HTMLHeaderElement";
+import { HTMLHeadingElement } from "#structure/html/HTMLHeadingElement";
+import { HTMLHtmlElement } from "#structure/html/HTMLHtmlElement";
+import { HTMLIElement } from "#structure/html/HTMLIElement";
+import { HTMLIFrameElement } from "#structure/html/HTMLIFrameElement";
+import { HTMLImageElement } from "#structure/html/HTMLImageElement";
+import { HTMLInputElement } from "#structure/html/HTMLInputElement";
+import { HTMLKBDElement } from "#structure/html/HTMLKBDElement";
+import { HTMLLIElement } from "#structure/html/HTMLLIElement";
+import { HTMLLabelElement } from "#structure/html/HTMLLabelElement";
+import { HTMLLegendElement } from "#structure/html/HTMLLegendElement";
+import { HTMLLinkElement } from "#structure/html/HTMLLinkElement";
+import { HTMLMainElement } from "#structure/html/HTMLMainElement";
+import { HTMLMapElement } from "#structure/html/HTMLMapElement";
+import { HTMLMarkElement } from "#structure/html/HTMLMarkElement";
+import { HTMLMenuElement } from "#structure/html/HTMLMenuElement";
+import { HTMLMetaElement } from "#structure/html/HTMLMetaElement";
+import { HTMLMeterElement } from "#structure/html/HTMLMeterElement";
+import { HTMLModElement } from "#structure/html/HTMLModElement";
+import { HTMLNavElement } from "#structure/html/HTMLNavElement";
+import { HTMLNoscriptElement } from "#structure/html/HTMLNoscriptElement";
+import { HTMLOListElement } from "#structure/html/HTMLOListElement";
+import { HTMLObjectElement } from "#structure/html/HTMLObjectElement";
+import { HTMLOptionElement } from "#structure/html/HTMLOptionElement";
+import { HTMLOptGroupElement } from "#structure/html/HTMLOptGroupElement";
+import { HTMLOutputElement } from "#structure/html/HTMLOutputElement";
+import { HTMLParagraphElement } from "#structure/html/HTMLParagraphElement";
+import { HTMLPictureElement } from "#structure/html/HTMLPictureElement";
+import { HTMLPreElement } from "#structure/html/HTMLPreElement";
+import { HTMLProgressElement } from "#structure/html/HTMLProgressElement";
+import { HTMLQuoteElement } from "#structure/html/HTMLQuoteElement";
+import { HTMLRPElement } from "#structure/html/HTMLRPElement";
+import { HTMLRTElement } from "#structure/html/HTMLRTElement";
+import { HTMLRubyElement } from "#structure/html/HTMLRubyElement";
+import { HTMLSElement } from "#structure/html/HTMLSElement";
+import { HTMLSampElement } from "#structure/html/HTMLSampElement";
+import { HTMLScriptElement } from "#structure/html/HTMLScriptElement";
+import { HTMLSectionElement } from "#structure/html/HTMLSectionElement";
+import { HTMLSelectElement } from "#structure/html/HTMLSelectElement";
+import { HTMLSmallElement } from "#structure/html/HTMLSmallElement";
+import { HTMLSlotElement } from "#structure/html/HTMLSlotElement";
+import { HTMLSourceElement } from "#structure/html/HTMLSourceElement";
+import { HTMLSpanElement } from "#structure/html/HTMLSpanElement";
+import { HTMLStrongElement } from "#structure/html/HTMLStrongElement";
+import { HTMLStyleElement } from "#structure/html/HTMLStyleElement";
+import { HTMLSubElement } from "#structure/html/HTMLSubElement";
+import { HTMLSupElement } from "#structure/html/HTMLSupElement";
+import { HTMLSummaryElement } from "#structure/html/HTMLSummaryElement";
+import { HTMLTableCaptionElement } from "#structure/html/HTMLTableCaptionElement";
+import { HTMLTableCellElement } from "#structure/html/HTMLTableCellElement";
+import { HTMLTableColElement } from "#structure/html/HTMLTableColElement";
+import { HTMLTableElement } from "#structure/html/HTMLTableElement";
+import { HTMLTableRowElement } from "#structure/html/HTMLTableRowElement";
+import { HTMLTableSectionElement } from "#structure/html/HTMLTableSectionElement";
+import { HTMLTemplateElement } from "#structure/html/HTMLTemplateElement";
+import { HTMLTextAreaElement } from "#structure/html/HTMLTextAreaElement";
+import { HTMLTimeElement } from "#structure/html/HTMLTimeElement";
+import { HTMLTitleElement } from "#structure/html/HTMLTitleElement";
+import { HTMLTrackElement } from "#structure/html/HTMLTrackElement";
+import { HTMLUElement } from "#structure/html/HTMLUElement";
+import { HTMLUListElement } from "#structure/html/HTMLUListElement";
+import { HTMLVarElement } from "#structure/html/HTMLVarElement";
+import { HTMLVideoElement } from "#structure/html/HTMLVideoElement";
+import { HTMLWBRElement } from "#structure/html/HTMLWBRElement";
+
+export const htmlElementMap = new Map()
+.set('a', HTMLAnchorElement)
+.set('abbr', HTMLAbbrElement)
+.set('address', HTMLAddressElement)
+.set('area', HTMLAreaElement)
+.set('article', HTMLArticleElement)
+.set('aside', HTMLAsideElement)
+.set('audio', HTMLAudioElement)
+.set('b', HTMLBElement)
+.set('bdi', HTMLBDIElement)
+.set('bdo', HTMLBDOElement)
+.set('blockquote', HTMLQuoteElement)
+.set('br', HTMLBRElement)
+.set('base', HTMLBaseElement)
+.set('body', HTMLBodyElement)
+.set('button', HTMLButtonElement)
+.set('canvas', HTMLCanvasElement)
+.set('caption', HTMLTableCaptionElement)
+.set('cite', HTMLCiteElement)
+.set('code', HTMLCodeElement)
+.set('col', HTMLTableColElement)
+.set('colgroup', HTMLTableColElement)
+.set('data', HTMLDataElement)
+.set('datalist', HTMLDataListElement)
+.set('dd', HTMLDDElement)
+.set('del', HTMLModElement)
+.set('details', HTMLDetailsElement)
+.set('dfn', HTMLDFNElement)
+.set('dialog', HTMLDialogElement)
+.set('div', HTMLDivElement)
+.set('dl', HTMLDListElement)
+.set('dt', HTMLDTElement)
+.set('em', HTMLEMElement)
+.set('embed', HTMLEmbedElement)
+.set('fieldset', HTMLFieldSetElement)
+.set('figcaption', HTMLFigCaptionElement)
+.set('figure', HTMLFigureElement)
+.set('footer', HTMLFooterElement)
+.set('form', HTMLFormElement)
+.set('h1', HTMLHeadingElement)
+.set('h2', HTMLHeadingElement)
+.set('h3', HTMLHeadingElement)
+.set('h4', HTMLHeadingElement)
+.set('h5', HTMLHeadingElement)
+.set('h6', HTMLHeadingElement)
+.set('head', HTMLHeadElement)
+.set('header', HTMLHeaderElement)
+.set('hgroup', HTMLHGroupElement)
+.set('hr', HTMLHRElement)
+.set('html', HTMLHtmlElement)
+.set('i', HTMLIElement)
+.set('iframe', HTMLIFrameElement)
+.set('img', HTMLImageElement)
+.set('input', HTMLInputElement)
+.set('ins', HTMLModElement)
+.set('kbd', HTMLKBDElement)
+.set('label', HTMLLabelElement)
+.set('legend', HTMLLegendElement)
+.set('li', HTMLLIElement)
+.set('link', HTMLLinkElement)
+.set('main', HTMLMainElement)
+.set('map', HTMLMapElement)
+.set('mark', HTMLMarkElement)
+.set('menu', HTMLMenuElement)
+.set('meta', HTMLMetaElement)
+.set('meter', HTMLMeterElement)
+.set('nav', HTMLNavElement)
+.set('noscript', HTMLNoscriptElement)
+.set('object', HTMLObjectElement)
+.set('ol', HTMLOListElement)
+.set('optgroup', HTMLOptGroupElement)
+.set('option', HTMLOptionElement)
+.set('output', HTMLOutputElement)
+.set('p', HTMLParagraphElement)
+.set('picture', HTMLPictureElement)
+.set('pre', HTMLPreElement)
+.set('progress', HTMLProgressElement)
+.set('q', HTMLQuoteElement)
+.set('rp', HTMLRPElement)
+.set('rt', HTMLRTElement)
+.set('ruby', HTMLRubyElement)
+.set('s', HTMLSElement)
+.set('samp', HTMLSampElement)
+.set('script', HTMLScriptElement)
+.set('section', HTMLSectionElement)
+.set('select', HTMLSelectElement)
+.set('small', HTMLSmallElement)
+.set('slot', HTMLSlotElement)
+.set('source', HTMLSourceElement)
+.set('span', HTMLSpanElement)
+.set('strong', HTMLStrongElement)
+.set('style', HTMLStyleElement)
+.set('sub', HTMLSubElement)
+.set('summary', HTMLSummaryElement)
+.set('sup', HTMLSupElement)
+.set('table', HTMLTableElement)
+.set('tbody', HTMLTableSectionElement)
+.set('td', HTMLTableCellElement)
+.set('template', HTMLTemplateElement)
+.set('textarea', HTMLTextAreaElement)
+.set('tfoot', HTMLTableSectionElement)
+.set('th', HTMLTableCellElement)
+.set('thead', HTMLTableSectionElement)
+.set('time', HTMLTimeElement)
+.set('title', HTMLTitleElement)
+.set('tr', HTMLTableRowElement)
+.set('track', HTMLTrackElement)
+.set('u', HTMLUElement)
+.set('ul', HTMLUListElement)
+.set('var', HTMLVarElement)
+.set('video', HTMLVideoElement)
+.set('wbr', HTMLWBRElement)

package/packages/dom/src/lib/assignAttributes.ts

@@ -0,0 +1,16 @@
+import type { Element } from "#structure/Element"
+import { _Object_assign, _Object_defineProperty, _Object_entries, forEach } from "@amateras/utils"
+
+export const assignAttributes = (target: any, props: {[key: string]: any}) => {
+    forEach(_Object_entries(props), ([name]) => {
+        _Object_defineProperty(target.prototype, name, {
+            enumerable: true,
+            get(this: Element) {
+                return this.getAttribute(name)
+            },
+            set(this: Element, value: any) {
+                this.setAttribute(name, value);
+            }
+        })
+    })
+}

package/packages/dom/src/structure/CSS.ts

@@ -0,0 +1,7 @@
+import { _Object_assign } from "@amateras/utils"
+
+export class CSS {
+    static supports() { return true }
+}
+
+_Object_assign(globalThis, { CSS })

package/packages/dom/src/structure/CSSStyleSheet.ts

@@ -0,0 +1,10 @@
+import { _Object_assign } from "@amateras/utils";
+
+export class CSSStyleSheet {
+    cssRules: string[] = []
+    insertRule(cssText: string) {
+        this.cssRules.push(cssText);
+    }
+}
+
+_Object_assign(globalThis, { CSSStyleSheet })

package/packages/dom/src/structure/DOMTokenList.ts

@@ -0,0 +1,19 @@
+import { _Object_assign, forEach } from "@amateras/utils";
+
+export class DOMTokenList extends Set {
+    constructor(tokens?: string[]) {
+        super(tokens);
+    }
+
+    add(...tokens: string[]) {
+        forEach(tokens, token => super.add(token));
+        return this;
+    }
+
+    remove(...tokens: string[]) {
+        forEach(tokens, token => super.delete(token));
+        return this;
+    }
+}
+
+_Object_assign(globalThis, { DOMTokenList })

package/packages/dom/src/structure/Document.ts

@@ -0,0 +1,36 @@
+import { _Object_assign } from "@amateras/utils"
+import { Node } from "./Node";
+import { HTMLElement } from "./HTMLElement";
+import { htmlElementMap } from "#lib/HTMLElementMap";
+import { Text } from "./Text";
+
+export class Document extends Node {
+    adoptedStyleSheets = [];
+    documentElement = this.createElement('html');
+    head = this.createElement('head');
+    body = this.createElement('body');
+    #ele_title: null | HTMLElement = null;
+    constructor() {
+        super('#document');
+        this.appendChild(this.documentElement);
+        this.documentElement.appendChild(this.head);
+        this.documentElement.appendChild(this.body);
+    }
+
+    createElement(nodeName: string): HTMLElement {
+        const constructor = htmlElementMap.get(nodeName);
+        if (constructor) return new constructor();
+        return new HTMLElement(nodeName)
+    }
+
+    set title(title: string) {
+        if (title.length) {
+            this.#ele_title?.remove();
+            this.#ele_title = this.createElement('title');
+            this.#ele_title.appendChild(new Text(title))
+            this.head.appendChild(this.#ele_title);
+        } else this.#ele_title?.remove();
+    }
+}
+
+_Object_assign(globalThis, { Document })

package/packages/dom/src/structure/Element.ts

@@ -0,0 +1,106 @@
+import { _Array_from, _Object_assign, _Object_entries, forEach, isArray, isString, isUndefined } from "@amateras/utils";
+import { Node } from "./Node";
+import { DOMTokenList } from "./DOMTokenList";
+import { assignAttributes } from "#lib/assignAttributes";
+import { Text } from "./Text";
+import { HTMLElement as ParserHTMLElement, Node as ParserNode, TextNode, parse as htmlParse } from 'node-html-parser';
+import type { Document } from "./Document";
+
+export class Element extends Node {
+    #attributes = new Map<string, any>();
+    #classList = new DOMTokenList();
+    readonly tagname: string
+
+    static defaultAttributes = {
+        id: ''
+    }
+    
+    constructor(nodeName: string) {
+        super(nodeName.toUpperCase())
+        this.tagname = nodeName.toUpperCase();
+    }
+
+    get attributes() {
+        return _Array_from(this.#attributes).map(([name, value]) => ({name, value}))
+    }
+
+    get innerHTML() {
+        const children = _Array_from(this.childNodes).map(node => node.toString());
+        return children.join('');
+    }
+
+    set innerHTML(html: string) {
+        const element = htmlParse(html);
+        const createChildElement = (target: Node, ele: ParserNode) => {
+            forEach(element.childNodes, node => {
+                if (node instanceof TextNode) target.appendChild(new Text(node.textContent));
+                const ele = (document as unknown as Document).createElement(node.rawTagName);
+                if (node instanceof ParserHTMLElement) {
+                    forEach(Object.entries(node.attributes), ([key, value]) => ele.setAttribute(key, value))
+                }
+                target.appendChild(ele);
+                createChildElement(ele, node);
+            })
+        }
+
+        createChildElement(this, element);
+    }
+
+    get outerHTML() {
+        const nodeName = this.nodeName.toLowerCase();
+        const attr = _Array_from(this.attributes).map(({name, value}) => {
+            //@ts-expect-error
+            const defaultValue = this.constructor.defaultAttributes[name];
+            if (isArray(defaultValue)) value = defaultValue[value ? 1 : 2];
+            return `${name}${isString(value) && value ? `="${value}"` : ``}`;
+        })
+        const IS_SELF_CLOSING = ['img', 'meta', 'input'].includes(nodeName);
+        this.#classList.size && attr.unshift(`class="${_Array_from(this.classList).join(' ')}"`)
+        return `<${nodeName}${attr.length ? ` ${attr.join(' ')}` : ''}>${this.innerHTML}${IS_SELF_CLOSING ? '' : `</${nodeName}>`}`
+    }
+
+    set outerHTML(html: string) {
+
+    }
+
+    toString() {
+        return this.outerHTML;
+    }
+
+    setAttribute(key: string, value: string) {
+        this.#attributes.set(key, value);
+    }
+
+    getAttribute(key: string) {
+        const value = this.#attributes.get(key)
+        if (!isUndefined(value)) return value;
+        //@ts-expect-error
+        const defaultValue = this.constructor.defaultAttributes[key];
+        if (isArray(defaultValue)) return defaultValue[0]
+        return defaultValue;
+    }
+
+    get classList(): DOMTokenList {
+        return this.#classList
+    }
+
+    set classList(tokens: string) {
+        this.#classList = new DOMTokenList(tokens.split(' '));
+    }
+
+    set textContent(text: string) {
+        forEach(this.childNodes, node => node.remove());
+        this.appendChild(new Text(text));
+    }
+
+    get textContent() {
+        const strings = _Array_from(this.childNodes).map(node => {
+            if (node instanceof Text) return node.textContent;
+            else if (node instanceof Element) return node.textContent;
+        })
+        return strings.join('')
+    }
+}
+
+assignAttributes(Element, Element.defaultAttributes)
+_Object_assign(globalThis, { Element })

package/packages/dom/src/structure/HTMLElement.ts

@@ -0,0 +1,34 @@
+import { _Array_from, _Object_assign, _Object_entries } from "@amateras/utils";
+import { Element } from "./Element";
+import { assignAttributes } from "#lib/assignAttributes";
+
+export class HTMLElement extends Element {
+    #style: Partial<CSSStyleDeclaration> = {}
+
+    static defaultAttributes = {
+        ...Element.defaultAttributes,
+        autocapitalize: false,
+        dir: '',
+        draggable: false,
+        hidden: false,
+        inert: [false, ''],
+        lang: '',
+        popover: null,
+        spellcheck: true,
+        title: '',
+        translate: [true, 'yes', 'no'],
+        writingSuggestions: 'true',
+    }
+    
+    get attributes() {
+        const style = _Object_entries(this.#style).filter(([_, value]) => value).map(([key, value]) => `${key}:${value}`).join(';')
+        const attrs = super.attributes;
+        if (style) attrs.push({name: 'style', value: style})
+        return attrs
+    }
+
+    get style() { return this.#style }
+}
+
+assignAttributes(HTMLElement, HTMLElement.defaultAttributes)
+_Object_assign(globalThis, { HTMLElement })

package/packages/dom/src/structure/History.ts

@@ -0,0 +1,11 @@
+export class History {
+    scrollRestoration: ScrollRestoration = 'manual';
+    readonly length = 0;
+    readonly state: any;
+
+    back() {}
+    forward() {}
+    go(delta?: number) {}
+    pushState() {}
+    replaceState() {}
+}

package/packages/dom/src/structure/Location.ts

@@ -0,0 +1,9 @@
+export class Location extends URL {
+    constructor() {
+        super('http://localhost')
+    }
+
+    reload() {}
+    replace(url: string | URL) {}
+    assign(url: string | URL) {}
+}

package/packages/dom/src/structure/Node.ts

@@ -0,0 +1,51 @@
+import { _Array_from, _null, _Object_assign, isUndefined } from "@amateras/utils";
+import { NodeList } from "./NodeList";
+
+export class Node extends EventTarget {
+    readonly nodeName: string
+    constructor(nodeName: string) {
+        super();
+        this.nodeName = nodeName;
+    }
+    #childNodes = new NodeList();
+    get childNodes() { return this.#childNodes }
+
+    parentElement: null | Node = _null;
+
+    appendChild(node: Node) {
+        this.#childNodes.delete(node);
+        this.#childNodes.add(node);
+        node.parentElement = this;
+    }
+
+    insertBefore(node: Node, target: Node) {
+        this.#childNodes.delete(node);
+        const nodeList = _Array_from(this.childNodes);
+        const index = nodeList.indexOf(target);
+        if (isUndefined(target) || index === -1) this.appendChild(node);
+        else {
+            this.#childNodes = new NodeList([...nodeList.slice(0, index - 1), node, ...nodeList.slice(index)]);
+            node.parentElement = this;
+        }
+    }
+
+    remove() {
+        this.parentElement?.childNodes.delete(this);
+        this.parentElement = _null;
+    }
+
+    contains(node: Node) {
+        for (const childNode of this.#childNodes) {
+            if (node === childNode) return true;
+            else if (node.contains(node)) return true;
+        }
+        return false
+    }
+
+    toString() {}
+
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void {}
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void {}
+}
+
+_Object_assign(globalThis, { Node })

package/packages/dom/src/structure/NodeList.ts

@@ -0,0 +1,10 @@
+import { _Object_assign } from "@amateras/utils";
+import type { Node } from "./Node";
+
+export class NodeList extends Set<Node> {
+    constructor(node: Node[] = []) {
+        super(node)
+    }
+}
+
+_Object_assign(globalThis, { NodeList })

package/packages/dom/src/structure/Storage.ts

@@ -0,0 +1,8 @@
+export class Storage {
+    readonly length: number = 0;
+    clear() {}
+    getItem() {}
+    key() {}
+    removeItem() {}
+    setItem() {}
+}

package/packages/dom/src/structure/Text.ts

@@ -0,0 +1,20 @@
+import { _Object_assign } from "@amateras/utils";
+import { Node } from "./Node";
+
+export class Text extends Node {
+    #textContent: string;
+    constructor(str: string) {
+        super('#text');
+        this.#textContent = str;
+    }
+
+    get textContent() {
+        return this.#textContent;
+    }
+
+    toString() {
+        return this.#textContent;
+    }
+}
+
+_Object_assign(globalThis, { Text })

package/packages/dom/src/structure/Window.ts

@@ -0,0 +1,14 @@
+import { Document } from "./Document";
+import { History } from "./History";
+import { Location } from "./Location";
+import { Storage } from "./Storage";
+
+export class Window extends EventTarget {
+    document = new Document();
+    location = new Location();
+    history = new History();
+    sessionStorage = new Storage();
+    localStorage = new Storage();
+    
+    scrollTo = () => {}
+}

package/packages/dom/src/structure/html/HTMLAbbrElement.ts

@@ -0,0 +1,16 @@
+import { assignAttributes } from "#lib/assignAttributes";
+import { HTMLElement } from "#structure/HTMLElement";
+import { _Object_assign } from "@amateras/utils";
+
+export class HTMLAbbrElement extends HTMLElement {
+    static defaultAttributes = {
+        ...HTMLElement.defaultAttributes
+    }
+
+    constructor() {
+        super('abbr')
+    }
+}
+
+assignAttributes(HTMLAbbrElement, HTMLAbbrElement.defaultAttributes)
+_Object_assign(globalThis, { HTMLAbbrElement })

package/packages/dom/src/structure/html/HTMLAddressElement.ts

@@ -0,0 +1,16 @@
+import { assignAttributes } from "#lib/assignAttributes";
+import { HTMLElement } from "#structure/HTMLElement";
+import { _Object_assign } from "@amateras/utils";
+
+export class HTMLAddressElement extends HTMLElement {
+    static defaultAttributes = {
+        ...HTMLElement.defaultAttributes
+    }
+
+    constructor() {
+        super('address')
+    }
+}
+
+assignAttributes(HTMLAddressElement, HTMLAddressElement.defaultAttributes)
+_Object_assign(globalThis, { HTMLAddressElement })