defuddle-cli 0.1.1 → 0.1.2

package/dist/dom.js

@@ -0,0 +1,586 @@
+import { setupRange } from './dom/interfaces/range.js';
+import { setupDocumentMethods, setupWindowMethods } from './dom/interfaces/document.js';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { JSDOM, VirtualConsole } from 'jsdom';
+import { setupDOMInterfaces } from './dom/interfaces/setup.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Define CSS interfaces globally first
+globalThis.CSSRule = class {
+    constructor(type) {
+        this.type = 1;
+        if (type !== undefined) {
+            Object.defineProperty(this, 'type', { value: type });
+        }
+        this.cssText = '';
+        this.parentRule = null;
+        this.parentStyleSheet = null;
+    }
+};
+// Static properties
+Object.defineProperties(globalThis.CSSRule, {
+    STYLE_RULE: { value: 1, writable: false },
+    CHARSET_RULE: { value: 2, writable: false },
+    IMPORT_RULE: { value: 3, writable: false },
+    MEDIA_RULE: { value: 4, writable: false },
+    FONT_FACE_RULE: { value: 5, writable: false },
+    PAGE_RULE: { value: 6, writable: false },
+    KEYFRAMES_RULE: { value: 7, writable: false },
+    KEYFRAME_RULE: { value: 8, writable: false },
+    NAMESPACE_RULE: { value: 10, writable: false },
+    COUNTER_STYLE_RULE: { value: 11, writable: false },
+    SUPPORTS_RULE: { value: 12, writable: false },
+    DOCUMENT_RULE: { value: 13, writable: false },
+    FONT_FEATURE_VALUES_RULE: { value: 14, writable: false },
+    VIEWPORT_RULE: { value: 15, writable: false },
+    REGION_STYLE_RULE: { value: 16, writable: false }
+});
+globalThis.CSSMediaRule = class extends globalThis.CSSRule {
+    constructor() {
+        super();
+        this.conditionText = '';
+        this.deleteRule = () => { };
+        this.insertRule = () => 0;
+        Object.defineProperty(this, 'type', { value: 4 }); // CSSRule.MEDIA_RULE
+        this.media = {
+            length: 0,
+            mediaText: '',
+            item: () => null,
+            appendMedium: () => { },
+            deleteMedium: () => { },
+            toString: () => '',
+            [Symbol.iterator]: function* () { yield ''; return undefined; }
+        };
+        this.cssRules = {
+            length: 0,
+            item: () => null,
+            [Symbol.iterator]: function* () {
+                yield new globalThis.CSSRule();
+                return undefined;
+            }
+        };
+    }
+};
+globalThis.CSSStyleSheet = class {
+    constructor() {
+        this.type = 'text/css';
+        this.href = null;
+        this.ownerNode = null;
+        this.parentStyleSheet = null;
+        this.title = null;
+        this.disabled = false;
+        this.ownerRule = null;
+        this.addRule = () => 0;
+        this.removeRule = () => { };
+        this.replace = async () => this;
+        this.replaceSync = () => { };
+        this.media = {
+            length: 0,
+            mediaText: '',
+            item: () => null,
+            appendMedium: () => { },
+            deleteMedium: () => { },
+            toString: () => '',
+            [Symbol.iterator]: function* () { yield ''; return undefined; }
+        };
+        this.cssRules = {
+            length: 0,
+            item: () => null,
+            [Symbol.iterator]: function* () {
+                yield new globalThis.CSSRule();
+                return undefined;
+            }
+        };
+        this.rules = this.cssRules;
+    }
+    insertRule(rule, index) {
+        return 0;
+    }
+    deleteRule(index) { }
+};
+// Define SVGElement globally
+globalThis.SVGElement = class {
+    constructor() {
+        this.id = '';
+        this.className = '';
+        this.style = {
+            cssText: '',
+            length: 0,
+            parentRule: null,
+            getPropertyPriority: () => '',
+            getPropertyValue: () => '',
+            item: () => '',
+            removeProperty: () => '',
+            setProperty: () => '',
+            [Symbol.iterator]: function* () { yield ''; return undefined; }
+        };
+        this.ownerSVGElement = null;
+        this.viewportElement = null;
+        this.tagName = '';
+        this.namespaceURI = null;
+        this.prefix = null;
+        this.localName = '';
+        this.baseURI = '';
+        this.textContent = '';
+        this.innerHTML = '';
+        this.outerHTML = '';
+        this.hidden = false;
+        this.slot = '';
+        this.attributes = {
+            length: 0,
+            getNamedItem: () => null,
+            getNamedItemNS: () => null,
+            item: () => null,
+            removeNamedItem: () => null,
+            removeNamedItemNS: () => null,
+            setNamedItem: () => null,
+            setNamedItemNS: () => null,
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+        this.childNodes = {
+            length: 0,
+            item: () => null,
+            forEach: () => { },
+            entries: function* () { yield [0, null]; return undefined; },
+            keys: function* () { yield 0; return undefined; },
+            values: function* () { yield null; return undefined; },
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+        this.firstChild = null;
+        this.lastChild = null;
+        this.nextSibling = null;
+        this.previousSibling = null;
+        this.parentNode = null;
+        this.parentElement = null;
+        this.childElementCount = 0;
+        this.firstElementChild = null;
+        this.lastElementChild = null;
+        this.nextElementSibling = null;
+        this.previousElementSibling = null;
+        this.children = {
+            length: 0,
+            item: () => null,
+            namedItem: () => null,
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+        // Initialize any required properties
+    }
+    getAttribute(name) {
+        return null;
+    }
+    getAttributeNS(namespaceURI, localName) {
+        return null;
+    }
+    setAttribute(name, value) { }
+    setAttributeNS(namespaceURI, qualifiedName, value) { }
+    removeAttributeNS(namespaceURI, localName) { }
+    hasAttribute(name) {
+        return false;
+    }
+    hasAttributeNS(namespaceURI, localName) {
+        return false;
+    }
+    getBoundingClientRect() {
+        return {
+            top: 0,
+            left: 0,
+            bottom: 0,
+            right: 0,
+            width: 0,
+            height: 0,
+            x: 0,
+            y: 0,
+            toJSON: function () { return this; }
+        };
+    }
+    getClientRects() {
+        return {
+            length: 0,
+            item: function () { return null; },
+            [Symbol.iterator]: function* () { }
+        };
+    }
+    getElementsByClassName(classNames) {
+        return {
+            length: 0,
+            item: () => null,
+            namedItem: () => null,
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+    }
+    getElementsByTagName(qualifiedName) {
+        return {
+            length: 0,
+            item: () => null,
+            namedItem: () => null,
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+    }
+    getElementsByTagNameNS(namespaceURI, localName) {
+        return {
+            length: 0,
+            item: () => null,
+            namedItem: () => null,
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+    }
+    querySelector(selectors) {
+        return null;
+    }
+    querySelectorAll(selectors) {
+        return {
+            length: 0,
+            item: () => null,
+            forEach: () => { },
+            entries: function* () { yield [0, null]; return undefined; },
+            keys: function* () { yield 0; return undefined; },
+            values: function* () { yield null; return undefined; },
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+    }
+    matches(selectors) {
+        return false;
+    }
+    closest(selectors) {
+        return null;
+    }
+    contains(other) {
+        return false;
+    }
+    append(...nodes) { }
+    prepend(...nodes) { }
+    after(...nodes) { }
+    before(...nodes) { }
+    replaceWith(...nodes) { }
+    remove() { }
+    insertAdjacentElement(where, element) {
+        return null;
+    }
+    insertAdjacentText(where, data) { }
+    insertAdjacentHTML(position, text) { }
+    replaceChildren(...nodes) { }
+};
+// Define HTMLImageElement globally
+globalThis.HTMLImageElement = class {
+    constructor() {
+        this.alt = '';
+        this.src = '';
+        this.srcset = '';
+        this.sizes = '';
+        this.crossOrigin = null;
+        this.useMap = '';
+        this.isMap = false;
+        this.width = 0;
+        this.height = 0;
+        this.naturalWidth = 0;
+        this.naturalHeight = 0;
+        this.complete = false;
+        this.name = '';
+        this.lowsrc = '';
+        this.align = '';
+        this.hspace = 0;
+        this.vspace = 0;
+        this.longDesc = '';
+        this.border = '';
+        this.x = 0;
+        this.y = 0;
+        this.currentSrc = '';
+        this.decoding = 'auto';
+        this.fetchPriority = 'auto';
+        this.loading = 'eager';
+        this.referrerPolicy = '';
+        // Initialize any required properties
+    }
+    decode() {
+        return Promise.resolve();
+    }
+};
+// Create a virtual console
+const virtualConsole = new VirtualConsole();
+// Create a virtual DOM
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+    virtualConsole,
+    runScripts: 'dangerously',
+    resources: 'usable',
+    pretendToBeVisual: true,
+    beforeParse(window) {
+        setupDOMInterfaces(window);
+        setupRange(window);
+        setupDocumentMethods(window);
+        setupWindowMethods(window);
+    }
+});
+// Get the window object
+const window = dom.window;
+// Add window to global scope
+globalThis.window = window;
+// Add document to global scope
+globalThis.document = window.document;
+// Add required DOM interfaces to global scope
+globalThis.Element = window.Element;
+globalThis.Node = window.Node;
+globalThis.NodeFilter = window.NodeFilter;
+globalThis.Range = window.Range;
+globalThis.DOMParser = window.DOMParser;
+globalThis.XMLSerializer = window.XMLSerializer;
+globalThis.navigator = window.navigator;
+globalThis.HTMLElement = window.HTMLElement;
+// Define DOMSettableTokenList
+globalThis.DOMSettableTokenList = class {
+    constructor() {
+        this.length = 0;
+        this.value = '';
+    }
+    add(token) { }
+    contains(token) { return false; }
+    item(index) { return null; }
+    remove(token) { }
+    replace(oldToken, newToken) { return false; }
+    supports(token) { return false; }
+    toggle(token, force) { return false; }
+    [Symbol.iterator]() {
+        return function* () { yield ''; return undefined; }();
+    }
+};
+// Define HTML element types
+globalThis.HTMLIFrameElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.align = '';
+        this.allow = '';
+        this.allowFullscreen = false;
+        this.contentDocument = null;
+        this.contentWindow = null;
+        this.frameBorder = '';
+        this.height = '';
+        this.longDesc = '';
+        this.marginHeight = '';
+        this.marginWidth = '';
+        this.name = '';
+        this.referrerPolicy = '';
+        this.sandbox = {
+            length: 0,
+            value: '',
+            add: () => { },
+            contains: () => false,
+            item: () => null,
+            remove: () => { },
+            replace: () => false,
+            supports: () => false,
+            toggle: () => false,
+            [Symbol.iterator]: function* () { yield ''; return undefined; }
+        };
+        this.scrolling = '';
+        this.src = '';
+        this.srcdoc = '';
+        this.width = '';
+    }
+};
+globalThis.HTMLOListElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.type = '';
+        this.compact = false;
+        this.reversed = false;
+        this.start = 0;
+    }
+};
+globalThis.HTMLUListElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.type = '';
+        this.compact = false;
+    }
+};
+globalThis.HTMLTableElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.caption = null;
+        this.tHead = null;
+        this.tFoot = null;
+        this.tBodies = {
+            length: 0,
+            item: () => null,
+            namedItem: () => null,
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+        this.rows = {
+            length: 0,
+            item: () => null,
+            namedItem: () => null,
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+        this.align = '';
+        this.bgColor = '';
+        this.border = '';
+        this.cellPadding = '';
+        this.cellSpacing = '';
+        this.frame = '';
+        this.rules = '';
+        this.summary = '';
+        this.width = '';
+    }
+    createCaption() {
+        return new globalThis.HTMLTableCaptionElement();
+    }
+    deleteCaption() { }
+    createTHead() {
+        return new globalThis.HTMLTableSectionElement();
+    }
+    deleteTHead() { }
+    createTFoot() {
+        return new globalThis.HTMLTableSectionElement();
+    }
+    deleteTFoot() { }
+    createTBody() {
+        return new globalThis.HTMLTableSectionElement();
+    }
+    insertRow(index) {
+        return new globalThis.HTMLTableRowElement();
+    }
+    deleteRow(index) { }
+};
+globalThis.HTMLTableRowElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.rowIndex = 0;
+        this.sectionRowIndex = 0;
+        this.cells = {
+            length: 0,
+            item: () => null,
+            namedItem: () => null,
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+        this.align = '';
+        this.bgColor = '';
+        this.ch = '';
+        this.chOff = '';
+        this.vAlign = '';
+    }
+    insertCell(index) {
+        return new globalThis.HTMLTableCellElement();
+    }
+    deleteCell(index) { }
+};
+globalThis.HTMLTableCellElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.colSpan = 1;
+        this.rowSpan = 1;
+        this.headers = {
+            length: 0,
+            value: '',
+            add: () => { },
+            contains: () => false,
+            item: () => null,
+            remove: () => { },
+            replace: () => false,
+            supports: () => false,
+            toggle: () => false,
+            [Symbol.iterator]: function* () { yield ''; return undefined; }
+        };
+        this.cellIndex = 0;
+        this.scope = '';
+        this.abbr = '';
+        this.align = '';
+        this.axis = '';
+        this.bgColor = '';
+        this.ch = '';
+        this.chOff = '';
+        this.height = '';
+        this.noWrap = false;
+        this.vAlign = '';
+        this.width = '';
+    }
+};
+globalThis.HTMLTableSectionElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.rows = {
+            length: 0,
+            item: () => null,
+            namedItem: () => null,
+            [Symbol.iterator]: function* () { yield null; return undefined; }
+        };
+        this.align = '';
+        this.ch = '';
+        this.chOff = '';
+        this.vAlign = '';
+    }
+    insertRow(index) {
+        return new globalThis.HTMLTableRowElement();
+    }
+    deleteRow(index) { }
+};
+globalThis.HTMLTableCaptionElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.align = '';
+    }
+};
+globalThis.HTMLButtonElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.disabled = false;
+        this.form = null;
+        this.formAction = '';
+        this.formEnctype = '';
+        this.formMethod = '';
+        this.formNoValidate = false;
+        this.formTarget = '';
+        this.name = '';
+        this.type = 'submit';
+        this.value = '';
+        this.menu = null;
+    }
+};
+// Add HTMLSpanElement interface
+globalThis.HTMLSpanElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+    }
+};
+// Add HTMLDivElement interface
+globalThis.HTMLDivElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.align = '';
+    }
+};
+globalThis.HTMLAnchorElement = class extends globalThis.HTMLElement {
+    constructor() {
+        super();
+        this.href = '';
+        this.target = '';
+        this.download = '';
+        this.ping = '';
+        this.rel = '';
+        this.relList = {
+            length: 0,
+            value: '',
+            add: () => { },
+            contains: () => false,
+            item: () => null,
+            remove: () => { },
+            replace: () => false,
+            supports: () => false,
+            toggle: () => false,
+            [Symbol.iterator]: function* () { yield ''; return undefined; }
+        };
+        this.hreflang = '';
+        this.type = '';
+        this.text = '';
+        this.referrerPolicy = '';
+        this.origin = '';
+        this.protocol = '';
+        this.username = '';
+        this.password = '';
+        this.host = '';
+        this.hostname = '';
+        this.port = '';
+        this.pathname = '';
+        this.search = '';
+        this.hash = '';
+    }
+};