@dooboostore/dom-parser 1.0.0

package/dist/cjs/window/WindowBase.js

@@ -0,0 +1,847 @@
+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 WindowBase_exports = {};
+__export(WindowBase_exports, {
+  WindowBase: () => WindowBase
+});
+module.exports = __toCommonJS(WindowBase_exports);
+var import_DocumentBase = require("../node/DocumentBase");
+var import_NodeBase = require("../node/NodeBase");
+var import_ElementBase = require("../node/elements/ElementBase");
+var import_HTMLAnchorElement = require("../node/elements/HTMLAnchorElement");
+var import_HTMLBodyElement = require("../node/elements/HTMLBodyElement");
+var import_HTMLButtonElement = require("../node/elements/HTMLButtonElement");
+var import_HTMLCanvasElement = require("../node/elements/HTMLCanvasElement");
+var import_HTMLDivElement = require("../node/elements/HTMLDivElement");
+var import_HTMLH1Element = require("../node/elements/HTMLH1Element");
+var import_HTMLHeadElement = require("../node/elements/HTMLHeadElement");
+var import_HTMLHtmlElement = require("../node/elements/HTMLHtmlElement");
+var import_HTMLImgElement = require("../node/elements/HTMLImgElement");
+var import_HTMLInputElement = require("../node/elements/HTMLInputElement");
+var import_HTMLPElement = require("../node/elements/HTMLPElement");
+var import_HTMLSpanElement = require("../node/elements/HTMLSpanElement");
+var import_HTMLTitleElement = require("../node/elements/HTMLTitleElement");
+var import_HTMLLinkElement = require("../node/elements/HTMLLinkElement");
+var import_HTMLScriptElement = require("../node/elements/HTMLScriptElement");
+var import_HTMLStyleElement = require("../node/elements/HTMLStyleElement");
+var import_HTMLFormElement = require("../node/elements/HTMLFormElement");
+var import_HTMLTableElement = require("../node/elements/HTMLTableElement");
+var import_HTMLUListElement = require("../node/elements/HTMLUListElement");
+var import_HTMLOListElement = require("../node/elements/HTMLOListElement");
+var import_HTMLLIElement = require("../node/elements/HTMLLIElement");
+var import_HTMLMetaElement = require("../node/elements/HTMLMetaElement");
+var import_HTMLTemplateElement = require("../node/elements/HTMLTemplateElement");
+var import_HTMLTheadElement = require("../node/elements/HTMLTheadElement");
+var import_HTMLTfootElement = require("../node/elements/HTMLTfootElement");
+var import_HTMLTrElement = require("../node/elements/HTMLTrElement");
+var import_HTMLTdElement = require("../node/elements/HTMLTdElement");
+var import_HTMLThElement = require("../node/elements/HTMLThElement");
+var import_HTMLCaptionElement = require("../node/elements/HTMLCaptionElement");
+var import_HTMLTbodyElement = require("../node/elements/HTMLTbodyElement");
+class LocationBase {
+  constructor(initialUrl = "about:blank", urlChangeCallback) {
+    this._href = "about:blank";
+    this._protocol = "about:";
+    this._host = "";
+    this._hostname = "";
+    this._port = "";
+    this._pathname = "blank";
+    this._search = "";
+    this._hash = "";
+    this._origin = "null";
+    this.urlChangeCallback = urlChangeCallback;
+    this.parseUrl(initialUrl);
+  }
+  get href() {
+    return this._href;
+  }
+  set href(url) {
+    const oldHref = this._href;
+    this.parseUrl(url);
+    if (this._href !== oldHref && this.urlChangeCallback) {
+      this.urlChangeCallback(this._href);
+    }
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  set protocol(value) {
+    if (!value.endsWith(":")) {
+      value += ":";
+    }
+    this._protocol = value;
+    this.reconstructUrl();
+  }
+  get host() {
+    return this._host;
+  }
+  set host(value) {
+    this._host = value;
+    const colonIndex = value.lastIndexOf(":");
+    if (colonIndex !== -1 && colonIndex > value.lastIndexOf("]")) {
+      this._hostname = value.substring(0, colonIndex);
+      this._port = value.substring(colonIndex + 1);
+    } else {
+      this._hostname = value;
+      this._port = "";
+    }
+    this.reconstructUrl();
+  }
+  get hostname() {
+    return this._hostname;
+  }
+  set hostname(value) {
+    this._hostname = value;
+    this._host = this._port ? `${value}:${this._port}` : value;
+    this.reconstructUrl();
+  }
+  get port() {
+    return this._port;
+  }
+  set port(value) {
+    this._port = value;
+    this._host = value ? `${this._hostname}:${value}` : this._hostname;
+    this.reconstructUrl();
+  }
+  get pathname() {
+    return this._pathname;
+  }
+  set pathname(value) {
+    if (!value.startsWith("/")) {
+      value = "/" + value;
+    }
+    this._pathname = value;
+    this.reconstructUrl();
+  }
+  get search() {
+    return this._search;
+  }
+  set search(value) {
+    if (value && !value.startsWith("?")) {
+      value = "?" + value;
+    }
+    this._search = value;
+    this.reconstructUrl();
+  }
+  get hash() {
+    return this._hash;
+  }
+  set hash(value) {
+    if (value && !value.startsWith("#")) {
+      value = "#" + value;
+    }
+    this._hash = value;
+    this.reconstructUrl();
+  }
+  get origin() {
+    return this._origin;
+  }
+  assign(url) {
+    const oldHref = this._href;
+    this.parseUrl(url);
+    if (this._href !== oldHref && this.urlChangeCallback) {
+      this.urlChangeCallback(this._href);
+    }
+  }
+  replace(url) {
+    const oldHref = this._href;
+    this.parseUrl(url);
+    if (this._href !== oldHref && this.urlChangeCallback) {
+      this.urlChangeCallback(this._href);
+    }
+  }
+  reload(forcedReload) {
+  }
+  toString() {
+    return this._href;
+  }
+  parseUrl(url) {
+    try {
+      let parsedUrl;
+      if (url.startsWith("//")) {
+        parsedUrl = new URL(this._protocol + url);
+      } else if (url.startsWith("/")) {
+        parsedUrl = new URL(url, `${this._protocol}//${this._host}`);
+      } else if (url.includes("://")) {
+        parsedUrl = new URL(url);
+      } else {
+        const base = `${this._protocol}//${this._host}${this._pathname}`;
+        parsedUrl = new URL(url, base);
+      }
+      this._href = parsedUrl.href;
+      this._protocol = parsedUrl.protocol;
+      this._host = parsedUrl.host;
+      this._hostname = parsedUrl.hostname;
+      this._port = parsedUrl.port;
+      this._pathname = parsedUrl.pathname;
+      this._search = parsedUrl.search;
+      this._hash = parsedUrl.hash;
+      this._origin = parsedUrl.origin;
+    } catch (e) {
+      if (url === "about:blank") {
+        this._href = "about:blank";
+        this._protocol = "about:";
+        this._host = "";
+        this._hostname = "";
+        this._port = "";
+        this._pathname = "blank";
+        this._search = "";
+        this._hash = "";
+        this._origin = "null";
+      }
+    }
+  }
+  reconstructUrl() {
+    try {
+      let url = this._protocol;
+      if (this._protocol !== "about:" && this._protocol !== "data:") {
+        url += "//";
+        if (this._host) {
+          url += this._host;
+        }
+      }
+      url += this._pathname;
+      url += this._search;
+      url += this._hash;
+      const testUrl = new URL(url);
+      this._href = testUrl.href;
+      this._origin = testUrl.origin;
+    } catch (e) {
+    }
+  }
+}
+class HistoryBase {
+  constructor(window) {
+    this.length = 1;
+    this.state = null;
+    this.historyStack = [];
+    this.currentIndex = -1;
+    this.window = window;
+  }
+  back() {
+    this.go(-1);
+  }
+  forward() {
+    this.go(1);
+  }
+  go(delta) {
+    if (!delta || this.historyStack.length === 0) return;
+    const newIndex = this.currentIndex + delta;
+    if (newIndex >= 0 && newIndex < this.historyStack.length) {
+      this.currentIndex = newIndex;
+      const entry = this.historyStack[this.currentIndex];
+      this.state = entry.state;
+      if (entry.url && this.window.location) {
+        this.window.location._href = entry.url;
+        this.window.location.parseUrl(entry.url);
+      }
+      this.window.dispatchPopStateEvent(entry.state, entry.url);
+    }
+  }
+  pushState(data, title, url) {
+    this.historyStack = this.historyStack.slice(0, this.currentIndex + 1);
+    this.historyStack.push({ state: data, title, url });
+    this.currentIndex = this.historyStack.length - 1;
+    this.state = data;
+    this.length = this.historyStack.length;
+    if (url && this.window.location) {
+      const oldHref = this.window.location._href;
+      this.window.location._href = url;
+      this.window.location.parseUrl(url);
+      if (url !== oldHref && this.window.location.urlChangeCallback) {
+        this.window.location.urlChangeCallback(url);
+      }
+    }
+  }
+  replaceState(data, title, url) {
+    if (this.currentIndex >= 0 && this.currentIndex < this.historyStack.length) {
+      this.historyStack[this.currentIndex] = { state: data, title, url };
+    } else {
+      this.historyStack = [{ state: data, title, url }];
+      this.currentIndex = 0;
+      this.length = 1;
+    }
+    this.state = data;
+    if (url && this.window.location) {
+      const oldHref = this.window.location._href;
+      this.window.location._href = url;
+      this.window.location.parseUrl(url);
+      if (url !== oldHref && this.window.location.urlChangeCallback) {
+        this.window.location.urlChangeCallback(url);
+      }
+    }
+  }
+}
+class NavigatorBase {
+  constructor() {
+    this.userAgent = "Mozilla/5.0 (Server-Side Rendering)";
+    this.language = "en-US";
+    this.languages = ["en-US", "en"];
+    this.platform = "Server";
+    this.cookieEnabled = false;
+    this.onLine = true;
+  }
+}
+class WindowBase {
+  constructor(document, initialUrl) {
+    // Event system
+    this._eventListeners = [];
+    this.closed = false;
+    this.cookieStore = {};
+    this.customElements = {};
+    this.devicePixelRatio = 1;
+    this.event = void 0;
+    this.external = {};
+    this.frameElement = null;
+    this.frames = {};
+    this.innerHeight = 768;
+    this.innerWidth = 1024;
+    this.length = 0;
+    this.locationbar = {};
+    this.menubar = {};
+    this.name = "";
+    this.ondevicemotion = null;
+    this.ondeviceorientation = null;
+    this.ondeviceorientationabsolute = null;
+    this.onorientationchange = null;
+    this.opener = null;
+    this.orientation = 0;
+    this.originAgentCluster = false;
+    this.outerHeight = 768;
+    this.outerWidth = 1024;
+    this.pageXOffset = 0;
+    this.pageYOffset = 0;
+    this.parent = {};
+    this.personalbar = {};
+    this.screen = {};
+    this.screenLeft = 0;
+    this.screenTop = 0;
+    this.screenX = 0;
+    this.screenY = 0;
+    this.scrollX = 0;
+    this.scrollY = 0;
+    this.scrollbars = {};
+    this.self = this;
+    this.speechSynthesis = {};
+    this.status = "";
+    this.statusbar = {};
+    this.toolbar = {};
+    this.top = null;
+    this.visualViewport = null;
+    this.window = this;
+    // Global constructors
+    this.Node = import_NodeBase.NodeBase;
+    this.Element = import_ElementBase.ElementBase;
+    this.HTMLElement = import_ElementBase.ElementBase;
+    this.Event = class Event {
+    };
+    this.PopStateEvent = class PopStateEvent extends this.Event {
+    };
+    this.IntersectionObserver = class IntersectionObserver {
+    };
+    this.NodeFilter = class NodeFilter {
+    };
+    this.DocumentFragment = class DocumentFragment {
+    };
+    this.HTMLMetaElement = import_HTMLMetaElement.HTMLMetaElement;
+    this.HTMLCanvasElement = import_HTMLCanvasElement.HTMLCanvasElement;
+    this.CanvasRenderingContext2D = class CanvasRenderingContext2D {
+    };
+    this.CanvasPattern = class CanvasPattern {
+    };
+    this.CanvasGradient = class CanvasGradient {
+    };
+    this.Path2D = class Path2D {
+    };
+    this.ImageData = class ImageData {
+    };
+    // HTML element constructors
+    this.HTMLAnchorElement = import_HTMLAnchorElement.HTMLAnchorElement;
+    this.HTMLBodyElement = import_HTMLBodyElement.HTMLBodyElement;
+    this.HTMLButtonElement = import_HTMLButtonElement.HTMLButtonElement;
+    this.HTMLDivElement = import_HTMLDivElement.HTMLDivElement;
+    this.HTMLH1Element = import_HTMLH1Element.HTMLH1Element;
+    this.HTMLHeadElement = import_HTMLHeadElement.HTMLHeadElement;
+    this.HTMLHtmlElement = import_HTMLHtmlElement.HTMLHtmlElement;
+    this.HTMLImgElement = import_HTMLImgElement.HTMLImgElement;
+    this.HTMLInputElement = import_HTMLInputElement.HTMLInputElement;
+    this.HTMLPElement = import_HTMLPElement.HTMLPElement;
+    this.HTMLSpanElement = import_HTMLSpanElement.HTMLSpanElement;
+    this.HTMLTitleElement = import_HTMLTitleElement.HTMLTitleElement;
+    this.HTMLLinkElement = import_HTMLLinkElement.HTMLLinkElement;
+    this.HTMLScriptElement = import_HTMLScriptElement.HTMLScriptElement;
+    this.HTMLStyleElement = import_HTMLStyleElement.HTMLStyleElement;
+    this.HTMLFormElement = import_HTMLFormElement.HTMLFormElement;
+    this.HTMLTableElement = import_HTMLTableElement.HTMLTableElement;
+    this.HTMLUListElement = import_HTMLUListElement.HTMLUListElement;
+    this.HTMLOListElement = import_HTMLOListElement.HTMLOListElement;
+    this.HTMLLIElement = import_HTMLLIElement.HTMLLIElement;
+    this.HTMLTemplateElement = import_HTMLTemplateElement.HTMLTemplateElement;
+    this.HTMLTheadElement = import_HTMLTheadElement.HTMLTheadElement;
+    this.HTMLTfootElement = import_HTMLTfootElement.HTMLTfootElement;
+    this.HTMLTrElement = import_HTMLTrElement.HTMLTrElement;
+    this.HTMLTdElement = import_HTMLTdElement.HTMLTdElement;
+    this.HTMLThElement = import_HTMLThElement.HTMLThElement;
+    this.HTMLCaptionElement = import_HTMLCaptionElement.HTMLCaptionElement;
+    this.HTMLTbodyElement = import_HTMLTbodyElement.HTMLTbodyElement;
+    // EventTarget methods (inherited)
+    // These are already covered by addEventListener/removeEventListener/dispatchEvent
+    // GlobalEventHandlers - empty implementations
+    this.onabort = null;
+    this.onanimationcancel = null;
+    this.onanimationend = null;
+    this.onanimationiteration = null;
+    this.onanimationstart = null;
+    this.onauxclick = null;
+    this.onbeforeinput = null;
+    this.onblur = null;
+    this.oncancel = null;
+    this.oncanplay = null;
+    this.oncanplaythrough = null;
+    this.onchange = null;
+    this.onclick = null;
+    this.onclose = null;
+    this.oncontextmenu = null;
+    this.oncopy = null;
+    this.oncuechange = null;
+    this.oncut = null;
+    this.ondblclick = null;
+    this.ondrag = null;
+    this.ondragend = null;
+    this.ondragenter = null;
+    this.ondragleave = null;
+    this.ondragover = null;
+    this.ondragstart = null;
+    this.ondrop = null;
+    this.ondurationchange = null;
+    this.onemptied = null;
+    this.onended = null;
+    this.onerror = null;
+    this.onfocus = null;
+    this.onformdata = null;
+    this.ongotpointercapture = null;
+    this.oninput = null;
+    this.oninvalid = null;
+    this.onkeydown = null;
+    this.onkeypress = null;
+    this.onkeyup = null;
+    this.onload = null;
+    this.onloadeddata = null;
+    this.onloadedmetadata = null;
+    this.onloadstart = null;
+    this.onlostpointercapture = null;
+    this.onmousedown = null;
+    this.onmouseenter = null;
+    this.onmouseleave = null;
+    this.onmousemove = null;
+    this.onmouseout = null;
+    this.onmouseover = null;
+    this.onmouseup = null;
+    this.onpaste = null;
+    this.onpause = null;
+    this.onplay = null;
+    this.onplaying = null;
+    this.onpointercancel = null;
+    this.onpointerdown = null;
+    this.onpointerenter = null;
+    this.onpointerleave = null;
+    this.onpointermove = null;
+    this.onpointerout = null;
+    this.onpointerover = null;
+    this.onpointerup = null;
+    this.onprogress = null;
+    this.onratechange = null;
+    this.onreset = null;
+    this.onresize = null;
+    this.onscroll = null;
+    this.onscrollend = null;
+    this.onsecuritypolicyviolation = null;
+    this.onseeked = null;
+    this.onseeking = null;
+    this.onselect = null;
+    this.onselectionchange = null;
+    this.onselectstart = null;
+    this.onslotchange = null;
+    this.onstalled = null;
+    this.onsubmit = null;
+    this.onsuspend = null;
+    this.ontimeupdate = null;
+    this.ontoggle = null;
+    this.ontouchcancel = null;
+    this.ontouchend = null;
+    this.ontouchmove = null;
+    this.ontouchstart = null;
+    this.ontransitioncancel = null;
+    this.ontransitionend = null;
+    this.ontransitionrun = null;
+    this.ontransitionstart = null;
+    this.onvolumechange = null;
+    this.onwaiting = null;
+    this.onwebkitanimationend = null;
+    this.onwebkitanimationiteration = null;
+    this.onwebkitanimationstart = null;
+    this.onwebkittransitionend = null;
+    this.onwheel = null;
+    // WindowEventHandlers - empty implementations
+    this.onafterprint = null;
+    this.onbeforeprint = null;
+    this.onbeforeunload = null;
+    this.onhashchange = null;
+    this.onlanguagechange = null;
+    this.onmessage = null;
+    this.onmessageerror = null;
+    this.onoffline = null;
+    this.ononline = null;
+    this.onpagehide = null;
+    this.onpageshow = null;
+    this.onpopstate = null;
+    this.onrejectionhandled = null;
+    this.onstorage = null;
+    this.onunhandledrejection = null;
+    this.onunload = null;
+    // WindowLocalStorage
+    this.localStorage = {};
+    // WindowOrWorkerGlobalScope - empty implementations
+    this.caches = {};
+    this.crossOriginIsolated = false;
+    this.crypto = {};
+    this.indexedDB = {};
+    this.isSecureContext = false;
+    this.origin = "null";
+    this.performance = {};
+    // WindowSessionStorage
+    this.sessionStorage = {};
+    this.document = document || new import_DocumentBase.DocumentBase();
+    if (this.document && this.document.setWindow) {
+      this.document.setWindow(this);
+    }
+    this._location = new LocationBase(initialUrl);
+    this.history = new HistoryBase(this);
+    this.navigator = new NavigatorBase();
+    this.clientInformation = this.navigator;
+    return new Proxy(this, {
+      get(target, prop) {
+        if (typeof prop === "string" && /^\d+$/.test(prop)) {
+          return target;
+        }
+        return target[prop];
+      },
+      set(target, prop, value) {
+        if (typeof prop === "string" && /^\d+$/.test(prop)) {
+          return true;
+        }
+        target[prop] = value;
+        return true;
+      },
+      has(target, prop) {
+        if (typeof prop === "string" && /^\d+$/.test(prop)) {
+          return true;
+        }
+        return prop in target;
+      },
+      ownKeys(target) {
+        const keys = Object.getOwnPropertyNames(target);
+        for (let i = 0; i < target.length; i++) {
+          keys.push(i.toString());
+        }
+        return keys;
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        if (typeof prop === "string" && /^\d+$/.test(prop)) {
+          return {
+            enumerable: true,
+            configurable: true,
+            value: target
+          };
+        }
+        return Object.getOwnPropertyDescriptor(target, prop);
+      }
+    });
+  }
+  get location() {
+    return this._location;
+  }
+  set location(href) {
+    if (typeof href === "string") {
+      this._location.href = href;
+    } else {
+      this._location.href = href.href;
+    }
+  }
+  // Window methods - all with empty implementations for server-side
+  alert(message) {
+  }
+  blur() {
+  }
+  cancelIdleCallback(handle) {
+  }
+  captureEvents() {
+  }
+  close() {
+  }
+  confirm(message) {
+    return false;
+  }
+  focus() {
+  }
+  getComputedStyle(elt, pseudoElt) {
+    return {};
+  }
+  getSelection() {
+    return null;
+  }
+  matchMedia(query) {
+    return {};
+  }
+  moveBy(x, y) {
+  }
+  moveTo(x, y) {
+  }
+  open(url, target, features) {
+    return null;
+  }
+  postMessage(message, targetOriginOrOptions, transfer) {
+  }
+  print() {
+  }
+  prompt(message, _default) {
+    return null;
+  }
+  releaseEvents() {
+  }
+  requestIdleCallback(callback, options) {
+    return 0;
+  }
+  resizeBy(x, y) {
+  }
+  resizeTo(width, height) {
+  }
+  scroll(optionsOrX, y) {
+  }
+  scrollBy(optionsOrX, y) {
+  }
+  scrollTo(optionsOrX, y) {
+  }
+  stop() {
+  }
+  // Timer methods
+  setTimeout(callback, delay, ...args) {
+    return setTimeout(callback, delay, ...args);
+  }
+  clearTimeout(id) {
+    clearTimeout(id);
+  }
+  setInterval(callback, delay, ...args) {
+    return setInterval(callback, delay, ...args);
+  }
+  clearInterval(id) {
+    clearInterval(id);
+  }
+  // Animation methods
+  requestAnimationFrame(callback) {
+    return this.setTimeout(callback, 16);
+  }
+  cancelAnimationFrame(id) {
+    this.clearTimeout(id);
+  }
+  addEventListener(type, listener, options) {
+    if (type === "popstate" || type === "load" || type === "unload" || type === "beforeunload") {
+      this._eventListeners.push({
+        type,
+        listener: typeof listener === "function" ? listener : listener.handleEvent,
+        options
+      });
+    }
+  }
+  removeEventListener(type, listener, options) {
+    if (type === "popstate" || type === "load" || type === "unload" || type === "beforeunload") {
+      const targetListener = typeof listener === "function" ? listener : listener.handleEvent;
+      this._eventListeners = this._eventListeners.filter(
+        (eventListener) => !(eventListener.type === type && eventListener.listener === targetListener)
+      );
+    }
+  }
+  dispatchEvent(event) {
+    const eventListeners = this._eventListeners.filter((listener) => listener.type === event.type);
+    for (const eventListener of eventListeners) {
+      try {
+        eventListener.listener.call(this, event);
+        if (eventListener.options && typeof eventListener.options === "object" && eventListener.options.once) {
+          this.removeEventListener(event.type, eventListener.listener);
+        }
+      } catch (error) {
+        console.error("Error in event listener:", error);
+      }
+    }
+    return true;
+  }
+  /**
+   * Dispatch a popstate event to registered listeners
+   */
+  dispatchPopStateEvent(state, url) {
+    const popStateEvent = {
+      type: "popstate",
+      state,
+      url
+    };
+    this.dispatchEvent(popStateEvent);
+  }
+  atob(data) {
+    return "";
+  }
+  btoa(data) {
+    return "";
+  }
+  createImageBitmap(...args) {
+    return Promise.resolve({});
+  }
+  fetch(input, init) {
+    return Promise.resolve({});
+  }
+  queueMicrotask(callback) {
+  }
+  reportError(e) {
+  }
+  structuredClone(value, options) {
+    return value;
+  }
+  /**
+   * Recursive HTML parsing
+   */
+  parseHTMLRecursive(html, parent) {
+    let position = 0;
+    while (position < html.length) {
+      const tagStart = html.indexOf("<", position);
+      if (tagStart === -1) {
+        const remainingText = html.substring(position).trim();
+        if (remainingText) {
+          const textNode = this.document.createTextNode(remainingText);
+          parent.appendChild(textNode);
+        }
+        break;
+      }
+      if (tagStart > position) {
+        const textContent = html.substring(position, tagStart).trim();
+        if (textContent) {
+          const textNode = this.document.createTextNode(textContent);
+          parent.appendChild(textNode);
+        }
+      }
+      const tagEnd = html.indexOf(">", tagStart);
+      if (tagEnd === -1) break;
+      const tagContent = html.substring(tagStart + 1, tagEnd);
+      if (tagContent.startsWith("/")) {
+        position = tagEnd + 1;
+        break;
+      }
+      const isSelfClosing = tagContent.endsWith("/") || this.isSelfClosingTag(tagContent.split(/\s+/)[0]);
+      const spaceIndex = tagContent.indexOf(" ");
+      const tagName = spaceIndex === -1 ? tagContent.replace("/", "") : tagContent.substring(0, spaceIndex);
+      const attributes = spaceIndex === -1 ? "" : tagContent.substring(spaceIndex + 1).replace("/", "");
+      const element = this.document.createElement(tagName.toLowerCase());
+      if (attributes.trim()) {
+        this.parseAttributes(attributes, element);
+      }
+      if (tagName.toLowerCase() === "html") {
+        this.document.documentElement = element;
+        this.document.appendChild(element);
+      } else if (tagName.toLowerCase() === "head") {
+        this.document.head = element;
+        if (this.document.documentElement) {
+          this.document.documentElement.appendChild(element);
+        } else {
+          parent.appendChild(element);
+        }
+      } else if (tagName.toLowerCase() === "body") {
+        this.document.body = element;
+        if (this.document.documentElement) {
+          this.document.documentElement.appendChild(element);
+        } else {
+          parent.appendChild(element);
+        }
+      } else {
+        parent.appendChild(element);
+      }
+      if (isSelfClosing) {
+        position = tagEnd + 1;
+      } else {
+        const closingTag = `</${tagName}>`;
+        const closingTagIndex = this.findMatchingClosingTag(html, tagEnd + 1, tagName);
+        if (closingTagIndex !== -1) {
+          const innerContent = html.substring(tagEnd + 1, closingTagIndex);
+          if (innerContent.trim()) {
+            this.parseHTMLRecursive(innerContent, element);
+          }
+          position = closingTagIndex + closingTag.length;
+        } else {
+          position = tagEnd + 1;
+        }
+      }
+    }
+  }
+  findMatchingClosingTag(html, startPos, tagName) {
+    const openTag = `<${tagName}`;
+    const closeTag = `</${tagName}>`;
+    let depth = 1;
+    let pos = startPos;
+    while (pos < html.length && depth > 0) {
+      const nextOpen = html.indexOf(openTag, pos);
+      const nextClose = html.indexOf(closeTag, pos);
+      if (nextClose === -1) return -1;
+      if (nextOpen !== -1 && nextOpen < nextClose) {
+        depth++;
+        pos = nextOpen + openTag.length;
+      } else {
+        depth--;
+        if (depth === 0) return nextClose;
+        pos = nextClose + closeTag.length;
+      }
+    }
+    return -1;
+  }
+  parseAttributes(attributeString, element) {
+    const attrRegex = /([\w:-]+)(?:\s*=\s*(['"])(.*?)\2)?/g;
+    let match;
+    while ((match = attrRegex.exec(attributeString)) !== null) {
+      const name = match[1];
+      let value = match[3] || "";
+      element.setAttribute(name, value);
+    }
+  }
+  isSelfClosingTag(tagName) {
+    const selfClosingTags = ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"];
+    return selfClosingTags.includes(tagName.toLowerCase());
+  }
+  /**
+   * Clear current document content
+   */
+  clearDocumentContent() {
+    const doc = this.document;
+    if (doc.head) {
+      while (doc.head.firstChild) {
+        doc.head.removeChild(doc.head.firstChild);
+      }
+    }
+    if (doc.body) {
+      while (doc.body.firstChild) {
+        doc.body.removeChild(doc.body.firstChild);
+      }
+    }
+  }
+}
+//# sourceMappingURL=WindowBase.js.map