@dooboostore/dom-parser 1.0.1 → 1.0.2

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

@@ -186,100 +186,6 @@ var dooboostoreDomParser = (() => {
     }
   });
 
-  // 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({
@@ -690,6 +596,174 @@ var dooboostoreDomParser = (() => {
     }
   });
 
+  // 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({
@@ -1152,80 +1226,6 @@ var dooboostoreDomParser = (() => {
     }
   });
 
-  // 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({
@@ -1424,7 +1424,7 @@ var dooboostoreDomParser = (() => {
          */
         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) {
@@ -1856,7 +1856,17 @@ var dooboostoreDomParser = (() => {
           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");
@@ -2251,7 +2261,7 @@ var dooboostoreDomParser = (() => {
   });
 
   // src/node/elements/HTMLElementBase.ts
-  var HTMLElementBase;
+  var HTMLElementBase, CSSStyleDeclarationImpl, StylePropertyMapImpl;
   var init_HTMLElementBase = __esm({
     "src/node/elements/HTMLElementBase.ts"() {
       init_ElementBase();
@@ -2267,6 +2277,10 @@ var dooboostoreDomParser = (() => {
           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() {
@@ -2349,8 +2363,6 @@ var dooboostoreDomParser = (() => {
           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");
@@ -2412,6 +2424,156 @@ var dooboostoreDomParser = (() => {
               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 = "";
+        }
       };
     }
   });
@@ -4503,6 +4665,10 @@ var dooboostoreDomParser = (() => {
     parseHTML: () => parseHTML
   });
 
+  // src/DomParser.ts
+  init_TextBase();
+  init_Comment();
+
   // src/node/DocumentBase.ts
   init_ParentNodeBase();
   init_Node();
@@ -4718,6 +4884,7 @@ var dooboostoreDomParser = (() => {
         },
         reload: () => {
         },
+        // @ts-ignore
         toString: () => this._location.href
       };
       // Event handlers
@@ -4747,6 +4914,9 @@ var dooboostoreDomParser = (() => {
       this.head = head;
       this.body = body;
     }
+    setLocation(location) {
+      this._location = location;
+    }
     get location() {
       return this._location;
     }
@@ -5004,10 +5174,6 @@ var dooboostoreDomParser = (() => {
     }
   };
 
-  // src/DomParser.ts
-  init_TextBase();
-  init_Comment();
-
   // src/window/WindowBase.ts
   init_NodeBase();
   init_ElementBase();
@@ -5286,10 +5452,14 @@ var dooboostoreDomParser = (() => {
     }
   };
   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;
@@ -5514,11 +5684,13 @@ var dooboostoreDomParser = (() => {
       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;
@@ -5561,6 +5733,9 @@ var dooboostoreDomParser = (() => {
         }
       });
     }
+    get closed() {
+      return this._closed;
+    }
     get location() {
       return this._location;
     }
@@ -5581,6 +5756,103 @@ var dooboostoreDomParser = (() => {
     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;
@@ -5629,23 +5901,38 @@ var dooboostoreDomParser = (() => {
     }
     // 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") {
@@ -5836,43 +6123,65 @@ var dooboostoreDomParser = (() => {
   // 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;
       }