defuddle-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1041 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { JSDOM, VirtualConsole } from 'jsdom';
+import pkg from 'defuddle';
+const { Defuddle } = pkg;
+import chalk from 'chalk';
+import { readFile, writeFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import { createMarkdownContent } from './markdown.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;
+    }
+};
+// Add 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();
+// Function to set up DOM interfaces
+function setupDOMInterfaces(window) {
+    var _a;
+    try {
+        // First, set up basic window properties
+        try {
+            if (!window.innerWidth) {
+                Object.defineProperty(window, 'innerWidth', { value: 1024 });
+            }
+            if (!window.innerHeight) {
+                Object.defineProperty(window, 'innerHeight', { value: 768 });
+            }
+            if (!window.devicePixelRatio) {
+                Object.defineProperty(window, 'devicePixelRatio', { value: 1 });
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set basic window properties:', error);
+        }
+        // Set up CSS interfaces
+        try {
+            if (!window.CSSRule) {
+                window.CSSRule = globalThis.CSSRule;
+            }
+            if (!window.CSSMediaRule) {
+                window.CSSMediaRule = globalThis.CSSMediaRule;
+            }
+            if (!window.CSSStyleSheet) {
+                window.CSSStyleSheet = globalThis.CSSStyleSheet;
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set CSS interfaces:', error);
+        }
+        // Set up HTML and SVG interfaces
+        try {
+            if (!window.HTMLImageElement) {
+                window.HTMLImageElement = globalThis.HTMLImageElement;
+            }
+            if (!window.SVGElement) {
+                window.SVGElement = globalThis.SVGElement;
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set HTML/SVG interfaces:', error);
+        }
+        // Set up screen object
+        try {
+            if (!window.screen) {
+                Object.defineProperty(window, 'screen', {
+                    value: {
+                        width: 1024,
+                        height: 768,
+                        availWidth: 1024,
+                        availHeight: 768,
+                        colorDepth: 24,
+                        pixelDepth: 24,
+                        orientation: {
+                            type: 'landscape-primary',
+                            angle: 0
+                        }
+                    }
+                });
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set screen object:', error);
+        }
+        // Set up storage objects
+        try {
+            if (!window.localStorage) {
+                const storage = {
+                    length: 0,
+                    getItem: () => null,
+                    setItem: () => { },
+                    removeItem: () => { },
+                    clear: () => { },
+                    key: () => null
+                };
+                try {
+                    Object.defineProperty(window, 'localStorage', {
+                        value: storage,
+                        writable: false,
+                        configurable: false
+                    });
+                }
+                catch (error) {
+                    // Silently ignore storage setup failures
+                }
+            }
+            if (!window.sessionStorage) {
+                const storage = {
+                    length: 0,
+                    getItem: () => null,
+                    setItem: () => { },
+                    removeItem: () => { },
+                    clear: () => { },
+                    key: () => null
+                };
+                try {
+                    Object.defineProperty(window, 'sessionStorage', {
+                        value: storage,
+                        writable: false,
+                        configurable: false
+                    });
+                }
+                catch (error) {
+                    // Silently ignore storage setup failures
+                }
+            }
+        }
+        catch (error) {
+            // Silently ignore storage setup failures
+        }
+        // Set up animation frame methods
+        try {
+            if (!window.requestAnimationFrame) {
+                window.requestAnimationFrame = (callback) => {
+                    return setTimeout(callback, 0);
+                };
+            }
+            if (!window.cancelAnimationFrame) {
+                window.cancelAnimationFrame = (handle) => {
+                    clearTimeout(handle);
+                };
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set animation frame methods:', error);
+        }
+        // Set up DOM methods
+        try {
+            if (!window.Document.prototype.getElementsByClassName) {
+                window.Document.prototype.getElementsByClassName = function (classNames) {
+                    const elements = this.querySelectorAll('.' + classNames);
+                    const collection = new HTMLCollection();
+                    elements.forEach((el, i) => {
+                        collection[i] = el;
+                    });
+                    return collection;
+                };
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set getElementsByClassName:', error);
+        }
+        // Set up Node methods
+        try {
+            if (!window.Node.prototype.contains) {
+                window.Node.prototype.contains = function (node) {
+                    let current = node;
+                    while (current) {
+                        if (current === this)
+                            return true;
+                        current = current.parentNode;
+                    }
+                    return false;
+                };
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set Node.contains:', error);
+        }
+        // Set up Element methods
+        try {
+            if (!window.Element.prototype.getBoundingClientRect) {
+                window.Element.prototype.getBoundingClientRect = function () {
+                    return {
+                        top: 0,
+                        left: 0,
+                        bottom: 0,
+                        right: 0,
+                        width: 0,
+                        height: 0,
+                        x: 0,
+                        y: 0,
+                        toJSON: function () { return this; }
+                    };
+                };
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set getBoundingClientRect:', error);
+        }
+        // Set up Document methods
+        try {
+            if (!window.Document.prototype.getSelection) {
+                window.Document.prototype.getSelection = function () {
+                    const selection = {
+                        anchorNode: null,
+                        anchorOffset: 0,
+                        direction: 'forward',
+                        focusNode: null,
+                        focusOffset: 0,
+                        isCollapsed: true,
+                        rangeCount: 0,
+                        type: 'None',
+                        getRangeAt: function () { return new window.Range(); },
+                        removeAllRanges: function () { },
+                        addRange: function () { },
+                        collapse: function () { },
+                        collapseToEnd: function () { },
+                        collapseToStart: function () { },
+                        deleteFromDocument: function () { },
+                        empty: function () { },
+                        extend: function () { },
+                        modify: function () { },
+                        selectAllChildren: function () { },
+                        setBaseAndExtent: function () { },
+                        setPosition: function () { },
+                        toString: function () { return ''; },
+                        containsNode: function (node, allowPartialContainment = false) {
+                            return false;
+                        },
+                        removeRange: function (range) { }
+                    };
+                    return selection;
+                };
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set getSelection:', error);
+        }
+        // Set up Window methods
+        try {
+            if (!window.Window.prototype.getComputedStyle) {
+                window.Window.prototype.getComputedStyle = function (elt, pseudoElt) {
+                    const style = {
+                        accentColor: '',
+                        alignContent: '',
+                        alignItems: '',
+                        alignSelf: '',
+                        getPropertyValue: function (prop) { return ''; }
+                    };
+                    return style;
+                };
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set getComputedStyle:', error);
+        }
+        // Set up Range constructor last
+        try {
+            if (!window.Range) {
+                window.Range = (_a = class Range {
+                        constructor() {
+                            this.START_TO_START = 0;
+                            this.START_TO_END = 1;
+                            this.END_TO_END = 2;
+                            this.END_TO_START = 3;
+                            this.startContainer = document.documentElement;
+                            this.startOffset = 0;
+                            this.endContainer = document.documentElement;
+                            this.endOffset = 0;
+                            this.collapsed = true;
+                            this.commonAncestorContainer = document.documentElement;
+                        }
+                        createContextualFragment(fragment) {
+                            return document.createDocumentFragment();
+                        }
+                        detach() { }
+                        cloneContents() {
+                            return document.createDocumentFragment();
+                        }
+                        cloneRange() {
+                            return new _a();
+                        }
+                        collapse(toStart = false) { }
+                        compareBoundaryPoints(how, sourceRange) {
+                            return 0;
+                        }
+                        comparePoint(node, offset) {
+                            return 0;
+                        }
+                        deleteContents() { }
+                        extractContents() {
+                            return document.createDocumentFragment();
+                        }
+                        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* () { }
+                            };
+                        }
+                        insertNode(node) { }
+                        intersectsNode(node) {
+                            return false;
+                        }
+                        isPointInRange(node, offset) {
+                            return false;
+                        }
+                        selectNode(node) { }
+                        selectNodeContents(node) {
+                            this.startContainer = node;
+                            this.startOffset = 0;
+                            this.endContainer = node;
+                            this.endOffset = node.childNodes.length;
+                            this.collapsed = false;
+                        }
+                        setEnd(node, offset) { }
+                        setEndAfter(node) { }
+                        setEndBefore(node) { }
+                        setStart(node, offset) { }
+                        setStartAfter(node) { }
+                        setStartBefore(node) { }
+                        surroundContents(newParent) { }
+                    },
+                    _a.START_TO_START = 0,
+                    _a.START_TO_END = 1,
+                    _a.END_TO_END = 2,
+                    _a.END_TO_START = 3,
+                    _a);
+            }
+        }
+        catch (error) {
+            console.warn('Warning: Could not set Range constructor:', error);
+        }
+    }
+    catch (error) {
+        console.error('Error in setupDOMInterfaces:', error);
+        // Don't throw the error, just log it
+    }
+}
+// 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);
+    }
+});
+// 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 = '';
+    }
+};
+const program = new Command();
+program
+    .name('defuddle')
+    .description('Extract article content from web pages')
+    .version('0.1.0');
+program
+    .command('parse')
+    .description('Parse HTML content from a file or URL')
+    .argument('<source>', 'HTML file path or URL to parse')
+    .option('-o, --output <file>', 'Output file path (default: stdout)')
+    .option('-m, --markdown', 'Convert content to markdown format')
+    .option('--md', 'Alias for --markdown')
+    .option('-j, --json', 'Output as JSON with metadata and content')
+    .option('-p, --property <name>', 'Extract a specific property (e.g., title, description, domain)')
+    .option('--debug', 'Enable debug mode')
+    .action(async (source, options) => {
+    try {
+        // Handle --md alias
+        if (options.md) {
+            options.markdown = true;
+        }
+        let html;
+        try {
+            // Determine if source is a URL or file path
+            if (source.startsWith('http://') || source.startsWith('https://')) {
+                const response = await fetch(source);
+                html = await response.text();
+            }
+            else {
+                const filePath = resolve(process.cwd(), source);
+                html = await readFile(filePath, 'utf-8');
+            }
+            // Create a new JSDOM instance with the HTML content
+            const contentDom = new JSDOM(html, {
+                virtualConsole,
+                runScripts: 'dangerously',
+                resources: 'usable',
+                pretendToBeVisual: true,
+                url: source.startsWith('http') ? source : undefined,
+                beforeParse(window) {
+                    try {
+                        setupDOMInterfaces(window);
+                    }
+                    catch (error) {
+                        console.error('Error setting up DOM interfaces:', error);
+                    }
+                }
+            });
+            // Initialize document properties
+            const doc = contentDom.window.document;
+            // 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);
+            }
+            // Parse content with debug mode if enabled
+            try {
+                const defuddle = new Defuddle(doc, {
+                    debug: options.debug
+                });
+                const result = await defuddle.parse();
+                // Format output
+                let output;
+                let content;
+                let contentMarkdown;
+                // Convert content to markdown if requested
+                if (options.markdown || options.json) {
+                    contentMarkdown = createMarkdownContent(result.content, source);
+                }
+                // Format the response based on options
+                if (options.property) {
+                    // Extract specific property
+                    const property = options.property.toLowerCase();
+                    if (property in result) {
+                        output = result[property]?.toString() || '';
+                    }
+                    else {
+                        console.error(chalk.red(`Error: Property "${property}" not found in response`));
+                        process.exit(1);
+                    }
+                }
+                else if (options.json) {
+                    const jsonObj = {
+                        content: result.content,
+                        title: result.title,
+                        description: result.description,
+                        domain: result.domain,
+                        favicon: result.favicon,
+                        image: result.image,
+                        parseTime: result.parseTime,
+                        published: result.published,
+                        author: result.author,
+                        site: result.site,
+                        schemaOrgData: result.schemaOrgData,
+                        wordCount: result.wordCount
+                    };
+                    // Only include markdown content if markdown flag is set
+                    if (options.markdown) {
+                        jsonObj.contentMarkdown = contentMarkdown;
+                    }
+                    output = JSON.stringify(jsonObj, null, 2)
+                        .replace(/"([^"]+)":/g, chalk.cyan('"$1":'))
+                        .replace(/: "([^"]+)"/g, chalk.yellow(': "$1"'))
+                        .replace(/: (\d+)/g, chalk.yellow(': $1'))
+                        .replace(/: (true|false|null)/g, chalk.magenta(': $1'));
+                }
+                else {
+                    output = options.markdown ? contentMarkdown : result.content;
+                }
+                // Handle output
+                if (options.output) {
+                    const outputPath = resolve(process.cwd(), options.output);
+                    await writeFile(outputPath, output, 'utf-8');
+                    console.log(chalk.green(`Output written to ${options.output}`));
+                }
+                else {
+                    console.log(output);
+                }
+            }
+            catch (error) {
+                console.error(chalk.red('Error during parsing:'), error);
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error loading content:'), error instanceof Error ? error.message : 'Unknown error occurred');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error occurred');
+        process.exit(1);
+    }
+});
+program.parse();