@dooboostore/dom-parser 1.0.1 → 1.0.2

package/dist/esm-bundle/dooboostore-dom-parser.esm.js

@@ -185,100 +185,6 @@ var init_NodeListOf = __esm({
   }
 });
 
-// src/node/TextBase.ts
-var TextBase_exports = {};
-__export(TextBase_exports, {
-  TextBase: () => TextBase
-});
-var TextBase;
-var init_TextBase = __esm({
-  "src/node/TextBase.ts"() {
-    init_ChildNodeBase();
-    init_Node();
-    TextBase = class _TextBase extends ChildNodeBase {
-      constructor(data, ownerDocument) {
-        super(TEXT_NODE, "#text", ownerDocument);
-        // Override nodeType to match Text interface
-        this.nodeType = TEXT_NODE;
-        this.nodeName = "#text";
-        this._data = data;
-        this._nodeValue = data;
-      }
-      get data() {
-        return this._data;
-      }
-      set data(value) {
-        this._data = value;
-        this._nodeValue = value;
-      }
-      get length() {
-        return this._data.length;
-      }
-      get textContent() {
-        return this._data ? this.decodeHTMLEntities(this._data) : this._data;
-      }
-      set textContent(value) {
-        this._data = value || "";
-        this._nodeValue = this._data;
-      }
-      get wholeText() {
-        return this._data;
-      }
-      // CharacterData methods
-      appendData(data) {
-        this._data += data;
-        this._nodeValue = this._data;
-      }
-      deleteData(offset, count) {
-        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, data) {
-        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, count, data) {
-        this.deleteData(offset, count);
-        this.insertData(offset, data);
-      }
-      substringData(offset, count) {
-        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);
-      }
-      splitText(offset) {
-        if (offset < 0 || offset > this._data.length) {
-          throw new Error("Index out of bounds");
-        }
-        const newData = this._data.slice(offset);
-        this._data = this._data.slice(0, offset);
-        this._nodeValue = this._data;
-        const newTextNode = new _TextBase(newData, this._ownerDocument);
-        if (this._parentNodeInternal) {
-          const nextSibling = this.nextSibling;
-          this._parentNodeInternal.insertBefore(newTextNode, nextSibling);
-        }
-        return newTextNode;
-      }
-      cloneNode(deep) {
-        return new _TextBase(this._data, this._ownerDocument);
-      }
-      toString() {
-        return this._data;
-      }
-    };
-  }
-});
-
 // src/node/NodeBase.ts
 var NodeBase;
 var init_NodeBase = __esm({
@@ -689,6 +595,174 @@ var init_ChildNodeBase = __esm({
   }
 });
 
+// src/node/TextBase.ts
+var TextBase_exports = {};
+__export(TextBase_exports, {
+  TextBase: () => TextBase
+});
+var TextBase;
+var init_TextBase = __esm({
+  "src/node/TextBase.ts"() {
+    init_ChildNodeBase();
+    init_Node();
+    TextBase = class _TextBase extends ChildNodeBase {
+      constructor(data, ownerDocument) {
+        super(TEXT_NODE, "#text", ownerDocument);
+        // Override nodeType to match Text interface
+        this.nodeType = TEXT_NODE;
+        this.nodeName = "#text";
+        this._data = data;
+        this._nodeValue = data;
+      }
+      get data() {
+        return this._data;
+      }
+      set data(value) {
+        this._data = value;
+        this._nodeValue = value;
+      }
+      get length() {
+        return this._data.length;
+      }
+      get textContent() {
+        return this._data ? this.decodeHTMLEntities(this._data) : this._data;
+      }
+      set textContent(value) {
+        this._data = value || "";
+        this._nodeValue = this._data;
+      }
+      get wholeText() {
+        return this._data;
+      }
+      // CharacterData methods
+      appendData(data) {
+        this._data += data;
+        this._nodeValue = this._data;
+      }
+      deleteData(offset, count) {
+        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, data) {
+        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, count, data) {
+        this.deleteData(offset, count);
+        this.insertData(offset, data);
+      }
+      substringData(offset, count) {
+        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);
+      }
+      splitText(offset) {
+        if (offset < 0 || offset > this._data.length) {
+          throw new Error("Index out of bounds");
+        }
+        const newData = this._data.slice(offset);
+        this._data = this._data.slice(0, offset);
+        this._nodeValue = this._data;
+        const newTextNode = new _TextBase(newData, this._ownerDocument);
+        if (this._parentNodeInternal) {
+          const nextSibling = this.nextSibling;
+          this._parentNodeInternal.insertBefore(newTextNode, nextSibling);
+        }
+        return newTextNode;
+      }
+      cloneNode(deep) {
+        return new _TextBase(this._data, this._ownerDocument);
+      }
+      toString() {
+        return this._data;
+      }
+    };
+  }
+});
+
+// src/node/Comment.ts
+var Comment_exports = {};
+__export(Comment_exports, {
+  Comment: () => Comment
+});
+var Comment;
+var init_Comment = __esm({
+  "src/node/Comment.ts"() {
+    init_ChildNodeBase();
+    init_Node();
+    Comment = class _Comment extends ChildNodeBase {
+      constructor(data, ownerDocument) {
+        super(COMMENT_NODE, "#comment", ownerDocument);
+        this._data = data;
+        this._nodeValue = data;
+      }
+      get data() {
+        return this._data;
+      }
+      set data(value) {
+        this._data = value;
+        this._nodeValue = value;
+      }
+      get length() {
+        return this._data.length;
+      }
+      get textContent() {
+        return this._data;
+      }
+      set textContent(value) {
+        this._data = value || "";
+        this._nodeValue = this._data;
+      }
+      // CharacterData methods
+      appendData(data) {
+        this._data += data;
+        this._nodeValue = this._data;
+      }
+      deleteData(offset, count) {
+        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, data) {
+        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, count, data) {
+        this.deleteData(offset, count);
+        this.insertData(offset, data);
+      }
+      substringData(offset, count) {
+        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) {
+        return new _Comment(this._data, this._ownerDocument);
+      }
+      toString() {
+        return `<!--${this._data}-->`;
+      }
+    };
+  }
+});
+
 // src/node/collection/HTMLCollection.ts
 var HTMLCollection;
 var init_HTMLCollection = __esm({
@@ -1151,80 +1225,6 @@ var init_ParentNodeBase = __esm({
   }
 });
 
-// src/node/Comment.ts
-var Comment_exports = {};
-__export(Comment_exports, {
-  Comment: () => Comment
-});
-var Comment;
-var init_Comment = __esm({
-  "src/node/Comment.ts"() {
-    init_ChildNodeBase();
-    init_Node();
-    Comment = class _Comment extends ChildNodeBase {
-      constructor(data, ownerDocument) {
-        super(COMMENT_NODE, "#comment", ownerDocument);
-        this._data = data;
-        this._nodeValue = data;
-      }
-      get data() {
-        return this._data;
-      }
-      set data(value) {
-        this._data = value;
-        this._nodeValue = value;
-      }
-      get length() {
-        return this._data.length;
-      }
-      get textContent() {
-        return this._data;
-      }
-      set textContent(value) {
-        this._data = value || "";
-        this._nodeValue = this._data;
-      }
-      // CharacterData methods
-      appendData(data) {
-        this._data += data;
-        this._nodeValue = this._data;
-      }
-      deleteData(offset, count) {
-        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, data) {
-        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, count, data) {
-        this.deleteData(offset, count);
-        this.insertData(offset, data);
-      }
-      substringData(offset, count) {
-        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) {
-        return new _Comment(this._data, this._ownerDocument);
-      }
-      toString() {
-        return `<!--${this._data}-->`;
-      }
-    };
-  }
-});
-
 // src/node/DocumentFragmentBase.ts
 var DocumentFragmentBase;
 var init_DocumentFragmentBase = __esm({
@@ -1423,7 +1423,7 @@ var init_ElementBase = __esm({
        */
       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 attrs = Array.from(element._attributes?.entries() || []).map(([name, value]) => value === "" ? ` ${name}` : ` ${name}="${String(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) {
@@ -1855,7 +1855,17 @@ var init_ElementBase = __esm({
         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");
@@ -2250,7 +2260,7 @@ var init_ElementBase = __esm({
 });
 
 // src/node/elements/HTMLElementBase.ts
-var HTMLElementBase;
+var HTMLElementBase, CSSStyleDeclarationImpl, StylePropertyMapImpl;
 var init_HTMLElementBase = __esm({
   "src/node/elements/HTMLElementBase.ts"() {
     init_ElementBase();
@@ -2266,6 +2276,10 @@ var init_HTMLElementBase = __esm({
         this._contentEditable = "inherit";
         this._innerText = "";
         this._outerText = "";
+        // New implementations for style, dataset, nonce
+        this._style = null;
+        this._dataset = null;
+        this._attributeStyleMap = null;
       }
       // HTMLElement interface implementation
       get title() {
@@ -2348,8 +2362,6 @@ var init_HTMLElementBase = __esm({
         console.log(`Clicked on ${this.tagName} element`);
       }
       focus(options) {
-        this.setAttribute("data-focused", "true");
-        console.log(`Focused on ${this.tagName} element`);
       }
       blur() {
         this.removeAttribute("data-focused");
@@ -2411,6 +2423,156 @@ var init_HTMLElementBase = __esm({
             break;
         }
       }
+      get style() {
+        if (!this._style) {
+          this._style = new Proxy(new CSSStyleDeclarationImpl(this), {
+            get: (target, prop) => {
+              if (typeof prop === "string" && !(prop in target)) {
+                const cssProp = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+                return target.getPropertyValue(cssProp);
+              }
+              return target[prop];
+            },
+            set: (target, prop, value) => {
+              if (typeof prop === "string" && !(prop in target)) {
+                const cssProp = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+                target.setProperty(cssProp, String(value));
+                return true;
+              }
+              target[prop] = value;
+              return true;
+            }
+          });
+        }
+        return this._style;
+      }
+      set style(value) {
+        if (typeof value === "string") {
+          this.style.cssText = value;
+        }
+      }
+      get attributeStyleMap() {
+        if (!this._attributeStyleMap) {
+          this._attributeStyleMap = new StylePropertyMapImpl(this);
+        }
+        return this._attributeStyleMap;
+      }
+      get dataset() {
+        if (!this._dataset) {
+          this._dataset = new Proxy({}, {
+            get: (target, prop) => {
+              if (typeof prop === "string") {
+                const attrName = "data-" + prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+                return this.getAttribute(attrName);
+              }
+              return void 0;
+            },
+            set: (target, prop, value) => {
+              if (typeof prop === "string") {
+                const attrName = "data-" + prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+                this.setAttribute(attrName, String(value));
+                return true;
+              }
+              return false;
+            },
+            deleteProperty: (target, prop) => {
+              if (typeof prop === "string") {
+                const attrName = "data-" + prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+                this.removeAttribute(attrName);
+                return true;
+              }
+              return false;
+            }
+          });
+        }
+        return this._dataset;
+      }
+      get nonce() {
+        return this.getAttribute("nonce") || "";
+      }
+      set nonce(value) {
+        this.setAttribute("nonce", value);
+      }
+    };
+    CSSStyleDeclarationImpl = class {
+      constructor(element) {
+        this.element = element;
+        this.parentRule = null;
+      }
+      getPropertyPriority(property) {
+        return "";
+      }
+      get cssText() {
+        return this.element.getAttribute("style") || "";
+      }
+      set cssText(value) {
+        this.element.setAttribute("style", value);
+      }
+      get length() {
+        return this.parseStyle(this.cssText).size;
+      }
+      getPropertyValue(property) {
+        const style = this.parseStyle(this.cssText);
+        return style.get(property) || "";
+      }
+      setProperty(property, value, priority = "") {
+        const style = this.parseStyle(this.cssText);
+        if (value === null || value === "") {
+          style.delete(property);
+        } else {
+          style.set(property, value);
+        }
+        this.cssText = this.serializeStyle(style);
+      }
+      removeProperty(property) {
+        const style = this.parseStyle(this.cssText);
+        const value = style.get(property) || "";
+        style.delete(property);
+        this.cssText = this.serializeStyle(style);
+        return value;
+      }
+      item(index) {
+        const style = this.parseStyle(this.cssText);
+        return Array.from(style.keys())[index] || "";
+      }
+      parseStyle(cssText) {
+        const style = /* @__PURE__ */ new Map();
+        if (!cssText) return style;
+        cssText.split(";").forEach((declaration) => {
+          const part = declaration.trim();
+          if (!part) return;
+          const colonIndex = part.indexOf(":");
+          if (colonIndex !== -1) {
+            const property = part.substring(0, colonIndex).trim();
+            const value = part.substring(colonIndex + 1).trim();
+            if (property && value) {
+              style.set(property, value);
+            }
+          }
+        });
+        return style;
+      }
+      serializeStyle(style) {
+        return Array.from(style.entries()).map(([property, value]) => `${property}: ${value}`).join("; ");
+      }
+    };
+    StylePropertyMapImpl = class {
+      constructor(element) {
+        this.element = element;
+      }
+      set(property, ...values) {
+        const value = values[0];
+        this.element.style.setProperty(property, String(value));
+      }
+      append(property, ...values) {
+        this.set(property, ...values);
+      }
+      delete(property) {
+        this.element.style.removeProperty(property);
+      }
+      clear() {
+        this.element.style.cssText = "";
+      }
     };
   }
 });
@@ -4494,6 +4656,10 @@ var init_ElementFactory = __esm({
   }
 });
 
+// src/DomParser.ts
+init_TextBase();
+init_Comment();
+
 // src/node/DocumentBase.ts
 init_ParentNodeBase();
 init_Node();
@@ -4709,6 +4875,7 @@ var DocumentBase = class extends ParentNodeBase {
       },
       reload: () => {
       },
+      // @ts-ignore
       toString: () => this._location.href
     };
     // Event handlers
@@ -4738,6 +4905,9 @@ var DocumentBase = class extends ParentNodeBase {
     this.head = head;
     this.body = body;
   }
+  setLocation(location) {
+    this._location = location;
+  }
   get location() {
     return this._location;
   }
@@ -4995,10 +5165,6 @@ var DocumentBase = class extends ParentNodeBase {
   }
 };
 
-// src/DomParser.ts
-init_TextBase();
-init_Comment();
-
 // src/window/WindowBase.ts
 init_NodeBase();
 init_ElementBase();
@@ -5277,10 +5443,14 @@ var NavigatorBase = class {
   }
 };
 var WindowBase = class {
-  constructor(document, initialUrl) {
+  constructor(config) {
     // Event system
     this._eventListeners = [];
-    this.closed = false;
+    // Timers and intervals tracking
+    this._timers = /* @__PURE__ */ new Set();
+    this._intervals = /* @__PURE__ */ new Set();
+    this._animationFrames = /* @__PURE__ */ new Set();
+    this._closed = false;
     this.cookieStore = {};
     this.customElements = {};
     this.devicePixelRatio = 1;
@@ -5505,11 +5675,13 @@ var WindowBase = class {
     this.performance = {};
     // WindowSessionStorage
     this.sessionStorage = {};
-    this.document = document || new DocumentBase();
+    const documentBase = new DocumentBase();
     if (this.document && this.document.setWindow) {
       this.document.setWindow(this);
     }
-    this._location = new LocationBase(initialUrl);
+    this._location = new LocationBase(config?.initialUrl);
+    documentBase.setLocation(this._location);
+    this.document = documentBase;
     this.history = new HistoryBase(this);
     this.navigator = new NavigatorBase();
     this.clientInformation = this.navigator;
@@ -5552,6 +5724,9 @@ var WindowBase = class {
       }
     });
   }
+  get closed() {
+    return this._closed;
+  }
   get location() {
     return this._location;
   }
@@ -5572,6 +5747,103 @@ var WindowBase = class {
   captureEvents() {
   }
   close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._timers.forEach((id) => clearTimeout(id));
+    this._timers.clear();
+    this._intervals.forEach((id) => clearInterval(id));
+    this._intervals.clear();
+    this._animationFrames.forEach((id) => clearTimeout(id));
+    this._animationFrames.clear();
+    this._eventListeners.forEach((listener) => {
+      listener.listener = null;
+    });
+    this._eventListeners.length = 0;
+    this.onload = null;
+    this.onunload = null;
+    this.onbeforeunload = null;
+    this.onpopstate = null;
+    this.onerror = null;
+    this.onmessage = null;
+    this.onhashchange = null;
+    if (this.document) {
+      const doc = this.document;
+      if (doc.body) {
+        this.clearNodeRecursively(doc.body);
+      }
+      if (doc.head) {
+        this.clearNodeRecursively(doc.head);
+      }
+      if (doc.documentElement) {
+        this.clearNodeRecursively(doc.documentElement);
+      }
+      if (doc.setWindow) {
+        doc.setWindow(null);
+      }
+      if (doc._eventListeners) {
+        doc._eventListeners.forEach((listener) => {
+          listener.listener = null;
+        });
+        doc._eventListeners.length = 0;
+      }
+    }
+    if (this.history) {
+      const hist = this.history;
+      if (hist.historyStack) {
+        hist.historyStack.forEach((entry) => {
+          entry.state = null;
+        });
+        hist.historyStack.length = 0;
+      }
+      hist.state = null;
+      hist.window = null;
+    }
+    if (this._location) {
+      this._location.urlChangeCallback = null;
+    }
+  }
+  /**
+   * Recursively clear a node and its children to prevent memory leaks
+   */
+  clearNodeRecursively(node) {
+    if (!node) return;
+    while (node.firstChild) {
+      const child = node.firstChild;
+      node.removeChild(child);
+      this.clearNodeRecursively(child);
+    }
+    if (node._eventListeners) {
+      node._eventListeners.forEach((listener) => {
+        listener.listener = null;
+      });
+      node._eventListeners.length = 0;
+    }
+    try {
+      if (node.parentNode) {
+        node.parentNode = null;
+      }
+    } catch (e) {
+    }
+    try {
+      if (node.ownerDocument) {
+        node.ownerDocument = null;
+      }
+    } catch (e) {
+    }
+    if (node._childNodes) {
+      if (Array.isArray(node._childNodes)) {
+        node._childNodes = [];
+      } else if (node._childNodes instanceof Map) {
+        node._childNodes.clear();
+      }
+    }
+    if (node._attributes) {
+      if (Array.isArray(node._attributes)) {
+        node._attributes = [];
+      } else if (node._attributes instanceof Map) {
+        node._attributes.clear();
+      }
+    }
   }
   confirm(message) {
     return false;
@@ -5620,23 +5892,38 @@ var WindowBase = class {
   }
   // Timer methods
   setTimeout(callback, delay, ...args) {
-    return setTimeout(callback, delay, ...args);
+    if (this._closed) return 0;
+    const id = setTimeout(() => {
+      this._timers.delete(id);
+      callback(...args);
+    }, delay);
+    this._timers.add(id);
+    return id;
   }
   clearTimeout(id) {
     clearTimeout(id);
+    this._timers.delete(id);
   }
   setInterval(callback, delay, ...args) {
-    return setInterval(callback, delay, ...args);
+    if (this._closed) return 0;
+    const id = setInterval(callback, delay, ...args);
+    this._intervals.add(id);
+    return id;
   }
   clearInterval(id) {
     clearInterval(id);
+    this._intervals.delete(id);
   }
   // Animation methods
   requestAnimationFrame(callback) {
-    return this.setTimeout(callback, 16);
+    if (this._closed) return 0;
+    const id = this.setTimeout(callback, 16);
+    this._animationFrames.add(id);
+    return id;
   }
   cancelAnimationFrame(id) {
     this.clearTimeout(id);
+    this._animationFrames.delete(id);
   }
   addEventListener(type, listener, options) {
     if (type === "popstate" || type === "load" || type === "unload" || type === "beforeunload") {
@@ -5827,43 +6114,65 @@ var WindowBase = class {
 // src/DomParser.ts
 var DomParser = class {
   constructor(html, option) {
-    const document = new DocumentBase();
-    const windowBase = new WindowBase(document, option?.href);
+    const windowBase = new WindowBase({ initialUrl: option?.href });
     this._window = windowBase;
-    this._document = document;
+    this._document = windowBase.document;
     this.parseHTML(html);
     this.setupDocumentReferences();
-    if (document && document.simulateLoading) {
-      document.simulateLoading();
+    if (this._document && this._document.simulateLoading) {
+      this._document.simulateLoading();
     }
   }
   get window() {
+    if (!this._window) {
+      throw new Error("DomParser has been destroyed");
+    }
     return this._window;
   }
   get document() {
+    if (!this._document) {
+      throw new Error("DomParser has been destroyed");
+    }
     return this._document;
   }
+  /**
+   * Destroy the DomParser instance and free memory
+   */
+  destroy() {
+    if (this._window) {
+      this._window.close();
+      this._window = null;
+    }
+    this._document = null;
+  }
   /**
    * Load new HTML content and replace the current document
    */
   loadHTML(html) {
+    if (!this._document) {
+      throw new Error("DomParser has been destroyed");
+    }
     this.clearDocument();
     this.parseHTML(html);
     this.setupDocumentReferences();
   }
   clearDocument() {
-    if (this.document.head) {
-      while (this.document.head.firstChild) {
-        this.document.head.removeChild(this.document.head.firstChild);
+    if (!this._document) return;
+    if (this._document.head) {
+      while (this._document.head.firstChild) {
+        this._document.head.removeChild(this._document.head.firstChild);
       }
     }
-    if (this.document.body) {
-      while (this.document.body.firstChild) {
-        this.document.body.removeChild(this.document.body.firstChild);
+    if (this._document.body) {
+      while (this._document.body.firstChild) {
+        this._document.body.removeChild(this._document.body.firstChild);
       }
     }
   }
   parseHTML(html) {
+    if (!this._document) {
+      throw new Error("DomParser has been destroyed");
+    }
     if (!html.trim()) {
       return;
     }