@dooboostore/dom-parser 1.0.0

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

@@ -0,0 +1,936 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ElementBase_exports = {};
+__export(ElementBase_exports, {
+  ElementBase: () => ElementBase
+});
+module.exports = __toCommonJS(ElementBase_exports);
+var import_ParentNodeBase = require("../ParentNodeBase");
+var import_collection = require("../collection");
+var import_ElementFactory = require("../../factory/ElementFactory");
+var import_Node = require("../Node");
+var import_CSSSelector = require("../../utils/CSSSelector");
+var import_NodeBase = require("../NodeBase");
+class DOMException extends Error {
+  constructor(message, name = "DOMException") {
+    super(message);
+    this.name = name;
+    this.name = name;
+  }
+}
+class ElementBase extends import_ParentNodeBase.ParentNodeBase {
+  constructor(_tagName, ownerDocument) {
+    super(import_Node.ELEMENT_NODE, _tagName.toUpperCase(), ownerDocument);
+    this._tagName = _tagName;
+    this._id = "";
+    this._className = "";
+    this._attributes = /* @__PURE__ */ new Map();
+    this.onfullscreenchange = null;
+    this.onfullscreenerror = null;
+  }
+  get tagName() {
+    return this._tagName.toUpperCase();
+  }
+  get localName() {
+    return this._tagName.toLowerCase();
+  }
+  // Element interface implementation
+  get id() {
+    return this._id;
+  }
+  set id(value) {
+    this._id = value;
+    this._attributes.set("id", value);
+  }
+  get className() {
+    return this._className;
+  }
+  set className(value) {
+    this._className = value;
+    this._attributes.set("class", value);
+  }
+  get classList() {
+    return new DOMTokenListImpl(this);
+  }
+  get innerHTML() {
+    let html = "";
+    for (const child of this._childNodesInternal) {
+      if (child.nodeType === import_Node.TEXT_NODE) {
+        html += child._nodeValue || "";
+      } else if (child.nodeType === import_Node.ELEMENT_NODE) {
+        html += this.generateChildElementHTML(child);
+      } else if (child.nodeType === 8) {
+        html += `<!--${child.textContent || ""}-->`;
+      }
+    }
+    return html;
+  }
+  get innerText() {
+    return this.textContent || "";
+  }
+  set innerText(value) {
+    this._childNodesInternal = [];
+    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;
+    }
+  }
+  set innerHTML(value) {
+    while (this._childNodesInternal.length > 0) {
+      const child = this._childNodesInternal[0];
+      if (child) {
+        this.removeChild(child);
+      }
+    }
+    if (value.trim()) {
+      this.parseAndAppendHTML(value);
+    }
+  }
+  /**
+   * Generate HTML for a child element without using outerHTML to avoid circular dependency
+   */
+  generateChildElementHTML(element) {
+    const tagName = element.tagName.toLowerCase();
+    const attrs = Array.from(element._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(tagName);
+    if (isSelfClosing) {
+      return `<${tagName}${attrs} />`;
+    } else {
+      let childHTML = "";
+      for (const child of element._childNodesInternal || []) {
+        if (child.nodeType === import_Node.TEXT_NODE) {
+          childHTML += child._nodeValue || "";
+        } else if (child.nodeType === import_Node.ELEMENT_NODE) {
+          childHTML += this.generateChildElementHTML(child);
+        } else if (child.nodeType === 8) {
+          childHTML += `<!--${child.textContent || ""}-->`;
+        }
+      }
+      return `<${tagName}${attrs}>${childHTML}</${tagName}>`;
+    }
+  }
+  /**
+   * Improved HTML parser for innerHTML using a stack-based approach
+   */
+  parseAndAppendHTML(html) {
+    const ElementFactory2 = require("../../factory/ElementFactory").ElementFactory;
+    let i = 0;
+    const length = html.length;
+    while (i < length) {
+      const nextTagStart = html.indexOf("<", i);
+      if (nextTagStart === -1) {
+        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);
+        }
+        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);
+        }
+      }
+      i = nextTagStart;
+      const tagEnd = this.findTagEnd(html, i);
+      if (tagEnd === -1) break;
+      const tagContent = html.substring(i + 1, tagEnd);
+      if (tagContent.startsWith("!--")) {
+        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);
+          i = commentEnd + 3;
+          continue;
+        }
+      }
+      if (tagContent.endsWith("/")) {
+        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);
+        this.parseAttributes(element, attributeString2);
+        this.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);
+        i = tagEnd + 1;
+        continue;
+      }
+      const parts = tagContent.split(/\s+/);
+      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);
+        if (closingTagIndex2 !== -1) {
+          const element = ElementFactory2.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);
+          }
+          this.appendChild(element);
+          i = closingTagIndex2 + closingTag2.length;
+          continue;
+        }
+      }
+      const closingTag = `</${tagName}>`;
+      const closingTagIndex = this.findMatchingClosingTag(html, tagName, tagEnd + 1);
+      if (closingTagIndex !== -1) {
+        const element = ElementFactory2.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;
+      } else {
+        const element = ElementFactory2.createElement(tagName, this._ownerDocument);
+        this.parseAttributes(element, attributeString);
+        this.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;
+    let quoteChar = "";
+    while (i < html.length) {
+      const char = html[i];
+      if (!inQuotes) {
+        if (char === '"' || char === "'") {
+          inQuotes = true;
+          quoteChar = char;
+        } else if (char === ">") {
+          return i;
+        }
+      } else {
+        if (char === quoteChar) {
+          inQuotes = false;
+          quoteChar = "";
+        }
+      }
+      i++;
+    }
+    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}>`;
+    let depth = 1;
+    let i = startIndex;
+    while (i < html.length && depth > 0) {
+      const nextOpen = html.indexOf(openTag, i);
+      const nextClose = html.indexOf(closeTag, i);
+      if (nextClose === -1) {
+        return -1;
+      }
+      if (nextOpen !== -1 && nextOpen < nextClose) {
+        const afterTag = html.charAt(nextOpen + openTag.length);
+        if (afterTag === " " || afterTag === ">" || afterTag === "/") {
+          depth++;
+        }
+        i = nextOpen + openTag.length;
+      } else {
+        depth--;
+        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++;
+      }
+      if (position >= length) break;
+      const nameStart = 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++;
+      }
+      let value = "";
+      if (position < length && 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++;
+            }
+            value = attributeString.substring(valueStart, position);
+            if (position < length && attributeString[position] === quote) {
+              position++;
+            }
+          } else {
+            const valueStart = position;
+            while (position < length && !/\s/.test(attributeString[position])) {
+              position++;
+            }
+            value = attributeString.substring(valueStart, position);
+          }
+        }
+      }
+      value = this.decodeHTMLEntities(value);
+      element.setAttribute(name, 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;
+    });
+  }
+  /**
+   * 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;": '"'
+    };
+    return str.replace(/&[a-zA-Z0-9#]+;/g, (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);
+        }
+      }
+      if (entity.startsWith("&#x") && entity.endsWith(";")) {
+        const hexStr = entity.slice(3, -1);
+        const num = parseInt(hexStr, 16);
+        if (!isNaN(num)) {
+          return String.fromCharCode(num);
+        }
+      }
+      return entity;
+    });
+  }
+  get outerHTML() {
+    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()}>`;
+    }
+  }
+  get namespaceURI() {
+    return "http://www.w3.org/1999/xhtml";
+  }
+  get prefix() {
+    return null;
+  }
+  // Attribute methods
+  getAttribute(qualifiedName) {
+    const value = this._attributes.get(qualifiedName.toLowerCase());
+    return value !== void 0 ? value : 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;
+    }
+  }
+  removeAttribute(qualifiedName) {
+    const name = qualifiedName.toLowerCase();
+    this._attributes.delete(name);
+    if (name === "id") {
+      this._id = "";
+    } else if (name === "class") {
+      this._className = "";
+    }
+  }
+  hasAttribute(qualifiedName) {
+    return this._attributes.has(qualifiedName.toLowerCase());
+  }
+  closest(selectors) {
+    let element = this;
+    while (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 import_CSSSelector.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");
+  }
+  get clientLeft() {
+    throw new Error("Element.clientLeft is not implemented yet");
+  }
+  get clientTop() {
+    throw new Error("Element.clientTop is not implemented yet");
+  }
+  get clientWidth() {
+    throw new Error("Element.clientWidth is not implemented yet");
+  }
+  get currentCSSZoom() {
+    throw new Error("Element.currentCSSZoom is not implemented yet");
+  }
+  get part() {
+    throw new Error("Element.part is not implemented yet");
+  }
+  get scrollHeight() {
+    throw new Error("Element.scrollHeight is not implemented yet");
+  }
+  get scrollLeft() {
+    throw new Error("Element.scrollLeft is not implemented yet");
+  }
+  set scrollLeft(value) {
+    throw new Error("Element.scrollLeft setter is not implemented yet");
+  }
+  get scrollTop() {
+    throw new Error("Element.scrollTop is not implemented yet");
+  }
+  set scrollTop(value) {
+    throw new Error("Element.scrollTop setter is not implemented yet");
+  }
+  get scrollWidth() {
+    throw new Error("Element.scrollWidth is not implemented yet");
+  }
+  get shadowRoot() {
+    throw new Error("Element.shadowRoot is not implemented yet");
+  }
+  get slot() {
+    throw new Error("Element.slot is not implemented yet");
+  }
+  set slot(value) {
+    throw new Error("Element.slot setter is not implemented yet");
+  }
+  // Methods - Not implemented yet
+  attachShadow(init) {
+    throw new Error("Element.attachShadow() is not implemented yet");
+  }
+  checkVisibility(options) {
+    throw new Error("Element.checkVisibility() is not implemented yet");
+  }
+  computedStyleMap() {
+    throw new Error("Element.computedStyleMap() is not implemented yet");
+  }
+  getAttributeNS(namespace, localName) {
+    return this.getAttribute(localName);
+  }
+  getAttributeNames() {
+    return Array.from(this._attributes.keys());
+  }
+  getAttributeNode(qualifiedName) {
+    const value = this.getAttribute(qualifiedName);
+    if (value !== null) {
+      return new AttrImpl(qualifiedName, value);
+    }
+    return null;
+  }
+  getAttributeNodeNS(namespace, localName) {
+    return this.getAttributeNode(localName);
+  }
+  getBoundingClientRect() {
+    throw new Error("Element.getBoundingClientRect() is not implemented yet");
+  }
+  getClientRects() {
+    throw new Error("Element.getClientRects() is not implemented yet");
+  }
+  getElementsByClassName(classNames) {
+    const result = [];
+    const classNameList = classNames.trim().split(/\s+/);
+    const hasAllClasses = (element, classes) => {
+      const elementClasses = element.className.trim().split(/\s+/);
+      return classes.every((cls) => elementClasses.includes(cls));
+    };
+    const traverse = (node) => {
+      if (node.nodeType === import_Node.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]);
+      }
+    };
+    for (let i = 0; i < this.childNodes.length; i++) {
+      traverse(this.childNodes[i]);
+    }
+    return new import_collection.HTMLCollection(result);
+  }
+  getElementsByTagName(qualifiedName) {
+    const result = [];
+    const tagName = qualifiedName.toLowerCase();
+    const isWildcard = tagName === "*";
+    const traverse = (node) => {
+      if (node.nodeType === import_Node.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]);
+      }
+    };
+    for (let i = 0; i < this.childNodes.length; i++) {
+      traverse(this.childNodes[i]);
+    }
+    return new import_collection.HTMLCollection(result);
+  }
+  getElementsByTagNameNS(namespace, localName) {
+    return this.getElementsByTagName(localName);
+  }
+  getHTML(options) {
+    throw new Error("Element.getHTML() is not implemented yet");
+  }
+  hasAttributeNS(namespace, localName) {
+    return this.hasAttribute(localName);
+  }
+  hasAttributes() {
+    return this._attributes.size > 0;
+  }
+  hasPointerCapture(pointerId) {
+    throw new Error("Element.hasPointerCapture() is not implemented yet");
+  }
+  insertAdjacentElement(where, element) {
+    const position = where.toLowerCase();
+    switch (position) {
+      case "beforebegin":
+        if (this.parentNode) {
+          this.parentNode.insertBefore(element, this);
+          return element;
+        }
+        return null;
+      case "afterbegin":
+        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);
+          }
+          return element;
+        }
+        return null;
+      default:
+        throw new DOMException(`Invalid position: ${where}`, "SyntaxError");
+    }
+  }
+  insertAdjacentHTML(position, html) {
+    const pos = position.toLowerCase();
+    const tempDiv = this._ownerDocument.createElement("div");
+    tempDiv.innerHTML = html;
+    const fragment = this._ownerDocument.createDocumentFragment();
+    while (tempDiv.firstChild) {
+      fragment.appendChild(tempDiv.firstChild);
+    }
+    switch (pos) {
+      case "beforebegin":
+        if (this.parentNode) {
+          this.parentNode.insertBefore(fragment, this);
+        }
+        break;
+      case "afterbegin":
+        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);
+          }
+        }
+        break;
+      default:
+        throw new DOMException(`Invalid position: ${position}`, "SyntaxError");
+    }
+  }
+  insertAdjacentText(where, data) {
+    const position = where.toLowerCase();
+    const textNode = this._ownerDocument.createTextNode(data);
+    switch (position) {
+      case "beforebegin":
+        if (this.parentNode) {
+          this.parentNode.insertBefore(textNode, this);
+        }
+        break;
+      case "afterbegin":
+        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);
+          }
+        }
+        break;
+      default:
+        throw new DOMException(`Invalid position: ${where}`, "SyntaxError");
+    }
+  }
+  releasePointerCapture(pointerId) {
+  }
+  removeAttributeNS(namespace, localName) {
+    this.removeAttribute(localName);
+  }
+  removeAttributeNode(attr) {
+    const oldValue = this.getAttribute(attr.name);
+    if (oldValue !== null) {
+      this.removeAttribute(attr.name);
+      return new AttrImpl(attr.name, oldValue);
+    }
+    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");
+  }
+  requestPointerLock(options) {
+    throw new Error("Element.requestPointerLock() is not implemented yet");
+  }
+  scroll(optionsOrX, y) {
+  }
+  scrollBy(optionsOrX, y) {
+  }
+  scrollIntoView(arg) {
+  }
+  scrollTo(optionsOrX, y) {
+  }
+  setAttributeNS(namespace, qualifiedName, value) {
+    this.setAttribute(qualifiedName, value);
+  }
+  setAttributeNode(attr) {
+    const oldAttr = this.getAttributeNode(attr.name);
+    this.setAttribute(attr.name, attr.value);
+    return oldAttr;
+  }
+  setAttributeNodeNS(attr) {
+    return this.setAttributeNode(attr);
+  }
+  setHTMLUnsafe(html) {
+  }
+  setPointerCapture(pointerId) {
+  }
+  toggleAttribute(qualifiedName, force) {
+    const hasAttr = this.hasAttribute(qualifiedName);
+    if (force === true || force === void 0 && !hasAttr) {
+      this.setAttribute(qualifiedName, "");
+      return true;
+    } else if (force === false || force === void 0 && hasAttr) {
+      this.removeAttribute(qualifiedName);
+      return false;
+    }
+    return hasAttr;
+  }
+  webkitMatchesSelector(selectors) {
+    return false;
+  }
+  // EventTarget methods - Not implemented yet
+  addEventListener(type, listener, options) {
+  }
+  removeEventListener(type, listener, options) {
+  }
+  dispatchEvent(event) {
+    return true;
+  }
+  cloneNode(deep) {
+    const clone = import_ElementFactory.ElementFactory.createElement(this.tagName, this._ownerDocument);
+    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));
+        }
+      }
+    }
+    return clone;
+  }
+}
+class DOMTokenListImpl {
+  constructor(element) {
+    this.element = element;
+  }
+  get length() {
+    return this.element.className.split(/\s+/).filter((c) => c.length > 0).length;
+  }
+  get value() {
+    return this.element.className;
+  }
+  set value(value) {
+    this.element.className = value;
+  }
+  add(...tokens) {
+    const classes = new Set(this.element.className.split(/\s+/).filter((c) => c.length > 0));
+    for (const token of tokens) {
+      classes.add(token);
+    }
+    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);
+    }
+    this.element.className = Array.from(classes).join(" ");
+  }
+  contains(token) {
+    return this.element.className.split(/\s+/).includes(token);
+  }
+  toggle(token, force) {
+    const hasToken = this.contains(token);
+    if (force === true || force === void 0 && !hasToken) {
+      this.add(token);
+      return true;
+    } else {
+      this.remove(token);
+      return false;
+    }
+  }
+  replace(oldToken, newToken) {
+    if (this.contains(oldToken)) {
+      this.remove(oldToken);
+      this.add(newToken);
+      return true;
+    }
+    return false;
+  }
+  item(index) {
+    const classes = this.element.className.split(/\s+/).filter((c) => c.length > 0);
+    return index >= 0 && index < classes.length ? classes[index] : null;
+  }
+}
+class AttrImpl extends import_NodeBase.NodeBase {
+  constructor(name, value) {
+    super(import_Node.ATTRIBUTE_NODE, name);
+    this.name = name;
+    this.value = value;
+    this.ownerElement = null;
+    this.namespaceURI = null;
+    this.prefix = null;
+    this.specified = true;
+  }
+  get localName() {
+    return this.name;
+  }
+}
+class NamedNodeMapImpl {
+  constructor(attributes) {
+    this.attributes = attributes;
+  }
+  get length() {
+    return this.attributes.size;
+  }
+  getNamedItem(qualifiedName) {
+    const value = this.attributes.get(qualifiedName.toLowerCase());
+    return value !== void 0 ? new AttrImpl(qualifiedName, value) : null;
+  }
+  getNamedItemNS(namespace, 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);
+    }
+    return null;
+  }
+  removeNamedItem(qualifiedName) {
+    const value = this.attributes.get(qualifiedName.toLowerCase());
+    if (value !== void 0) {
+      this.attributes.delete(qualifiedName.toLowerCase());
+      return new AttrImpl(qualifiedName, value);
+    }
+    throw new DOMException("The attribute is not found", "NotFoundError");
+  }
+  removeNamedItemNS(namespace, localName) {
+    return this.removeNamedItem(localName);
+  }
+  setNamedItem(attr) {
+    const oldValue = this.attributes.get(attr.name.toLowerCase());
+    this.attributes.set(attr.name.toLowerCase(), attr.value);
+    return oldValue !== void 0 ? new AttrImpl(attr.name, oldValue) : null;
+  }
+  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);
+    }
+  }
+  // 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);
+      }
+    }();
+  }
+  entries() {
+    const self = this;
+    return function* () {
+      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);
+    });
+  }
+}
+//# sourceMappingURL=ElementBase.js.map