defuddle-cli 0.1.0 → 0.1.2

package/src/dom/interfaces/setup.ts

@@ -0,0 +1,196 @@
+import { DOMWindow } from 'jsdom';
+import { setupDocumentMethods, setupWindowMethods } from './document.js';
+
+// Type for DOM interface setup functions
+export type SetupFunction = (window: DOMWindow) => void;
+
+// Setup basic window properties
+export const setupBasicWindow: SetupFunction = (window) => {
+	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 });
+	}
+};
+
+// Setup CSS interfaces
+export const setupCSSInterfaces: SetupFunction = (window) => {
+	if (!window.CSSRule) {
+		window.CSSRule = (globalThis as any).CSSRule as any;
+	}
+	if (!window.CSSMediaRule) {
+		window.CSSMediaRule = (globalThis as any).CSSMediaRule as any;
+	}
+	if (!window.CSSStyleSheet) {
+		window.CSSStyleSheet = (globalThis as any).CSSStyleSheet as any;
+	}
+};
+
+// Setup HTML and SVG interfaces
+export const setupHTMLAndSVG: SetupFunction = (window) => {
+	if (!window.HTMLImageElement) {
+		window.HTMLImageElement = (globalThis as any).HTMLImageElement as any;
+	}
+	if (!window.SVGElement) {
+		window.SVGElement = (globalThis as any).SVGElement as any;
+	}
+	if (!window.HTMLAnchorElement) {
+		window.HTMLAnchorElement = (globalThis as any).HTMLAnchorElement as any;
+	}
+};
+
+// Setup screen object
+export const setupScreen: SetupFunction = (window) => {
+	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
+				}
+			}
+		});
+	}
+};
+
+// Setup storage objects
+export const setupStorage: SetupFunction = (window) => {
+	const createStorage = () => {
+		const storage = {
+			length: 0,
+			getItem: () => null,
+			setItem: () => {},
+			removeItem: () => {},
+			clear: () => {},
+			key: () => null
+		};
+
+		// Make the storage object non-extensible
+		Object.preventExtensions(storage);
+		return storage;
+	};
+
+	try {
+		// Create storage objects
+		const localStorage = createStorage();
+		const sessionStorage = createStorage();
+
+		// Define properties with more permissive attributes
+		Object.defineProperties(window, {
+			localStorage: {
+				value: localStorage,
+				writable: true,
+				configurable: true
+			},
+			sessionStorage: {
+				value: sessionStorage,
+				writable: true,
+				configurable: true
+			}
+		});
+	} catch (error) {
+		// Log the error but don't throw
+		console.warn('Warning: Could not set up storage objects:', error instanceof Error ? error.message : 'Unknown error');
+	}
+};
+
+// Setup animation frame methods
+export const setupAnimationFrame: SetupFunction = (window) => {
+	if (!window.requestAnimationFrame) {
+		window.requestAnimationFrame = (callback: FrameRequestCallback): number => {
+			return setTimeout(callback, 0) as unknown as number;
+		};
+	}
+	if (!window.cancelAnimationFrame) {
+		window.cancelAnimationFrame = (handle: number): void => {
+			clearTimeout(handle as unknown as number);
+		};
+	}
+};
+
+// Setup DOM methods
+export const setupDOMMethods: SetupFunction = (window) => {
+	if (!window.Document.prototype.getElementsByClassName) {
+		window.Document.prototype.getElementsByClassName = function(classNames: string): HTMLCollectionOf<Element> {
+			const elements = this.querySelectorAll('.' + classNames);
+			const collection = new HTMLCollection();
+			elements.forEach((el, i) => {
+				collection[i] = el;
+			});
+			return collection;
+		};
+	}
+};
+
+// Setup Node methods
+export const setupNodeMethods: SetupFunction = (window) => {
+	if (!window.Node.prototype.contains) {
+		window.Node.prototype.contains = function(node: Node): boolean {
+			let current: Node | null = node;
+			while (current) {
+				if (current === this) return true;
+				current = current.parentNode;
+			}
+			return false;
+		};
+	}
+};
+
+// Setup Element methods
+export const setupElementMethods: SetupFunction = (window) => {
+	if (!window.Element.prototype.getBoundingClientRect) {
+		window.Element.prototype.getBoundingClientRect = function(): DOMRect {
+			return {
+				top: 0,
+				left: 0,
+				bottom: 0,
+				right: 0,
+				width: 0,
+				height: 0,
+				x: 0,
+				y: 0,
+				toJSON: function() { return this; }
+			};
+		};
+	}
+};
+
+// Main setup function that orchestrates all the individual setups
+export const setupDOMInterfaces = (window: DOMWindow): void => {
+	const setupFunctions: [string, SetupFunction][] = [
+		['basic window', setupBasicWindow],
+		['CSS interfaces', setupCSSInterfaces],
+		['HTML and SVG interfaces', setupHTMLAndSVG],
+		['screen object', setupScreen],
+		['storage objects', setupStorage],
+		['animation frame methods', setupAnimationFrame],
+		['DOM methods', setupDOMMethods],
+		['Node methods', setupNodeMethods],
+		['Element methods', setupElementMethods],
+		['Document methods', setupDocumentMethods],
+		['Window methods', setupWindowMethods]
+	];
+
+	try {
+		for (const [name, setup] of setupFunctions) {
+			try {
+				setup(window);
+			} catch (error) {
+				console.warn(`Warning: Could not set up ${name}:`, error instanceof Error ? error.message : 'Unknown error');
+			}
+		}
+	} catch (error) {
+		console.error('Error in setupDOMInterfaces:', error instanceof Error ? error.message : 'Unknown error');
+		// Don't throw the error, just log it
+	}
+}; 

package/src/index.ts

@@ -9,6 +9,9 @@ import { readFile, writeFile } from 'fs/promises';
 import { fileURLToPath } from 'url';
 import { dirname, resolve } from 'path';
 import { createMarkdownContent } from './markdown.js';
+import { setupDOMInterfaces } from './dom/interfaces/setup.js';
+import { setupRange } from './dom/interfaces/range.js';
+import { setupDocumentMethods, setupWindowMethods } from './dom/interfaces/document.js';
 
 interface DOMSettableTokenList {
 	length: number;
@@ -52,7 +55,7 @@ const __dirname = dirname(__filename);
 	}
 };
 
-// Add static properties
+// Static properties
 Object.defineProperties((globalThis as any).CSSRule, {
 	STYLE_RULE: { value: 1, writable: false },
 	CHARSET_RULE: { value: 2, writable: false },
@@ -377,370 +380,6 @@ Object.defineProperties((globalThis as any).CSSRule, {
 // Create a virtual console
 const virtualConsole = new VirtualConsole();
 
-// Function to set up DOM interfaces
-function setupDOMInterfaces(window: DOMWindow) {
-	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 as any).CSSRule as any;
-			}
-			if (!window.CSSMediaRule) {
-				window.CSSMediaRule = (globalThis as any).CSSMediaRule as any;
-			}
-			if (!window.CSSStyleSheet) {
-				window.CSSStyleSheet = (globalThis as any).CSSStyleSheet as any;
-			}
-		} catch (error) {
-			console.warn('Warning: Could not set CSS interfaces:', error);
-		}
-
-		// Set up HTML and SVG interfaces
-		try {
-			if (!window.HTMLImageElement) {
-				window.HTMLImageElement = (globalThis as any).HTMLImageElement as any;
-			}
-			if (!window.SVGElement) {
-				window.SVGElement = (globalThis as any).SVGElement as any;
-			}
-		} 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: FrameRequestCallback): number => {
-					return setTimeout(callback, 0) as unknown as number;
-				};
-			}
-			if (!window.cancelAnimationFrame) {
-				window.cancelAnimationFrame = (handle: number): void => {
-					clearTimeout(handle as unknown as number);
-				};
-			}
-		} 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: string): HTMLCollectionOf<Element> {
-					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: Node): boolean {
-					let current: Node | null = 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(): DOMRect {
-					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(): Selection | null {
-					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: Node, allowPartialContainment: boolean = false): boolean {
-							return false;
-						},
-						removeRange: function(range: Range): void {}
-					} as unknown as Selection;
-					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: Element, pseudoElt?: string | null): CSSStyleDeclaration {
-					const style = {
-						accentColor: '',
-						alignContent: '',
-						alignItems: '',
-						alignSelf: '',
-						getPropertyValue: function(prop: string): string { return ''; }
-					} as CSSStyleDeclaration;
-					return style;
-				};
-			}
-		} catch (error) {
-			console.warn('Warning: Could not set getComputedStyle:', error);
-		}
-
-		// Set up Range constructor last
-		try {
-			if (!window.Range) {
-				window.Range = class Range {
-					static readonly START_TO_START = 0;
-					static readonly START_TO_END = 1;
-					static readonly END_TO_END = 2;
-					static readonly END_TO_START = 3;
-
-					readonly START_TO_START = 0;
-					readonly START_TO_END = 1;
-					readonly END_TO_END = 2;
-					readonly END_TO_START = 3;
-
-					startContainer: Node;
-					startOffset: number;
-					endContainer: Node;
-					endOffset: number;
-					collapsed: boolean;
-					commonAncestorContainer: Node;
-
-					constructor() {
-						this.startContainer = document.documentElement;
-						this.startOffset = 0;
-						this.endContainer = document.documentElement;
-						this.endOffset = 0;
-						this.collapsed = true;
-						this.commonAncestorContainer = document.documentElement;
-					}
-
-					createContextualFragment(fragment: string): DocumentFragment {
-						return document.createDocumentFragment();
-					}
-
-					detach(): void {}
-
-					cloneContents(): DocumentFragment {
-						return document.createDocumentFragment();
-					}
-
-					cloneRange(): Range {
-						return new Range();
-					}
-
-					collapse(toStart: boolean = false): void {}
-
-					compareBoundaryPoints(how: number, sourceRange: Range): number {
-						return 0;
-					}
-
-					comparePoint(node: Node, offset: number): number {
-						return 0;
-					}
-
-					deleteContents(): void {}
-
-					extractContents(): DocumentFragment {
-						return document.createDocumentFragment();
-					}
-
-					getBoundingClientRect(): DOMRect {
-						return {
-							top: 0,
-							left: 0,
-							bottom: 0,
-							right: 0,
-							width: 0,
-							height: 0,
-							x: 0,
-							y: 0,
-							toJSON: function() { return this; }
-						};
-					}
-
-					getClientRects(): DOMRectList {
-						return {
-							length: 0,
-							item: function() { return null; },
-							[Symbol.iterator]: function*() {}
-						} as DOMRectList;
-					}
-
-					insertNode(node: Node): void {}
-
-					intersectsNode(node: Node): boolean {
-						return false;
-					}
-
-					isPointInRange(node: Node, offset: number): boolean {
-						return false;
-					}
-
-					selectNode(node: Node): void {}
-
-					selectNodeContents(node: Node): void {
-						this.startContainer = node;
-						this.startOffset = 0;
-						this.endContainer = node;
-						this.endOffset = node.childNodes.length;
-						this.collapsed = false;
-					}
-
-					setEnd(node: Node, offset: number): void {}
-
-					setEndAfter(node: Node): void {}
-
-					setEndBefore(node: Node): void {}
-
-					setStart(node: Node, offset: number): void {}
-
-					setStartAfter(node: Node): void {}
-
-					setStartBefore(node: Node): void {}
-
-					surroundContents(newParent: Node): void {}
-				};
-			}
-		} 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,
@@ -749,6 +388,9 @@ const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
 	pretendToBeVisual: true,
 	beforeParse(window: DOMWindow) {
 		setupDOMInterfaces(window);
+		setupRange(window);
+		setupDocumentMethods(window);
+		setupWindowMethods(window);
 	}
 });
 
@@ -768,7 +410,16 @@ const window = dom.window;
 (globalThis as any).Range = window.Range;
 (globalThis as any).DOMParser = window.DOMParser;
 (globalThis as any).XMLSerializer = window.XMLSerializer;
-(globalThis as any).navigator = window.navigator;
+
+// Handle navigator property
+if (!globalThis.navigator || Object.getOwnPropertyDescriptor(globalThis, 'navigator')?.configurable) {
+	Object.defineProperty(globalThis, 'navigator', {
+		value: window.navigator,
+		writable: false,
+		configurable: true
+	});
+}
+
 (globalThis as any).HTMLElement = window.HTMLElement;
 
 // Define DOMSettableTokenList
@@ -971,6 +622,75 @@ const window = dom.window;
 	align: string = '';
 };
 
+(globalThis as any).HTMLButtonElement = class extends (globalThis as any).HTMLElement {
+	constructor() {
+		super();
+	}
+	disabled: boolean = false;
+	form: HTMLFormElement | null = null;
+	formAction: string = '';
+	formEnctype: string = '';
+	formMethod: string = '';
+	formNoValidate: boolean = false;
+	formTarget: string = '';
+	name: string = '';
+	type: string = 'submit';
+	value: string = '';
+	menu: HTMLMenuElement | null = null;
+};
+
+// Add HTMLSpanElement interface
+(globalThis as any).HTMLSpanElement = class extends (globalThis as any).HTMLElement {
+	constructor() {
+		super();
+	}
+};
+
+// Add HTMLDivElement interface
+(globalThis as any).HTMLDivElement = class extends (globalThis as any).HTMLElement {
+	constructor() {
+		super();
+	}
+	align: string = '';
+};
+
+(globalThis as any).HTMLAnchorElement = class extends (globalThis as any).HTMLElement {
+	constructor() {
+		super();
+	}
+	href: string = '';
+	target: string = '';
+	download: string = '';
+	ping: string = '';
+	rel: string = '';
+	relList: DOMSettableTokenList = {
+		length: 0,
+		value: '',
+		add: () => {},
+		contains: () => false,
+		item: () => null,
+		remove: () => {},
+		replace: () => false,
+		supports: () => false,
+		toggle: () => false,
+		[Symbol.iterator]: function*() { yield ''; return undefined; }
+	} as unknown as DOMSettableTokenList;
+	hreflang: string = '';
+	type: string = '';
+	text: string = '';
+	referrerPolicy: string = '';
+	origin: string = '';
+	protocol: string = '';
+	username: string = '';
+	password: string = '';
+	host: string = '';
+	hostname: string = '';
+	port: string = '';
+	pathname: string = '';
+	search: string = '';
+	hash: string = '';
+};
+
 const program = new Command();
 
 program
@@ -1087,6 +807,11 @@ program
 					
 					const result = await defuddle.parse();
 
+					// If in debug mode, don't show content output
+					if (options.debug) {
+						process.exit(0);
+					}
+
 					// Format output
 					let output: string;
 					let content: string;

package/src/markdown.ts

@@ -283,17 +283,6 @@ export function createMarkdownContent(content: string, url: string) {
 		}
 	});
 
-	turndownService.addRule('removeHiddenElements', {
-		filter: function (node) {
-			return (
-				node.style.display === 'none'
-			);
-		},
-		replacement: function () {
-			return '';
-		}
-	});
-
 	turndownService.addRule('citations', {
 		filter: (node: Node): boolean => {
 			if (node instanceof Element) {