@dooboostore/dom-parser 1.0.0

package/src/node/elements/SVGElement.ts

@@ -0,0 +1,16 @@
+import { ElementBase } from './ElementBase';
+
+/**
+ * The **`SVGElement`** class represents the base class for all SVG elements.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGElement)
+ */
+export class SVGElement extends ElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get namespaceURI(): string | null {
+        return 'http://www.w3.org/2000/svg';
+    }
+}

package/src/node/elements/SVGRectElement.ts

@@ -0,0 +1,74 @@
+import { SVGElement } from './SVGElement';
+
+/**
+ * The **`SVGRectElement`** class represents an SVG `<rect>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGRectElement)
+ */
+export class SVGRectElement extends SVGElement {
+    private _x: number = 0;
+    private _y: number = 0;
+    private _width: number = 0;
+    private _height: number = 0;
+
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get x(): number {
+        return this._x;
+    }
+
+    set x(value: number) {
+        this._x = value;
+        this.setAttribute('x', value.toString());
+    }
+
+    get y(): number {
+        return this._y;
+    }
+
+    set y(value: number) {
+        this._y = value;
+        this.setAttribute('y', value.toString());
+    }
+
+    get width(): number {
+        return this._width;
+    }
+
+    set width(value: number) {
+        this._width = value;
+        this.setAttribute('width', value.toString());
+    }
+
+    get height(): number {
+        return this._height;
+    }
+
+    set height(value: number) {
+        this._height = value;
+        this.setAttribute('height', value.toString());
+    }
+
+    // Override setAttribute to sync with properties
+    setAttribute(qualifiedName: string, value: string): void {
+        super.setAttribute(qualifiedName, value);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'x':
+                this._x = parseFloat(value) || 0;
+                break;
+            case 'y':
+                this._y = parseFloat(value) || 0;
+                break;
+            case 'width':
+                this._width = parseFloat(value) || 0;
+                break;
+            case 'height':
+                this._height = parseFloat(value) || 0;
+                break;
+        }
+    }
+}

package/src/node/elements/index.ts

@@ -0,0 +1,186 @@
+// Base Element interfaces and types
+export { Element, DOMTokenList } from './Element';
+export { HTMLCollection, HTMLCollectionOf } from '../collection';
+
+// Base Element implementations
+export { ElementBase } from './ElementBase';
+export { HTMLElementBase } from './HTMLElementBase';
+export { HTMLGenericElement } from './HTMLGenericElement';
+
+// Import all element classes
+import { HTMLAnchorElement } from './HTMLAnchorElement';
+import { HTMLBodyElement } from './HTMLBodyElement';
+import { HTMLDivElement } from './HTMLDivElement';
+import { HTMLSpanElement } from './HTMLSpanElement';
+import { HTMLPElement } from './HTMLPElement';
+import { HTMLImgElement } from './HTMLImgElement';
+import { HTMLButtonElement } from './HTMLButtonElement';
+import { HTMLCanvasElement } from './HTMLCanvasElement';
+import { HTMLInputElement } from './HTMLInputElement';
+import { HTMLH1Element } from './HTMLH1Element';
+import { HTMLHeadElement } from './HTMLHeadElement';
+import { HTMLHtmlElement } from './HTMLHtmlElement';
+import { HTMLTitleElement } from './HTMLTitleElement';
+import { HTMLLinkElement } from './HTMLLinkElement';
+import { HTMLScriptElement } from './HTMLScriptElement';
+import { HTMLStyleElement } from './HTMLStyleElement';
+import { HTMLFormElement } from './HTMLFormElement';
+import { HTMLTableElement } from './HTMLTableElement';
+import { HTMLUListElement } from './HTMLUListElement';
+import { HTMLOListElement } from './HTMLOListElement';
+import { HTMLLIElement } from './HTMLLIElement';
+import { SVGElement } from './SVGElement';
+import { SVGCircleElement } from './SVGCircleElement';
+import { SVGRectElement } from './SVGRectElement';
+import { HTMLMetaElement } from './HTMLMetaElement';
+import { HTMLTemplateElement } from './HTMLTemplateElement';
+import { HTMLTheadElement } from './HTMLTheadElement';
+import { HTMLTfootElement } from './HTMLTfootElement';
+import { HTMLTrElement } from './HTMLTrElement';
+import { HTMLTdElement } from './HTMLTdElement';
+import { HTMLThElement } from './HTMLThElement';
+import { HTMLCaptionElement } from './HTMLCaptionElement';
+import { HTMLTbodyElement } from './HTMLTbodyElement';
+import { HTMLEmbedElement } from './HTMLEmbedElement';
+import { HTMLAreaElement } from './HTMLAreaElement';
+import { HTMLBaseElement } from './HTMLBaseElement';
+import { MathMLElement } from './MathMLElement';
+
+// Export all element classes
+export {
+    HTMLAnchorElement,
+    HTMLBodyElement,
+    HTMLDivElement,
+    HTMLHeadElement,
+    HTMLHtmlElement,
+    HTMLSpanElement,
+    HTMLPElement,
+    HTMLImgElement,
+    HTMLButtonElement,
+    HTMLCanvasElement,
+    HTMLInputElement,
+    HTMLH1Element,
+    HTMLTitleElement,
+    HTMLLinkElement,
+    HTMLScriptElement,
+    HTMLStyleElement,
+    HTMLFormElement,
+    HTMLTableElement,
+    HTMLUListElement,
+    HTMLOListElement,
+    HTMLLIElement,
+    SVGElement,
+    SVGCircleElement,
+    SVGRectElement,
+    HTMLMetaElement,
+    HTMLTemplateElement,
+    HTMLTheadElement,
+    HTMLTfootElement,
+    HTMLTrElement,
+    HTMLTdElement,
+    HTMLThElement,
+    HTMLCaptionElement,
+    HTMLTbodyElement,
+    HTMLEmbedElement,
+    HTMLAreaElement,
+    HTMLBaseElement,
+    MathMLElement,
+};
+
+// HTML Elements mapping with explicit string keys for proper type inference
+export const htmlElements = {
+    'a': HTMLAnchorElement,
+    'body': HTMLBodyElement,
+    'button': HTMLButtonElement,
+    'canvas': HTMLCanvasElement,
+    'div': HTMLDivElement,
+    'h1': HTMLH1Element,
+    'head': HTMLHeadElement,
+    'html': HTMLHtmlElement,
+    'img': HTMLImgElement,
+    'input': HTMLInputElement,
+    'p': HTMLPElement,
+    'meta': HTMLMetaElement,
+    'span': HTMLSpanElement,
+    'title': HTMLTitleElement,
+    'link': HTMLLinkElement,
+    'script': HTMLScriptElement,
+    'style': HTMLStyleElement,
+    'form': HTMLFormElement,
+    'table': HTMLTableElement,
+    'ul': HTMLUListElement,
+    'ol': HTMLOListElement,
+    'li': HTMLLIElement,
+    'template': HTMLTemplateElement,
+    'thead': HTMLTheadElement,
+    'tfoot': HTMLTfootElement,
+    'tr': HTMLTrElement,
+    'td': HTMLTdElement,
+    'th': HTMLThElement,
+    'caption': HTMLCaptionElement,
+    'tbody': HTMLTbodyElement,
+    'embed': HTMLEmbedElement,
+    'area': HTMLAreaElement,
+    'base': HTMLBaseElement,
+} as const;
+
+// SVG Elements mapping with explicit string keys
+export const svgElements = {
+    'svg': SVGElement,
+    'circle': SVGCircleElement,
+    'rect': SVGRectElement,
+} as const;
+
+// MathML Elements mapping - all use MathMLElement
+export const mathmlElements = {
+    'annotation': MathMLElement,
+    'annotation-xml': MathMLElement,
+    'maction': MathMLElement,
+    'math': MathMLElement,
+    'merror': MathMLElement,
+    'mfrac': MathMLElement,
+    'mi': MathMLElement,
+    'mmultiscripts': MathMLElement,
+    'mn': MathMLElement,
+    'mo': MathMLElement,
+    'mover': MathMLElement,
+    'mpadded': MathMLElement,
+    'mphantom': MathMLElement,
+    'mprescripts': MathMLElement,
+    'mroot': MathMLElement,
+    'mrow': MathMLElement,
+    'ms': MathMLElement,
+    'mspace': MathMLElement,
+    'msqrt': MathMLElement,
+    'mstyle': MathMLElement,
+    'msub': MathMLElement,
+    'msubsup': MathMLElement,
+    'msup': MathMLElement,
+    'mtable': MathMLElement,
+    'mtd': MathMLElement,
+    'mtext': MathMLElement,
+    'mtr': MathMLElement,
+    'munder': MathMLElement,
+    'munderover': MathMLElement,
+    'semantics': MathMLElement,
+} as const;
+
+// Type-safe tag name mappings - back to the working approach
+export type HTMLElementTagNameMap = {
+    [K in keyof typeof htmlElements]: InstanceType<typeof htmlElements[K]>;
+};
+
+export type SVGElementTagNameMap = {
+    [K in keyof typeof svgElements]: InstanceType<typeof svgElements[K]>;
+};
+
+export type MathMLElementTagNameMap = {
+    [K in keyof typeof mathmlElements]: InstanceType<typeof mathmlElements[K]>;
+};
+
+export interface HTMLElementDeprecatedTagNameMap {
+    // deprecated 태그들
+}
+
+// Type aliases for Document interface compatibility
+export type HTMLImageElement = HTMLImgElement;

package/src/node/index.ts

@@ -0,0 +1,28 @@
+// Core Node interfaces
+export { Node, ELEMENT_NODE, ATTRIBUTE_NODE, TEXT_NODE, CDATA_SECTION_NODE, ENTITY_REFERENCE_NODE, ENTITY_NODE, PROCESSING_INSTRUCTION_NODE, COMMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, DOCUMENT_FRAGMENT_NODE, NOTATION_NODE, DOCUMENT_POSITION_DISCONNECTED, DOCUMENT_POSITION_PRECEDING, DOCUMENT_POSITION_FOLLOWING, DOCUMENT_POSITION_CONTAINS, DOCUMENT_POSITION_CONTAINED_BY, DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC } from './Node';
+export { ChildNode } from './ChildNode';
+export { ParentNode } from './ParentNode';
+
+// Base implementations
+export { NodeBase } from './NodeBase';
+export { ChildNodeBase } from './ChildNodeBase';
+export { ParentNodeBase } from './ParentNodeBase';
+export { ElementBase } from './elements/ElementBase';
+export { Text } from './Text';
+
+// Document class (concrete implementation)
+export { Document, ElementCreationOptions, DocumentReadyState, DocumentFragment } from './Document';
+
+// Character data interfaces
+export { CharacterData } from './CharacterData';
+export { Comment } from './Comment';
+
+// Collections
+export { NodeList } from './collection/NodeList';
+export { NodeListOf } from './collection/NodeListOf';
+
+// Element interfaces (from element directory)
+export * from './elements';
+
+// Options and interfaces
+export { GetRootNodeOptions } from './GetRootNodeOptions';

package/src/utils/CSSSelector.ts

@@ -0,0 +1,360 @@
+import { Element } from '../node/elements/Element';
+
+/**
+ * CSS Selector Parser and Matcher
+ * Supports various CSS selector types including complex selectors
+ */
+export class CSSSelector {
+    /**
+     * Main method to check if an element matches a CSS selector
+     */
+    static matches(element: Element, selector: string): boolean {
+        selector = selector.trim();
+
+        // Handle compound selectors (e.g., "meta[charset]", "div.class", "input#id")
+        const components = this.parseSelector(selector);
+
+        // All components must match for the selector to match
+        for (const component of components) {
+            if (!this.matchesSingleSelector(element, component)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Parse a selector into individual components
+     * e.g., "div.user-panel[data-id='123']" -> ["div", ".user-panel", "[data-id='123']"]
+     */
+    private static parseSelector(selector: string): string[] {
+        const components: string[] = [];
+        let current = '';
+        let inBrackets = false;
+        let inQuotes = false;
+        let quoteChar = '';
+
+        for (let i = 0; i < selector.length; i++) {
+            const char = selector[i];
+            const prevChar = i > 0 ? selector[i - 1] : '';
+
+            if (inQuotes) {
+                current += char;
+                if (char === quoteChar && prevChar !== '\\') {
+                    inQuotes = false;
+                    quoteChar = '';
+                }
+                continue;
+            }
+
+            if (char === '"' || char === "'") {
+                inQuotes = true;
+                quoteChar = char;
+                current += char;
+                continue;
+            }
+
+            if (char === '[') {
+                inBrackets = true;
+                if (current) {
+                    components.push(current);
+                    current = '';
+                }
+                current += char;
+            } else if (char === ']') {
+                inBrackets = false;
+                current += char;
+                components.push(current);
+                current = '';
+            } else if (!inBrackets && (char === '.' || char === '#')) {
+                if (current) {
+                    components.push(current);
+                    current = '';
+                }
+                current += char;
+            } else if (!inBrackets && char === ':' && prevChar !== '\\') {
+                // Only treat colon as pseudo-class separator if it's not escaped
+                if (current) {
+                    components.push(current);
+                    current = '';
+                }
+                current += char;
+            } else {
+                current += char;
+            }
+        }
+
+        if (current) {
+            components.push(current);
+        }
+
+        return components;
+    }
+
+    /**
+     * Match a single selector component against an element
+     */
+    private static matchesSingleSelector(element: Element, selector: string): boolean {
+        selector = selector.trim();
+
+        // Tag selector (e.g., "div", "dr-wow", "wow\\:zz")
+        // Handle escaped colons in tag names
+        const unescapedSelector = selector.replace(/\\:/g, ':');
+        if (unescapedSelector.match(/^[a-zA-Z][a-zA-Z0-9:-]*$/)) {
+            return element.tagName.toLowerCase() === unescapedSelector.toLowerCase();
+        }
+
+        // ID selector (e.g., "#myId")
+        if (selector.startsWith('#')) {
+            const id = selector.substring(1);
+            return element.id === id;
+        }
+
+        // Class selector (e.g., ".myClass")
+        if (selector.startsWith('.')) {
+            const className = selector.substring(1);
+            return element.className.split(/\s+/).includes(className);
+        }
+
+        // Pseudo-class selectors
+        if (selector.startsWith(':')) {
+            return this.matchesPseudoClass(element, selector);
+        }
+
+        // Attribute selector (e.g., "[type='text']", "[disabled]", "[value*='test']")
+        if (selector.startsWith('[') && selector.endsWith(']')) {
+            return this.matchesAttributeSelector(element, selector);
+        }
+
+        // Universal selector
+        if (selector === '*') {
+            return true;
+        }
+
+        // Unsupported selector
+        return false;
+    }
+
+    /**
+     * Match attribute selectors with various operators
+     */
+    private static matchesAttributeSelector(element: Element, selector: string): boolean {
+        const attrContent = selector.slice(1, -1); // Remove [ and ]
+
+        // Parse attribute selector: attr, attr=value, attr*=value, etc.
+        const match = attrContent.match(/^([^=!*^$~|]+)(?:([=!*^$~|]+)(['"]?)([^'"]*)(['"]?))?$/);
+
+        if (!match) return false;
+
+        let attrName = match[1].trim();
+        const operator = match[2] || '';
+        const attrValue = match[4] || '';
+
+        // Handle escaped colons in attribute names
+        attrName = attrName.replace(/\\:/g, ':');
+
+        if (!operator) {
+            // Just check if attribute exists: [disabled]
+            return element.hasAttribute(attrName);
+        }
+
+        const elementValue = element.getAttribute(attrName);
+        if (elementValue === null) return false;
+
+        switch (operator) {
+            case '=':
+                // Exact match: [type="text"]
+                return elementValue === attrValue;
+
+            case '!=':
+                // Not equal: [value!="test"]
+                return elementValue !== attrValue;
+
+            case '*=':
+                // Contains: [value*="test"]
+                return elementValue.includes(attrValue);
+
+            case '^=':
+                // Starts with: [value^="test"]
+                return elementValue.startsWith(attrValue);
+
+            case '$=':
+                // Ends with: [value$="test"]
+                return elementValue.endsWith(attrValue);
+
+            case '~=':
+                // Word match: [class~="test"]
+                return elementValue.split(/\s+/).includes(attrValue);
+
+            case '|=':
+                // Language match: [lang|="en"]
+                return elementValue === attrValue || elementValue.startsWith(attrValue + '-');
+
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Match pseudo-class selectors
+     */
+    private static matchesPseudoClass(element: Element, selector: string): boolean {
+        const pseudoClass = selector.substring(1); // Remove :
+
+        // Parse pseudo-class with parameters: nth-child(2), contains('text')
+        const match = pseudoClass.match(/^([^(]+)(?:\(([^)]*)\))?$/);
+        if (!match) return false;
+
+        const pseudoName = match[1];
+        const pseudoParam = match[2];
+
+        switch (pseudoName) {
+            case 'checked':
+                // :checked - for input elements
+                return this.isInputElement(element) &&
+                    (element.getAttribute('checked') !== null ||
+                        element.getAttribute('selected') !== null);
+
+            case 'disabled':
+                // :disabled
+                return element.hasAttribute('disabled');
+
+            case 'enabled':
+                // :enabled
+                return !element.hasAttribute('disabled');
+
+            case 'focus':
+                // :focus - check if element has focus (autofocus attribute or programmatically focused)
+                return element.hasAttribute('autofocus') ||
+                    element.getAttribute('data-focused') === 'true';
+
+            case 'first':
+            case 'first-child':
+                // :first or :first-child
+                return this.isFirstChild(element);
+
+            case 'last':
+            case 'last-child':
+                // :last or :last-child
+                return this.isLastChild(element);
+
+            case 'even':
+                // :even (0-based indexing)
+                return this.getChildIndex(element) % 2 === 0;
+
+            case 'odd':
+                // :odd (0-based indexing)
+                return this.getChildIndex(element) % 2 === 1;
+
+            case 'nth-child':
+                // :nth-child(n)
+                if (pseudoParam) {
+                    const n = parseInt(pseudoParam, 10);
+                    return this.getChildIndex(element) === n - 1; // Convert to 0-based
+                }
+                return false;
+
+            case 'eq':
+                // :eq(n) - jQuery-style
+                if (pseudoParam) {
+                    const n = parseInt(pseudoParam, 10);
+                    return this.getChildIndex(element) === n;
+                }
+                return false;
+
+            case 'gt':
+                // :gt(n) - jQuery-style
+                if (pseudoParam) {
+                    const n = parseInt(pseudoParam, 10);
+                    return this.getChildIndex(element) > n;
+                }
+                return false;
+
+            case 'lt':
+                // :lt(n) - jQuery-style
+                if (pseudoParam) {
+                    const n = parseInt(pseudoParam, 10);
+                    return this.getChildIndex(element) < n;
+                }
+                return false;
+
+            case 'contains':
+                // :contains('text')
+                if (pseudoParam) {
+                    const text = pseudoParam.replace(/^['"]|['"]$/g, ''); // Remove quotes
+                    return (element.textContent || '').includes(text);
+                }
+                return false;
+
+            case 'visible':
+                // :visible - simplified check
+                return !element.hasAttribute('hidden') &&
+                    element.getAttribute('style')?.includes('display:none') !== true;
+
+            case 'hidden':
+                // :hidden
+                return element.hasAttribute('hidden') ||
+                    element.getAttribute('style')?.includes('display:none') === true;
+
+            case 'has':
+                // :has(selector) - simplified implementation
+                if (pseudoParam && 'querySelector' in element) {
+                    try {
+                        return (element as any).querySelector(pseudoParam) !== null;
+                    } catch {
+                        return false;
+                    }
+                }
+                return false;
+
+            case 'not':
+                // :not(selector) - simplified implementation
+                if (pseudoParam) {
+                    return !CSSSelector.matches(element, pseudoParam);
+                }
+                return false;
+
+            default:
+                // Unsupported pseudo-class
+                return false;
+        }
+    }
+
+    /**
+     * Helper methods for pseudo-class matching
+     */
+    private static isInputElement(element: Element): boolean {
+        const tagName = element.tagName.toLowerCase();
+        return tagName === 'input' || tagName === 'select' || tagName === 'textarea';
+    }
+
+    private static isFirstChild(element: Element): boolean {
+        const parent = element.parentNode;
+        if (!parent || !('children' in parent)) return false;
+
+        const children = (parent as any).children;
+        return children.length > 0 && children[0] === element;
+    }
+
+    private static isLastChild(element: Element): boolean {
+        const parent = element.parentNode;
+        if (!parent || !('children' in parent)) return false;
+
+        const children = (parent as any).children;
+        return children.length > 0 && children[children.length - 1] === element;
+    }
+
+    private static getChildIndex(element: Element): number {
+        const parent = element.parentNode;
+        if (!parent || !('children' in parent)) return -1;
+
+        const children = (parent as any).children;
+        for (let i = 0; i < children.length; i++) {
+            if (children[i] === element) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}