npm - defuddle-cli - Versions diffs - 0.1.0 → 0.1.2 - Mend

defuddle-cli 0.1.0 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

package/README.md +1 -1
package/dist/cli.d.ts +1 -0
package/dist/cli.js +77 -0
package/dist/commands/parse.d.ts +8 -0
package/dist/commands/parse.js +66 -0
package/dist/dom/interfaces/css.d.ts +38 -0
package/dist/dom/interfaces/css.js +20 -0
package/dist/dom/interfaces/document.d.ts +3 -0
package/dist/dom/interfaces/document.js +49 -0
package/dist/dom/interfaces/global.d.ts +21 -0
package/dist/dom/interfaces/global.js +182 -0
package/dist/dom/interfaces/html.d.ts +57 -0
package/dist/dom/interfaces/html.js +3 -0
package/dist/dom/interfaces/range.d.ts +2 -0
package/dist/dom/interfaces/range.js +87 -0
package/dist/dom/interfaces/setup.d.ts +12 -0
package/dist/dom/interfaces/setup.js +182 -0
package/dist/dom/interfaces/svg.d.ts +59 -0
package/dist/dom/interfaces/svg.js +161 -0
package/dist/dom/setup.d.ts +9 -0
package/dist/dom/setup.js +660 -0
package/dist/dom.d.ts +1 -0
package/dist/dom.js +586 -0
package/dist/index.js +84 -339
package/dist/markdown.js +0 -8
package/package.json +1 -1
package/src/dom/interfaces/document.ts +53 -0
package/src/dom/interfaces/range.ts +120 -0
package/src/dom/interfaces/setup.ts +196 -0
package/src/index.ts +91 -366
package/src/markdown.ts +0 -11

package/dist/dom/setup.js ADDED Viewed

@@ -0,0 +1,660 @@
+import { JSDOM, VirtualConsole } from 'jsdom';
+import { setupDOMInterfaces } from './interfaces/setup.js';
+import { setupRange } from './interfaces/range.js';
+import { setupDocumentMethods, setupWindowMethods } from './interfaces/document.js';
+// 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 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();
+    }
+};
+// 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 = '';
+    }
+};
+/**
+ * Creates a virtual DOM instance with the given HTML content
+ */
+export function createVirtualDOM(html, url) {
+    const dom = new JSDOM(html, {
+        virtualConsole,
+        runScripts: 'dangerously',
+        resources: 'usable',
+        pretendToBeVisual: true,
+        url,
+        beforeParse(window) {
+            try {
+                setupDOMInterfaces(window);
+            }
+            catch (error) {
+                console.error('Error setting up DOM interfaces:', error);
+            }
+        }
+    });
+    return dom;
+}
+/**
+ * Sets up additional document properties
+ */
+export function setupDocumentProperties(doc) {
+    // Ensure document has required properties
+    if (!doc.documentElement) {
+        throw new Error('Document has no root element');
+    }
+    // Set up document properties
+    try {
+        doc.documentElement.style.cssText = '';
+        doc.documentElement.className = '';
+    }
+    catch (error) {
+        console.warn('Warning: Could not set document element properties:', error);
+    }
+    // Ensure body exists and is properly set up
+    if (!doc.body) {
+        const body = doc.createElement('body');
+        doc.documentElement.appendChild(body);
+    }
+    try {
+        doc.body.style.cssText = '';
+        doc.body.className = '';
+    }
+    catch (error) {
+        console.warn('Warning: Could not set body properties:', error);
+    }
+    // Set up viewport and ensure head exists
+    if (!doc.head) {
+        const head = doc.createElement('head');
+        doc.documentElement.insertBefore(head, doc.body);
+    }
+    // Add viewport meta tag
+    try {
+        const viewport = doc.createElement('meta');
+        viewport.setAttribute('name', 'viewport');
+        viewport.setAttribute('content', 'width=device-width, initial-scale=1');
+        doc.head.appendChild(viewport);
+    }
+    catch (error) {
+        console.warn('Warning: Could not add viewport meta tag:', error);
+    }
+    // Add a base style element for mobile styles
+    try {
+        const style = doc.createElement('style');
+        style.textContent = `
+			@media (max-width: 768px) {
+				body { width: 100%; }
+			}
+		`;
+        doc.head.appendChild(style);
+    }
+    catch (error) {
+        console.warn('Warning: Could not add style element:', error);
+    }
+}

package/dist/dom.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};