@dooboostore/dom-parser 1.0.1 → 1.0.3

package/src/factory/ElementFactory.ts

@@ -4,66 +4,92 @@ import { HTMLElementBase, HTMLGenericElement, htmlElements, svgElements, mathmlE
  * Factory for creating HTML elements based on tag names
  */
 export class ElementFactory {
-    /**
-     * Creates an HTML element based on the tag name
-     */
-    static createElement(tagName: string, ownerDocument?: any): HTMLElementBase {
-        const normalizedTagName = tagName.toLowerCase();
-        
-        // Check HTML elements
-        for (const [tag, ElementClass] of Object.entries(htmlElements)) {
-            if (tag === normalizedTagName) {
-                return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
-            }
-        }
-        
-        // Check SVG elements
-        for (const [tag, ElementClass] of Object.entries(svgElements)) {
-            if (tag === normalizedTagName) {
-                return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
-            }
-        }
-        
-        // Check MathML elements
-        for (const [tag, ElementClass] of Object.entries(mathmlElements)) {
-            if (tag === normalizedTagName) {
-                return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
-            }
+  /**
+   * Creates an HTML element based on the tag name
+   */
+  static createElement(tagName: string, ownerDocument?: any, options?: any): HTMLElementBase {
+    const normalizedTagName = tagName.toLowerCase();
+    const customElements = (ownerDocument as any)?.defaultView?.customElements;
+
+    // 1. Check for Customized Built-in Elements (is="")
+    const isAttribute = typeof options === 'string' ? options : options?.is;
+    if (isAttribute && customElements && typeof customElements.get === 'function') {
+      const CustomElementClass = customElements.get(isAttribute);
+      if (CustomElementClass) {
+        const element = new CustomElementClass() as any;
+        element._tagName = tagName.toUpperCase();
+        element.nodeName = tagName.toUpperCase();
+        element._ownerDocument = ownerDocument;
+        if (element.setAttribute) {
+          element.setAttribute('is', isAttribute);
         }
-        
-        // For unknown elements, create a generic HTMLElement
-        return new HTMLGenericElement(tagName.toUpperCase(), ownerDocument);
+        return element;
+      }
     }
 
-    /**
-     * Get all supported HTML tag names
-     */
-    static getSupportedHTMLTagNames(): string[] {
-        return Object.keys(htmlElements);
+    // 2. Check for Autonomous Custom Elements
+    if (normalizedTagName.includes('-') && customElements && typeof customElements.get === 'function') {
+      const CustomElementClass = customElements.get(normalizedTagName);
+      if (CustomElementClass) {
+        const element = new CustomElementClass() as any;
+        element._tagName = tagName.toUpperCase();
+        element.nodeName = tagName.toUpperCase();
+        element._ownerDocument = ownerDocument;
+        return element;
+      }
     }
 
-    /**
-     * Get all supported SVG tag names
-     */
-    static getSupportedSVGTagNames(): string[] {
-        return Object.keys(svgElements);
+    // 3. Check HTML elements
+
+    for (const [tag, ElementClass] of Object.entries(htmlElements)) {
+      if (tag === normalizedTagName) {
+        return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
+      }
     }
 
-    /**
-     * Get all supported MathML tag names
-     */
-    static getSupportedMathMLTagNames(): string[] {
-        return Object.keys(mathmlElements);
+    // Check SVG elements
+    for (const [tag, ElementClass] of Object.entries(svgElements)) {
+      if (tag === normalizedTagName) {
+        return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
+      }
     }
 
-    /**
-     * Get all supported tag names
-     */
-    static getSupportedTagNames(): string[] {
-        return [
-            ...ElementFactory.getSupportedHTMLTagNames(),
-            ...ElementFactory.getSupportedSVGTagNames(),
-            ...ElementFactory.getSupportedMathMLTagNames()
-        ];
+    // Check MathML elements
+    for (const [tag, ElementClass] of Object.entries(mathmlElements)) {
+      if (tag === normalizedTagName) {
+        return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
+      }
     }
-}
+
+    // For unknown elements, create a generic HTMLElement
+    return new HTMLGenericElement(tagName.toUpperCase(), ownerDocument);
+  }
+
+  /**
+   * Get all supported HTML tag names
+   */
+  static getSupportedHTMLTagNames(): string[] {
+    return Object.keys(htmlElements);
+  }
+
+  /**
+   * Get all supported SVG tag names
+   */
+  static getSupportedSVGTagNames(): string[] {
+    return Object.keys(svgElements);
+  }
+
+  /**
+   * Get all supported MathML tag names
+   */
+  static getSupportedMathMLTagNames(): string[] {
+    return Object.keys(mathmlElements);
+  }
+
+  /**
+   * Get all supported tag names
+   */
+  static getSupportedTagNames(): string[] {
+    return [...ElementFactory.getSupportedHTMLTagNames(), ...ElementFactory.getSupportedSVGTagNames(), ...ElementFactory.getSupportedMathMLTagNames()];
+  }
+}

package/src/index.ts

@@ -1,19 +1,20 @@
-import { DomParser, DomParserOptions } from "./DomParser";
+import {DomParser, DomParserOptions} from './DomParser';
 
 // Main exports - what users actually need
-export { DomParser };
-
+export {DomParser};
+export {NodeIterator} from './node/NodeIterator';
+export {NodeFilter} from './node/NodeFilter'
 // Utility function to parse HTML and return window object
 export const parseHTML = (html: string, option?: DomParserOptions) => {
-    const parser = new DomParser(html, option);
-    return parser.window;
-}
+  const parser = new DomParser(html, option);
+  return parser.window;
+};
 
 // Default export
 export default {
-    DomParser,
-    parseHTML
-}
+  DomParser,
+  parseHTML
+};
 
 // Internal exports (commented out - users don't need these)
 // export { WindowBase } from './window/WindowBase';
@@ -25,4 +26,4 @@ export default {
 // export { DocumentBase } from "./node/DocumentBase";
 // export * from "./node/DocumentFragment";
 // export { DocumentFragmentBase } from "./node/DocumentFragmentBase";
-// export * from "./node/Node";
+// export * from "./node/Node";

package/src/node/CharacterData.ts

@@ -1,5 +1,3 @@
-import { Node } from './Node';
-import { ChildNode } from './ChildNode';
 
 /**
  * The **`CharacterData`** abstract interface represents a Node object that contains characters.

package/src/node/ChildNode.ts

@@ -1,42 +1,42 @@
-import { Node } from './Node';
-
-/**
- * The **`ChildNode`** interface contains methods and properties that are common to all types of Node objects that can have a parent.
- * 
- * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ChildNode)
- */
-export interface ChildNode extends Node {
-    /**
-     * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.
-     *
-     * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/after)
-     */
-    after(...nodes: (Node | string)[]): void;
-
-    /**
-     * Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.
-     *
-     * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/before)
-     */
-    before(...nodes: (Node | string)[]): void;
-
-    /**
-     * Removes node.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/remove)
-     */
-    remove(): void;
-
-    /**
-     * Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.
-     *
-     * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
-     *
-     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/replaceWith)
-     */
-    replaceWith(...nodes: (Node | string)[]): void;
-}
+// import {Node} from './Node';
+//
+// /**
+//  * The **`ChildNode`** interface contains methods and properties that are common to all types of Node objects that can have a parent.
+//  *
+//  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ChildNode)
+//  */
+// export interface ChildNode extends Node {
+//   /**
+//    * Inserts nodes just after node, while replacing strings in nodes with equivalent Text nodes.
+//    *
+//    * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
+//    *
+//    * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/after)
+//    */
+//   after(...nodes: (Node | string)[]): void;
+//
+//   /**
+//    * Inserts nodes just before node, while replacing strings in nodes with equivalent Text nodes.
+//    *
+//    * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
+//    *
+//    * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/before)
+//    */
+//   before(...nodes: (Node | string)[]): void;
+//
+//   /**
+//    * Removes node.
+//    *
+//    * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/remove)
+//    */
+//   remove(): void;
+//
+//   /**
+//    * Replaces node with nodes, while replacing strings in nodes with equivalent Text nodes.
+//    *
+//    * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
+//    *
+//    * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/replaceWith)
+//    */
+//   replaceWith(...nodes: (Node | string)[]): void;
+// }

package/src/node/ChildNodeBase.ts

@@ -1,54 +1,75 @@
+import { ELEMENT_NODE } from './Node';
 import { NodeBase } from './NodeBase';
-import { ChildNode } from './ChildNode';
-// import {Text} from "./Text";
 
 /**
  * Base implementation of the ChildNode interface
  */
+// @ts-ignore
 export abstract class ChildNodeBase extends NodeBase implements ChildNode {
-    
-    // ChildNode interface implementation
-    after(...nodes: (NodeBase | string)[]): void {
-        if (!this.parentNode) return;
-        
-        const nextSibling = this.nextSibling;
-        for (const node of nodes) {
-            if (typeof node === 'string') {
-                const { TextBase } = require('./TextBase');
-                const textNode = new TextBase(node, this._ownerDocument);
-                this.parentNode.insertBefore(textNode, nextSibling);
-            } else {
-                this.parentNode.insertBefore(node, nextSibling);
-            }
-        }
+  get nextElementSibling(): Element | null {
+    let next = this.nextSibling;
+    while (next) {
+      if (next.nodeType === ELEMENT_NODE) return next as unknown as Element;
+      next = next.nextSibling;
     }
+    return null;
+  }
 
-    before(...nodes: (NodeBase | string)[]): void {
-        if (!this.parentNode) return;
-        
-        for (const node of nodes) {
-            if (typeof node === 'string') {
-                const { TextBase } = require('./TextBase');
-                const textNode = new TextBase(node, this._ownerDocument);
-                this.parentNode.insertBefore(textNode, this);
-            } else {
-                this.parentNode.insertBefore(node, this);
-            }
-        }
+  get previousElementSibling(): Element | null {
+    let prev = this.previousSibling;
+    while (prev) {
+      if (prev.nodeType === ELEMENT_NODE) return prev as unknown as Element;
+      prev = prev.previousSibling;
     }
+    return null;
+  }
 
-    remove(): void {
-        if (this.parentNode) {
-            this.parentNode.removeChild(this);
-        }
+  get assignedSlot(): any | null {
+    return null;
+  }
+
+  // ChildNode interface implementation
+  after(...nodes: (Node | string)[]): void {
+    if (!this.parentNode) return;
+
+    const nextSibling = this.nextSibling;
+    for (const node of nodes) {
+      if (typeof node === 'string') {
+        const { TextBase } = require('./TextBase');
+        const textNode = new TextBase(node, this._ownerDocument);
+        this.parentNode.insertBefore(textNode, nextSibling);
+      } else {
+        this.parentNode.insertBefore(node, nextSibling);
+      }
     }
+  }
 
-    replaceWith(...nodes: (NodeBase | string)[]): void {
-        if (!this.parentNode) return;
-        
-        this.before(...nodes);
-        this.remove();
+  before(...nodes: (Node | string)[]): void {
+    if (!this.parentNode) return;
+
+    for (const node of nodes) {
+      if (typeof node === 'string') {
+        const { TextBase } = require('./TextBase');
+        const textNode = new TextBase(node, this._ownerDocument);
+        this.parentNode.insertBefore(textNode, this as unknown as Node);
+      } else {
+        this.parentNode.insertBefore(node, this as unknown as Node);
+      }
     }
+  }
+
+  remove(): void {
+    if (this.parentNode) {
+      this.parentNode.removeChild(this as unknown as Node);
+    }
+  }
+
+  replaceWith(...nodes: (Node | string)[]): void {
+    if (!this.parentNode) return;
+
+    this.before(...nodes);
+    this.remove();
+  }
 }
 
-// TextNode is now in a separate file
+// TextNode is now in a separate file

package/src/node/Comment.ts

@@ -3,7 +3,7 @@ import { COMMENT_NODE } from './Node';
 
 /**
  * The **`Comment`** interface represents textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view.
- * 
+ *
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Comment)
  */
 // export interface Comment {
@@ -21,78 +21,78 @@ import { COMMENT_NODE } from './Node';
 /**
  * The **`CommentNode`** class represents a comment node in the DOM.
  */
-export class Comment extends ChildNodeBase  {
-    private _data: string;
+export class Comment extends ChildNodeBase {
+  private _data: string;
 
-    constructor(data: string, ownerDocument?: any) {
-        super(COMMENT_NODE, '#comment', ownerDocument);
-        this._data = data;
-        this._nodeValue = data;
-    }
+  constructor(data: string, ownerDocument?: any) {
+    super(COMMENT_NODE, '#comment', ownerDocument);
+    this._data = data;
+    this._nodeValue = data;
+  }
 
-    get data(): string {
-        return this._data;
-    }
+  get data(): string {
+    return this._data;
+  }
 
-    set data(value: string) {
-        this._data = value;
-        this._nodeValue = value;
-    }
+  set data(value: string) {
+    this._data = value;
+    this._nodeValue = value;
+  }
 
-    get length(): number {
-        return this._data.length;
-    }
+  get length(): number {
+    return this._data.length;
+  }
 
-    get textContent(): string | null {
-        return this._data;
-    }
+  get textContent(): string | null {
+    return this._data;
+  }
 
-    set textContent(value: string | null) {
-        this._data = value || '';
-        this._nodeValue = this._data;
-    }
+  set textContent(value: string | null) {
+    this._data = value || '';
+    this._nodeValue = this._data;
+  }
 
-    // CharacterData methods
-    appendData(data: string): void {
-        this._data += data;
-        this._nodeValue = this._data;
-    }
+  // CharacterData methods
+  appendData(data: string): void {
+    this._data += data;
+    this._nodeValue = this._data;
+  }
 
-    deleteData(offset: number, count: number): void {
-        if (offset < 0 || offset > this._data.length) {
-            throw new Error('Index out of bounds');
-        }
-        const endOffset = Math.min(offset + count, this._data.length);
-        this._data = this._data.slice(0, offset) + this._data.slice(endOffset);
-        this._nodeValue = this._data;
+  deleteData(offset: number, count: number): void {
+    if (offset < 0 || offset > this._data.length) {
+      throw new Error('Index out of bounds');
     }
+    const endOffset = Math.min(offset + count, this._data.length);
+    this._data = this._data.slice(0, offset) + this._data.slice(endOffset);
+    this._nodeValue = this._data;
+  }
 
-    insertData(offset: number, data: string): void {
-        if (offset < 0 || offset > this._data.length) {
-            throw new Error('Index out of bounds');
-        }
-        this._data = this._data.slice(0, offset) + data + this._data.slice(offset);
-        this._nodeValue = this._data;
+  insertData(offset: number, data: string): void {
+    if (offset < 0 || offset > this._data.length) {
+      throw new Error('Index out of bounds');
     }
+    this._data = this._data.slice(0, offset) + data + this._data.slice(offset);
+    this._nodeValue = this._data;
+  }
 
-    replaceData(offset: number, count: number, data: string): void {
-        this.deleteData(offset, count);
-        this.insertData(offset, data);
-    }
+  replaceData(offset: number, count: number, data: string): void {
+    this.deleteData(offset, count);
+    this.insertData(offset, data);
+  }
 
-    substringData(offset: number, count: number): string {
-        if (offset < 0 || offset > this._data.length) {
-            throw new Error('Index out of bounds');
-        }
-        const endOffset = Math.min(offset + count, this._data.length);
-        return this._data.slice(offset, endOffset);
+  substringData(offset: number, count: number): string {
+    if (offset < 0 || offset > this._data.length) {
+      throw new Error('Index out of bounds');
     }
+    const endOffset = Math.min(offset + count, this._data.length);
+    return this._data.slice(offset, endOffset);
+  }
 
-    cloneNode(deep?: boolean): Comment {
-        return new Comment(this._data, this._ownerDocument);
-    }
+  cloneNode(deep?: boolean): Node {
+    return new Comment(this._data, this._ownerDocument) as unknown as Node;
+  }
 
-    toString(): string {
-        return `<!--${this._data}-->`;
-    }
-}
+  toString(): string {
+    return `<!--${this._data}-->`;
+  }
+}