@dooboostore/dom-parser 1.0.1 → 1.0.3

package/dist/esm/node/elements/ElementBase.js

@@ -1,9 +1,9 @@
 import { ParentNodeBase } from "../ParentNodeBase.js";
-import { HTMLCollection } from "../collection/index.js";
-import { ElementFactory } from "../../factory/ElementFactory.js";
+import { HTMLCollectionImp, HTMLCollectionOfImp } from "../collection/index.js";
 import { ELEMENT_NODE, TEXT_NODE, ATTRIBUTE_NODE } from "../Node.js";
 import { CSSSelector } from "../../utils/CSSSelector.js";
 import { NodeBase } from "../NodeBase.js";
+import { ShadowRootBase } from "../ShadowRootBase.js";
 class DOMException extends Error {
   constructor(message, name = "DOMException") {
     super(message);
@@ -11,16 +11,23 @@ class DOMException extends Error {
     this.name = name;
   }
 }
-class ElementBase extends ParentNodeBase {
-  constructor(_tagName, ownerDocument) {
+const _ElementBase = class _ElementBase extends ParentNodeBase {
+  constructor(_tagName = "DIV", ownerDocument) {
     super(ELEMENT_NODE, _tagName.toUpperCase(), ownerDocument);
     this._tagName = _tagName;
     this._id = "";
     this._className = "";
     this._attributes = /* @__PURE__ */ new Map();
+    this._shadowRoot = null;
     this.onfullscreenchange = null;
     this.onfullscreenerror = null;
   }
+  animate(keyframes, options) {
+    throw new Error("Method not implemented.");
+  }
+  getAnimations(options) {
+    throw new Error("Method not implemented.");
+  }
   get tagName() {
     return this._tagName.toUpperCase();
   }
@@ -66,10 +73,12 @@ class ElementBase extends ParentNodeBase {
     if (value !== null && value !== void 0) {
       const stringValue = String(value);
       const escapedValue = this.escapeHTMLEntities(stringValue);
-      const { TextBase } = require("../TextBase");
-      const textNode = new TextBase(escapedValue, this._ownerDocument);
-      this._childNodesInternal.push(textNode);
-      textNode._parentNodeInternal = this;
+      const { TextBase } = _ElementBase.dependencies;
+      if (TextBase) {
+        const textNode = new TextBase(escapedValue, this._ownerDocument);
+        this._childNodesInternal.push(textNode);
+        textNode._parentNodeInternal = this;
+      }
     }
   }
   set innerHTML(value) {
@@ -88,13 +97,16 @@ class ElementBase extends ParentNodeBase {
    */
   generateChildElementHTML(element) {
     const tagName = element.tagName.toLowerCase();
-    const attrs = Array.from(element._attributes?.entries() || []).map(([name, value]) => value === "" ? ` ${name}` : ` ${name}="${value.replace(/"/g, """)}"`).join("");
+    const attrs = Array.from(element._attributes?.entries() || []).map(([name, value]) => value === "" ? ` ${name}` : ` ${name}="${String(value).replace(/"/g, """)}"`).join("");
     const selfClosingTags = ["img", "input", "br", "hr", "meta", "link", "area", "base", "col", "embed", "source", "track", "wbr"];
     const isSelfClosing = selfClosingTags.includes(tagName);
     if (isSelfClosing) {
       return `<${tagName}${attrs} />`;
     } else {
       let childHTML = "";
+      if (element.shadowRoot) {
+        childHTML += `<template shadowrootmode="${element.shadowRoot.mode}">${element.shadowRoot.innerHTML}</template>`;
+      }
       for (const child of element._childNodesInternal || []) {
         if (child.nodeType === TEXT_NODE) {
           childHTML += child._nodeValue || "";
@@ -110,8 +122,12 @@ class ElementBase extends ParentNodeBase {
   /**
    * Improved HTML parser for innerHTML using a stack-based approach
    */
-  parseAndAppendHTML(html) {
-    const ElementFactory2 = require("../../factory/ElementFactory").ElementFactory;
+  parseAndAppendHTML(html, targetNode = this) {
+    const { ElementFactory, TextBase, Comment } = _ElementBase.dependencies;
+    if (!ElementFactory) {
+      console.error("SWC DOM Parser: ElementFactory dependency not injected.");
+      return;
+    }
     let i = 0;
     const length = html.length;
     while (i < length) {
@@ -120,18 +136,14 @@ class ElementBase extends ParentNodeBase {
         let text = html.substring(i).trim();
         if (text) {
           text = this.fixBrokenClosingTags(text);
-          const { TextBase } = require("../TextBase");
-          const textNode = new TextBase(text, this._ownerDocument);
-          this.appendChild(textNode);
+          if (TextBase) targetNode.appendChild(new TextBase(text, this._ownerDocument));
         }
         break;
       } else if (nextTagStart > i) {
         let text = html.substring(i, nextTagStart).trim();
         if (text) {
           text = this.fixBrokenClosingTags(text);
-          const { TextBase } = require("../TextBase");
-          const textNode = new TextBase(text, this._ownerDocument);
-          this.appendChild(textNode);
+          if (TextBase) targetNode.appendChild(new TextBase(text, this._ownerDocument));
         }
       }
       i = nextTagStart;
@@ -142,9 +154,7 @@ class ElementBase extends ParentNodeBase {
         const commentEnd = html.indexOf("-->", i);
         if (commentEnd !== -1) {
           const commentContent = html.substring(i + 4, commentEnd);
-          const { Comment } = require("../Comment");
-          const commentNode = new Comment(commentContent, this._ownerDocument);
-          this.appendChild(commentNode);
+          if (Comment) targetNode.appendChild(new Comment(commentContent, this._ownerDocument));
           i = commentEnd + 3;
           continue;
         }
@@ -153,17 +163,15 @@ class ElementBase extends ParentNodeBase {
         const parts2 = tagContent.slice(0, -1).trim().split(/\s+/);
         const tagName2 = parts2[0];
         const attributeString2 = tagContent.slice(tagName2.length, -1).trim();
-        const element = ElementFactory2.createElement(tagName2, this._ownerDocument);
+        const element = ElementFactory.createElement(tagName2, this._ownerDocument);
         this.parseAttributes(element, attributeString2);
-        this.appendChild(element);
+        targetNode.appendChild(element);
         i = tagEnd + 1;
         continue;
       }
       if (tagContent.startsWith("/")) {
         const closingTagText = `<${tagContent}>`;
-        const { TextBase } = require("../TextBase");
-        const textNode = new TextBase(closingTagText, this._ownerDocument);
-        this.appendChild(textNode);
+        if (TextBase) targetNode.appendChild(new TextBase(closingTagText, this._ownerDocument));
         i = tagEnd + 1;
         continue;
       }
@@ -171,44 +179,38 @@ class ElementBase extends ParentNodeBase {
       const tagName = parts[0];
       const attributeString = tagContent.slice(tagName.length).trim();
       if (tagName === "style" || tagName === "script") {
-        const closingTag2 = `</${tagName}>`;
-        const closingTagIndex2 = html.indexOf(closingTag2, tagEnd + 1);
+        const closingTag = `</${tagName}>`;
+        const closingTagIndex2 = html.indexOf(closingTag, tagEnd + 1);
         if (closingTagIndex2 !== -1) {
-          const element = ElementFactory2.createElement(tagName, this._ownerDocument);
+          const element = ElementFactory.createElement(tagName, this._ownerDocument);
           this.parseAttributes(element, attributeString);
           const content = html.substring(tagEnd + 1, closingTagIndex2);
-          if (content) {
-            const { TextBase } = require("../TextBase");
-            const textNode = new TextBase(content, this._ownerDocument);
-            element.appendChild(textNode);
+          if (content && TextBase) {
+            element.appendChild(new TextBase(content, this._ownerDocument));
           }
-          this.appendChild(element);
-          i = closingTagIndex2 + closingTag2.length;
+          targetNode.appendChild(element);
+          i = closingTagIndex2 + closingTag.length;
           continue;
         }
       }
-      const closingTag = `</${tagName}>`;
       const closingTagIndex = this.findMatchingClosingTag(html, tagName, tagEnd + 1);
       if (closingTagIndex !== -1) {
-        const element = ElementFactory2.createElement(tagName, this._ownerDocument);
+        const element = ElementFactory.createElement(tagName, this._ownerDocument);
         this.parseAttributes(element, attributeString);
         const content = html.substring(tagEnd + 1, closingTagIndex);
         if (content.trim()) {
           element.innerHTML = content;
         }
-        this.appendChild(element);
-        i = closingTagIndex + closingTag.length;
+        targetNode.appendChild(element);
+        i = closingTagIndex + (tagName.length + 3);
       } else {
-        const element = ElementFactory2.createElement(tagName, this._ownerDocument);
+        const element = ElementFactory.createElement(tagName, this._ownerDocument);
         this.parseAttributes(element, attributeString);
-        this.appendChild(element);
+        targetNode.appendChild(element);
         i = tagEnd + 1;
       }
     }
   }
-  /**
-   * Find the real end of a tag, considering quoted attributes
-   */
   findTagEnd(html, startIndex) {
     let i = startIndex + 1;
     let inQuotes = false;
@@ -219,9 +221,7 @@ class ElementBase extends ParentNodeBase {
         if (char === '"' || char === "'") {
           inQuotes = true;
           quoteChar = char;
-        } else if (char === ">") {
-          return i;
-        }
+        } else if (char === ">") return i;
       } else {
         if (char === quoteChar) {
           inQuotes = false;
@@ -232,16 +232,9 @@ class ElementBase extends ParentNodeBase {
     }
     return -1;
   }
-  /**
-   * Fix broken closing tags in text content
-   * Converts patterns like "/div>" to "</div>"
-   */
   fixBrokenClosingTags(text) {
     return text.replace(/\/(\w+)>/g, "</$1>");
   }
-  /**
-   * Find the matching closing tag, accounting for nested tags of the same type
-   */
   findMatchingClosingTag(html, tagName, startIndex) {
     const openTag = `<${tagName}`;
     const closeTag = `</${tagName}>`;
@@ -250,135 +243,70 @@ class ElementBase extends ParentNodeBase {
     while (i < html.length && depth > 0) {
       const nextOpen = html.indexOf(openTag, i);
       const nextClose = html.indexOf(closeTag, i);
-      if (nextClose === -1) {
-        return -1;
-      }
+      if (nextClose === -1) return -1;
       if (nextOpen !== -1 && nextOpen < nextClose) {
         const afterTag = html.charAt(nextOpen + openTag.length);
-        if (afterTag === " " || afterTag === ">" || afterTag === "/") {
-          depth++;
-        }
+        if (afterTag === " " || afterTag === ">" || afterTag === "/") depth++;
         i = nextOpen + openTag.length;
       } else {
         depth--;
-        if (depth === 0) {
-          return nextClose;
-        }
+        if (depth === 0) return nextClose;
         i = nextClose + closeTag.length;
       }
     }
     return -1;
   }
-  /**
-   * Parse attributes from attribute string
-   */
   parseAttributes(element, attributeString) {
     let position = 0;
     const length = attributeString.length;
     while (position < length) {
-      while (position < length && /\s/.test(attributeString[position])) {
-        position++;
-      }
+      while (position < length && /\s/.test(attributeString[position])) position++;
       if (position >= length) break;
       const nameStart = position;
-      while (position < length && /[\w:-]/.test(attributeString[position])) {
-        position++;
-      }
+      while (position < length && /[\w:-]/.test(attributeString[position])) position++;
       if (position === nameStart) {
         position++;
         continue;
       }
       const name = attributeString.substring(nameStart, position);
-      while (position < length && /\s/.test(attributeString[position])) {
-        position++;
-      }
+      while (position < length && /\s/.test(attributeString[position])) position++;
       let value = "";
       if (position < length && attributeString[position] === "=") {
         position++;
-        while (position < length && /\s/.test(attributeString[position])) {
-          position++;
-        }
+        while (position < length && /\s/.test(attributeString[position])) position++;
         if (position < length) {
           const quote = attributeString[position];
           if (quote === '"' || quote === "'") {
             position++;
             const valueStart = position;
-            while (position < length && attributeString[position] !== quote) {
-              position++;
-            }
+            while (position < length && attributeString[position] !== quote) position++;
             value = attributeString.substring(valueStart, position);
-            if (position < length && attributeString[position] === quote) {
-              position++;
-            }
+            if (position < length && attributeString[position] === quote) position++;
           } else {
             const valueStart = position;
-            while (position < length && !/\s/.test(attributeString[position])) {
-              position++;
-            }
+            while (position < length && !/\s/.test(attributeString[position])) position++;
             value = attributeString.substring(valueStart, position);
           }
         }
       }
-      value = this.decodeHTMLEntities(value);
-      element.setAttribute(name, value);
+      element.setAttribute(name, this.decodeHTMLEntities(value));
     }
   }
-  /**
-   * Escape HTML entities in a string to prevent XSS
-   */
   escapeHTMLEntities(str) {
-    const entityMap = {
-      "&": "&amp;",
-      "<": "&lt;",
-      ">": "&gt;",
-      '"': "&quot;",
-      "'": "&#39;"
-    };
-    return str.replace(/[&<>"']/g, (char) => {
-      return entityMap[char] || char;
-    });
+    const entityMap = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+    return str.replace(/[&<>"']/g, (char) => entityMap[char] || char);
   }
-  /**
-   * Decode HTML entities in a string
-   */
   decodeHTMLEntities(str) {
-    const entityMap = {
-      "&amp;": "&",
-      "&lt;": "<",
-      "&gt;": ">",
-      "&quot;": '"',
-      "&#39;": "'",
-      "&#34;": '"',
-      "&apos;": "'",
-      "&copy;": "\xA9",
-      "&reg;": "\xAE",
-      "&trade;": "\u2122",
-      "&nbsp;": " ",
-      "&hellip;": "\u2026",
-      "&mdash;": "\u2014",
-      "&ndash;": "\u2013",
-      "&lsquo;": "\u2018",
-      "&rsquo;": "\u2019",
-      "&ldquo;": '"',
-      "&rdquo;": '"'
-    };
+    const entityMap = { "&amp;": "&", "&lt;": "<", "&gt;": ">", "&quot;": '"', "&#39;": "'", "&#34;": '"', "&apos;": "'", "&copy;": "\xA9", "&reg;": "\xAE", "&trade;": "\u2122", "&nbsp;": " ", "&hellip;": "\u2026", "&mdash;": "\u2014", "&ndash;": "\u2013", "&lsquo;": "\u2018", "&rsquo;": "\u2019", "&ldquo;": '"', "&rdquo;": '"' };
     return str.replace(/&[a-zA-Z0-9#]+;/g, (entity) => {
-      if (entityMap[entity]) {
-        return entityMap[entity];
-      }
+      if (entityMap[entity]) return entityMap[entity];
       if (entity.startsWith("&#") && entity.endsWith(";")) {
-        const numStr = entity.slice(2, -1);
-        const num = parseInt(numStr, 10);
-        if (!isNaN(num)) {
-          return String.fromCharCode(num);
-        }
+        const num = parseInt(entity.slice(2, -1), 10);
+        return isNaN(num) ? entity : String.fromCharCode(num);
       }
       if (entity.startsWith("&#x") && entity.endsWith(";")) {
-        const hexStr = entity.slice(3, -1);
-        const num = parseInt(hexStr, 16);
-        if (!isNaN(num)) {
-          return String.fromCharCode(num);
-        }
+        const num = parseInt(entity.slice(3, -1), 16);
+        return isNaN(num) ? entity : String.fromCharCode(num);
       }
       return entity;
     });
@@ -387,11 +315,7 @@ class ElementBase extends ParentNodeBase {
     const attrs = Array.from(this._attributes.entries()).map(([name, value]) => value === "" ? ` ${name}` : ` ${name}="${value.replace(/"/g, "&quot;")}"`).join("");
     const selfClosingTags = ["img", "input", "br", "hr", "meta", "link", "area", "base", "col", "embed", "source", "track", "wbr"];
     const isSelfClosing = selfClosingTags.includes(this.tagName.toLowerCase());
-    if (isSelfClosing) {
-      return `<${this.tagName.toLowerCase()}${attrs} />`;
-    } else {
-      return `<${this.tagName.toLowerCase()}${attrs}>${this.innerHTML}</${this.tagName.toLowerCase()}>`;
-    }
+    return isSelfClosing ? `<${this.tagName.toLowerCase()}${attrs} />` : `<${this.tagName.toLowerCase()}${attrs}>${this.innerHTML}</${this.tagName.toLowerCase()}>`;
   }
   get namespaceURI() {
     return "http://www.w3.org/1999/xhtml";
@@ -399,28 +323,20 @@ class ElementBase extends ParentNodeBase {
   get prefix() {
     return null;
   }
-  // Attribute methods
   getAttribute(qualifiedName) {
-    const value = this._attributes.get(qualifiedName.toLowerCase());
-    return value !== void 0 ? value : null;
+    return this._attributes.get(qualifiedName.toLowerCase()) ?? null;
   }
   setAttribute(qualifiedName, value) {
     const name = qualifiedName.toLowerCase();
     this._attributes.set(name, value);
-    if (name === "id") {
-      this._id = value;
-    } else if (name === "class") {
-      this._className = value;
-    }
+    if (name === "id") this._id = value;
+    else if (name === "class") this._className = value;
   }
   removeAttribute(qualifiedName) {
     const name = qualifiedName.toLowerCase();
     this._attributes.delete(name);
-    if (name === "id") {
-      this._id = "";
-    } else if (name === "class") {
-      this._className = "";
-    }
+    if (name === "id") this._id = "";
+    else if (name === "class") this._className = "";
   }
   hasAttribute(qualifiedName) {
     return this._attributes.has(qualifiedName.toLowerCase());
@@ -428,82 +344,74 @@ class ElementBase extends ParentNodeBase {
   closest(selectors) {
     let element = this;
     while (element) {
-      if (element.matches && element.matches(selectors)) {
-        return element;
-      }
+      if (element.matches && element.matches(selectors)) return element;
       element = element.parentElement;
     }
     return null;
   }
-  /**
-   * Returns true if the element would be selected by the specified CSS selector; otherwise, returns false.
-   * 
-   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/matches)
-   */
   matches(selectors) {
     return CSSSelector.matches(this, selectors);
   }
-  // ChildNode methods are inherited from ParentNodeBase -> ChildNodeBase
-  // Additional Element properties and methods - Not implemented yet
   get attributes() {
     return new NamedNodeMapImpl(this._attributes);
   }
   get clientHeight() {
-    throw new Error("Element.clientHeight is not implemented yet");
+    return 0;
   }
   get clientLeft() {
-    throw new Error("Element.clientLeft is not implemented yet");
+    return 0;
   }
   get clientTop() {
-    throw new Error("Element.clientTop is not implemented yet");
+    return 0;
   }
   get clientWidth() {
-    throw new Error("Element.clientWidth is not implemented yet");
+    return 0;
   }
   get currentCSSZoom() {
-    throw new Error("Element.currentCSSZoom is not implemented yet");
+    return 1;
   }
   get part() {
-    throw new Error("Element.part is not implemented yet");
+    return { length: 0, value: "", add: () => {
+    }, remove: () => {
+    }, contains: () => false, toggle: () => false, replace: () => false, item: () => null };
   }
   get scrollHeight() {
-    throw new Error("Element.scrollHeight is not implemented yet");
+    return 0;
   }
   get scrollLeft() {
-    throw new Error("Element.scrollLeft is not implemented yet");
+    return 0;
   }
-  set scrollLeft(value) {
-    throw new Error("Element.scrollLeft setter is not implemented yet");
+  set scrollLeft(_) {
   }
   get scrollTop() {
-    throw new Error("Element.scrollTop is not implemented yet");
+    return 0;
   }
-  set scrollTop(value) {
-    throw new Error("Element.scrollTop setter is not implemented yet");
+  set scrollTop(_) {
   }
   get scrollWidth() {
-    throw new Error("Element.scrollWidth is not implemented yet");
+    return 0;
   }
   get shadowRoot() {
-    throw new Error("Element.shadowRoot is not implemented yet");
+    return this._shadowRoot;
   }
   get slot() {
-    throw new Error("Element.slot is not implemented yet");
+    return this.getAttribute("slot") || "";
   }
   set slot(value) {
-    throw new Error("Element.slot setter is not implemented yet");
+    this.setAttribute("slot", value);
   }
-  // Methods - Not implemented yet
   attachShadow(init) {
-    throw new Error("Element.attachShadow() is not implemented yet");
+    if (this._shadowRoot) throw new DOMException("Shadow root already attached", "NotSupportedError");
+    this._shadowRoot = new ShadowRootBase(this, init, this._ownerDocument);
+    return this._shadowRoot;
   }
-  checkVisibility(options) {
-    throw new Error("Element.checkVisibility() is not implemented yet");
+  checkVisibility(_options) {
+    return true;
   }
   computedStyleMap() {
-    throw new Error("Element.computedStyleMap() is not implemented yet");
+    return /* @__PURE__ */ new Map();
   }
-  getAttributeNS(namespace, localName) {
+  getAttributeNS(_ns, localName) {
     return this.getAttribute(localName);
   }
   getAttributeNames() {
@@ -511,19 +419,17 @@ class ElementBase extends ParentNodeBase {
   }
   getAttributeNode(qualifiedName) {
     const value = this.getAttribute(qualifiedName);
-    if (value !== null) {
-      return new AttrImpl(qualifiedName, value);
-    }
-    return null;
+    return value !== null ? new AttrImpl(qualifiedName, value) : null;
   }
-  getAttributeNodeNS(namespace, localName) {
+  getAttributeNodeNS(_ns, localName) {
     return this.getAttributeNode(localName);
   }
   getBoundingClientRect() {
-    throw new Error("Element.getBoundingClientRect() is not implemented yet");
+    return { bottom: 0, height: 0, left: 0, right: 0, top: 0, width: 0, x: 0, y: 0, toJSON: () => ({}) };
   }
   getClientRects() {
-    throw new Error("Element.getClientRects() is not implemented yet");
+    return { length: 0, item: () => null, [Symbol.iterator]: function* () {
+    } };
   }
   getElementsByClassName(classNames) {
     const result = [];
@@ -533,55 +439,37 @@ class ElementBase extends ParentNodeBase {
       return classes.every((cls) => elementClasses.includes(cls));
     };
     const traverse = (node) => {
-      if (node.nodeType === ELEMENT_NODE) {
-        const element = node;
-        if (hasAllClasses(element, classNameList)) {
-          result.push(element);
-        }
-      }
-      for (let i = 0; i < node.childNodes.length; i++) {
-        traverse(node.childNodes[i]);
-      }
+      if (node.nodeType === ELEMENT_NODE && hasAllClasses(node, classNameList)) result.push(node);
+      for (let i = 0; i < node.childNodes.length; i++) traverse(node.childNodes[i]);
     };
-    for (let i = 0; i < this.childNodes.length; i++) {
-      traverse(this.childNodes[i]);
-    }
-    return new HTMLCollection(result);
+    for (let i = 0; i < this.childNodes.length; i++) traverse(this.childNodes[i]);
+    return new HTMLCollectionOfImp(result);
   }
   getElementsByTagName(qualifiedName) {
     const result = [];
     const tagName = qualifiedName.toLowerCase();
     const isWildcard = tagName === "*";
     const traverse = (node) => {
-      if (node.nodeType === ELEMENT_NODE) {
-        const element = node;
-        if (isWildcard || element.localName === tagName) {
-          result.push(element);
-        }
-      }
-      for (let i = 0; i < node.childNodes.length; i++) {
-        traverse(node.childNodes[i]);
-      }
+      if (node.nodeType === ELEMENT_NODE && (isWildcard || node.localName === tagName)) result.push(node);
+      for (let i = 0; i < node.childNodes.length; i++) traverse(node.childNodes[i]);
     };
-    for (let i = 0; i < this.childNodes.length; i++) {
-      traverse(this.childNodes[i]);
-    }
-    return new HTMLCollection(result);
+    for (let i = 0; i < this.childNodes.length; i++) traverse(this.childNodes[i]);
+    return new HTMLCollectionImp(result);
   }
-  getElementsByTagNameNS(namespace, localName) {
+  getElementsByTagNameNS(_ns, localName) {
     return this.getElementsByTagName(localName);
   }
-  getHTML(options) {
-    throw new Error("Element.getHTML() is not implemented yet");
+  getHTML(_options) {
+    return this.outerHTML;
   }
-  hasAttributeNS(namespace, localName) {
+  hasAttributeNS(_ns, localName) {
     return this.hasAttribute(localName);
   }
   hasAttributes() {
     return this._attributes.size > 0;
   }
-  hasPointerCapture(pointerId) {
-    throw new Error("Element.hasPointerCapture() is not implemented yet");
+  hasPointerCapture(_id) {
+    return false;
   }
   insertAdjacentElement(where, element) {
     const position = where.toLowerCase();
@@ -593,22 +481,16 @@ class ElementBase extends ParentNodeBase {
         }
         return null;
       case "afterbegin":
-        if (this.firstChild) {
-          this.insertBefore(element, this.firstChild);
-        } else {
-          this.appendChild(element);
-        }
+        if (this.firstChild) this.insertBefore(element, this.firstChild);
+        else this.appendChild(element);
         return element;
       case "beforeend":
         this.appendChild(element);
         return element;
       case "afterend":
         if (this.parentNode) {
-          if (this.nextSibling) {
-            this.parentNode.insertBefore(element, this.nextSibling);
-          } else {
-            this.parentNode.appendChild(element);
-          }
+          if (this.nextSibling) this.parentNode.insertBefore(element, this.nextSibling);
+          else this.parentNode.appendChild(element);
           return element;
         }
         return null;
@@ -621,32 +503,22 @@ class ElementBase extends ParentNodeBase {
     const tempDiv = this._ownerDocument.createElement("div");
     tempDiv.innerHTML = html;
     const fragment = this._ownerDocument.createDocumentFragment();
-    while (tempDiv.firstChild) {
-      fragment.appendChild(tempDiv.firstChild);
-    }
+    while (tempDiv.firstChild) fragment.appendChild(tempDiv.firstChild);
     switch (pos) {
       case "beforebegin":
-        if (this.parentNode) {
-          this.parentNode.insertBefore(fragment, this);
-        }
+        if (this.parentNode) this.parentNode.insertBefore(fragment, this);
         break;
       case "afterbegin":
-        if (this.firstChild) {
-          this.insertBefore(fragment, this.firstChild);
-        } else {
-          this.appendChild(fragment);
-        }
+        if (this.firstChild) this.insertBefore(fragment, this.firstChild);
+        else this.appendChild(fragment);
         break;
       case "beforeend":
         this.appendChild(fragment);
         break;
       case "afterend":
         if (this.parentNode) {
-          if (this.nextSibling) {
-            this.parentNode.insertBefore(fragment, this.nextSibling);
-          } else {
-            this.parentNode.appendChild(fragment);
-          }
+          if (this.nextSibling) this.parentNode.insertBefore(fragment, this.nextSibling);
+          else this.parentNode.appendChild(fragment);
         }
         break;
       default:
@@ -658,36 +530,28 @@ class ElementBase extends ParentNodeBase {
     const textNode = this._ownerDocument.createTextNode(data);
     switch (position) {
       case "beforebegin":
-        if (this.parentNode) {
-          this.parentNode.insertBefore(textNode, this);
-        }
+        if (this.parentNode) this.parentNode.insertBefore(textNode, this);
         break;
       case "afterbegin":
-        if (this.firstChild) {
-          this.insertBefore(textNode, this.firstChild);
-        } else {
-          this.appendChild(textNode);
-        }
+        if (this.firstChild) this.insertBefore(textNode, this.firstChild);
+        else this.appendChild(textNode);
         break;
       case "beforeend":
         this.appendChild(textNode);
         break;
       case "afterend":
         if (this.parentNode) {
-          if (this.nextSibling) {
-            this.parentNode.insertBefore(textNode, this.nextSibling);
-          } else {
-            this.parentNode.appendChild(textNode);
-          }
+          if (this.nextSibling) this.parentNode.insertBefore(textNode, this.nextSibling);
+          else this.parentNode.appendChild(textNode);
         }
         break;
       default:
         throw new DOMException(`Invalid position: ${where}`, "SyntaxError");
     }
   }
-  releasePointerCapture(pointerId) {
+  releasePointerCapture(_id) {
   }
-  removeAttributeNS(namespace, localName) {
+  removeAttributeNS(_ns, localName) {
     this.removeAttribute(localName);
   }
   removeAttributeNode(attr) {
@@ -698,21 +562,21 @@ class ElementBase extends ParentNodeBase {
     }
     throw new DOMException("The attribute node is not an attribute of this element", "NotFoundError");
   }
-  requestFullscreen(options) {
-    throw new Error("Element.requestFullscreen() is not implemented yet");
+  requestFullscreen(_opt) {
+    return Promise.resolve();
   }
-  requestPointerLock(options) {
-    throw new Error("Element.requestPointerLock() is not implemented yet");
+  requestPointerLock(_opt) {
+    return Promise.resolve();
   }
-  scroll(optionsOrX, y) {
+  scroll(_x, _y) {
   }
-  scrollBy(optionsOrX, y) {
+  scrollBy(_x, _y) {
   }
-  scrollIntoView(arg) {
+  scrollIntoView(_arg) {
   }
-  scrollTo(optionsOrX, y) {
+  scrollTo(_x, _y) {
   }
-  setAttributeNS(namespace, qualifiedName, value) {
+  setAttributeNS(_ns, qualifiedName, value) {
     this.setAttribute(qualifiedName, value);
   }
   setAttributeNode(attr) {
@@ -724,8 +588,9 @@ class ElementBase extends ParentNodeBase {
     return this.setAttributeNode(attr);
   }
   setHTMLUnsafe(html) {
+    this.innerHTML = html;
   }
-  setPointerCapture(pointerId) {
+  setPointerCapture(_id) {
   }
   toggleAttribute(qualifiedName, force) {
     const hasAttr = this.hasAttribute(qualifiedName);
@@ -739,31 +604,31 @@ class ElementBase extends ParentNodeBase {
     return hasAttr;
   }
   webkitMatchesSelector(selectors) {
-    return false;
+    return this.matches(selectors);
   }
-  // EventTarget methods - Not implemented yet
   addEventListener(type, listener, options) {
   }
   removeEventListener(type, listener, options) {
   }
-  dispatchEvent(event) {
+  dispatchEvent(_event) {
     return true;
   }
   cloneNode(deep) {
+    const { ElementFactory } = _ElementBase.dependencies;
     const clone = ElementFactory.createElement(this.tagName, this._ownerDocument);
-    for (const [name, value] of this._attributes) {
-      clone.setAttribute(name, value);
-    }
+    for (const [name, value] of this._attributes) clone.setAttribute(name, value);
     if (deep) {
-      for (const child of this._childNodesInternal) {
-        if (child && "cloneNode" in child) {
-          clone.appendChild(child.cloneNode(true));
-        }
-      }
+      for (const child of this._childNodesInternal) if (child && "cloneNode" in child) clone.appendChild(child.cloneNode(true));
     }
     return clone;
   }
-}
+};
+/**
+ * Static dependencies to break circular references without using 'require' or 'global'.
+ * These are injected by the main DomParser entry point.
+ */
+_ElementBase.dependencies = {};
+let ElementBase = _ElementBase;
 class DOMTokenListImpl {
   constructor(element) {
     this.element = element;
@@ -779,16 +644,12 @@ class DOMTokenListImpl {
   }
   add(...tokens) {
     const classes = new Set(this.element.className.split(/\s+/).filter((c) => c.length > 0));
-    for (const token of tokens) {
-      classes.add(token);
-    }
+    tokens.forEach((t) => classes.add(t));
     this.element.className = Array.from(classes).join(" ");
   }
   remove(...tokens) {
     const classes = new Set(this.element.className.split(/\s+/).filter((c) => c.length > 0));
-    for (const token of tokens) {
-      classes.delete(token);
-    }
+    tokens.forEach((t) => classes.delete(t));
     this.element.className = Array.from(classes).join(" ");
   }
   contains(token) {
@@ -842,16 +703,12 @@ class NamedNodeMapImpl {
     const value = this.attributes.get(qualifiedName.toLowerCase());
     return value !== void 0 ? new AttrImpl(qualifiedName, value) : null;
   }
-  getNamedItemNS(namespace, localName) {
+  getNamedItemNS(_ns, localName) {
     return this.getNamedItem(localName);
   }
   item(index) {
     const keys = Array.from(this.attributes.keys());
-    if (index >= 0 && index < keys.length) {
-      const key = keys[index];
-      const value = this.attributes.get(key);
-      return new AttrImpl(key, value);
-    }
+    if (index >= 0 && index < keys.length) return new AttrImpl(keys[index], this.attributes.get(keys[index]));
     return null;
   }
   removeNamedItem(qualifiedName) {
@@ -862,7 +719,7 @@ class NamedNodeMapImpl {
     }
     throw new DOMException("The attribute is not found", "NotFoundError");
   }
-  removeNamedItemNS(namespace, localName) {
+  removeNamedItemNS(_ns, localName) {
     return this.removeNamedItem(localName);
   }
   setNamedItem(attr) {
@@ -873,42 +730,27 @@ class NamedNodeMapImpl {
   setNamedItemNS(attr) {
     return this.setNamedItem(attr);
   }
-  // Iterator implementation
   *[Symbol.iterator]() {
-    const keys = Array.from(this.attributes.keys());
-    for (const key of keys) {
-      const value = this.attributes.get(key);
-      yield new AttrImpl(key, value);
-    }
+    for (const [key, value] of this.attributes) yield new AttrImpl(key, value);
   }
-  // Additional iterator methods for compatibility
   keys() {
     return this.attributes.keys();
   }
   values() {
     const self = this;
     return function* () {
-      for (const [key, value] of self.attributes) {
-        yield new AttrImpl(key, value);
-      }
+      for (const [key, value] of self.attributes) yield new AttrImpl(key, value);
     }();
   }
   entries() {
     const self = this;
     return function* () {
-      for (const [key, value] of self.attributes) {
-        yield [key, new AttrImpl(key, value)];
-      }
+      for (const [key, value] of self.attributes) yield [key, new AttrImpl(key, value)];
     }();
   }
-  // forEach method for compatibility
   forEach(callback, thisArg) {
     const keys = Array.from(this.attributes.keys());
-    keys.forEach((key, index) => {
-      const value = this.attributes.get(key);
-      const attr = new AttrImpl(key, value);
-      callback.call(thisArg, attr, index, this);
-    });
+    keys.forEach((key, index) => callback.call(thisArg, new AttrImpl(key, this.attributes.get(key)), index, this));
   }
 }
 export {