@geektech/tsone 0.0.2 → 0.2.1

package/dist/dom/index.js

@@ -0,0 +1,2181 @@
+// lib/dom/index.ts
+var DomNodeType;
+((DomNodeType2) => {
+  DomNodeType2[DomNodeType2["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+  DomNodeType2[DomNodeType2["TEXT_NODE"] = 3] = "TEXT_NODE";
+  DomNodeType2[DomNodeType2["COMMENT_NODE"] = 8] = "COMMENT_NODE";
+  DomNodeType2[DomNodeType2["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
+  DomNodeType2[DomNodeType2["DOCUMENT_FRAGMENT_NODE"] = 11] = "DOCUMENT_FRAGMENT_NODE";
+})(DomNodeType ||= {});
+
+class DOMException extends Error {
+  code;
+  constructor(message, name = "Error") {
+    super(message);
+    this.name = name;
+    this.code = 0;
+  }
+}
+
+class EventTarget {
+  listenerMap = new Map;
+  addEventListener(type, listener, options) {
+    if (!listener) {
+      return;
+    }
+    const capture = typeof options === "boolean" ? options : options?.capture ?? false;
+    const once = typeof options === "object" ? options.once ?? false : false;
+    const passive = typeof options === "object" ? options.passive ?? false : false;
+    let entries = this.listenerMap.get(type);
+    if (!entries) {
+      entries = [];
+      this.listenerMap.set(type, entries);
+    }
+    if (entries.some((entry) => entry.listener === listener && entry.capture === capture)) {
+      return;
+    }
+    entries.push({ listener, capture, once, passive });
+  }
+  removeEventListener(type, listener, options) {
+    if (!listener) {
+      return;
+    }
+    const capture = typeof options === "boolean" ? options : options?.capture ?? false;
+    const entries = this.listenerMap.get(type);
+    if (!entries) {
+      return;
+    }
+    const index = entries.findIndex((entry) => entry.listener === listener && entry.capture === capture);
+    if (index >= 0) {
+      entries.splice(index, 1);
+    }
+    if (entries.length === 0) {
+      this.listenerMap.delete(type);
+    }
+  }
+  dispatchEvent(event) {
+    if (!(event instanceof Event)) {
+      throw new TypeError("dispatchEvent requires an Event instance");
+    }
+    if (event.dispatched) {
+      throw new Error("Event has already been dispatched");
+    }
+    return dispatchOnTarget(this, event);
+  }
+  getListeners(type) {
+    return this.listenerMap.get(type) ?? [];
+  }
+}
+
+class Event {
+  static NONE = 0;
+  static CAPTURING_PHASE = 1;
+  static AT_TARGET = 2;
+  static BUBBLING_PHASE = 3;
+  type;
+  bubbles;
+  cancelable;
+  composed;
+  target = null;
+  currentTarget = null;
+  eventPhase = Event.NONE;
+  defaultPrevented = false;
+  isTrusted = false;
+  timeStamp;
+  cancelBubble = false;
+  dispatched = false;
+  propagationStopped = false;
+  immediateStopped = false;
+  canceled = false;
+  constructor(type, init) {
+    this.type = type;
+    this.bubbles = init?.bubbles ?? false;
+    this.cancelable = init?.cancelable ?? false;
+    this.composed = init?.composed ?? false;
+    this.timeStamp = Date.now();
+  }
+  preventDefault() {
+    if (this.cancelable) {
+      this.canceled = true;
+    }
+  }
+  stopPropagation() {
+    this.propagationStopped = true;
+    this.cancelBubble = true;
+  }
+  stopImmediatePropagation() {
+    this.propagationStopped = true;
+    this.immediateStopped = true;
+    this.cancelBubble = true;
+  }
+  propagationPrevented() {
+    return this.propagationStopped;
+  }
+  immediatePrevented() {
+    return this.immediateStopped;
+  }
+  wasCanceled() {
+    return this.canceled;
+  }
+}
+
+class CustomEvent extends Event {
+  detail;
+  constructor(type, init) {
+    super(type, init);
+    this.detail = init?.detail;
+  }
+}
+
+class MouseEvent extends Event {
+  clientX;
+  clientY;
+  button;
+  buttons;
+  relatedTarget;
+  constructor(type, init) {
+    super(type, init);
+    this.clientX = init?.clientX ?? 0;
+    this.clientY = init?.clientY ?? 0;
+    this.button = init?.button ?? 0;
+    this.buttons = init?.buttons ?? 0;
+    this.relatedTarget = init?.relatedTarget ?? null;
+  }
+}
+
+class KeyboardEvent extends Event {
+  key;
+  code;
+  constructor(type, init) {
+    super(type, init);
+    this.key = init?.key ?? "";
+    this.code = init?.code ?? "";
+  }
+}
+function invokeListener(listener, event) {
+  const record = listener.listener;
+  if (typeof record === "function") {
+    record.call(event.currentTarget, event);
+  } else {
+    record.handleEvent(event);
+  }
+}
+function dispatchOnTarget(target, event) {
+  event.dispatched = true;
+  event.target = target;
+  const chain = buildEventPath(target);
+  const capturePath = [...chain].reverse();
+  const targetIndex = capturePath.length - 1;
+  event.eventPhase = Event.CAPTURING_PHASE;
+  for (let index = 0;index < targetIndex; index += 1) {
+    const current = capturePath[index];
+    if (event.propagationPrevented()) {
+      break;
+    }
+    event.currentTarget = current;
+    runListeners(current, event, true);
+  }
+  if (!event.propagationPrevented()) {
+    event.eventPhase = Event.AT_TARGET;
+    event.currentTarget = target;
+    runListeners(target, event, true);
+    if (!event.immediatePrevented()) {
+      runListeners(target, event, false);
+    }
+  }
+  if (event.bubbles && !event.propagationPrevented()) {
+    event.eventPhase = Event.BUBBLING_PHASE;
+    for (let index = capturePath.length - 2;index >= 0; index -= 1) {
+      const current = capturePath[index];
+      if (event.propagationPrevented()) {
+        break;
+      }
+      event.currentTarget = current;
+      runListeners(current, event, false);
+    }
+  }
+  event.eventPhase = Event.NONE;
+  event.currentTarget = null;
+  return !event.wasCanceled();
+}
+function runListeners(target, event, capture) {
+  const listeners = target.getListeners(event.type);
+  for (const entry of [...listeners]) {
+    if (entry.capture !== capture) {
+      continue;
+    }
+    if (event.immediatePrevented()) {
+      break;
+    }
+    if (entry.once) {
+      target.removeEventListener(event.type, entry.listener, {
+        capture: entry.capture
+      });
+    }
+    invokeListener(entry, event);
+  }
+}
+function buildEventPath(target) {
+  const path = [];
+  let current = target;
+  while (current) {
+    path.push(current);
+    const node = current;
+    if (node.nodeType === 9 /* DOCUMENT_NODE */) {
+      const view = node.defaultView;
+      if (view) {
+        path.push(view);
+      }
+      break;
+    }
+    const parent = node.parentNode;
+    if (parent) {
+      current = parent;
+      continue;
+    }
+    break;
+  }
+  return path;
+}
+
+class DOMTokenList {
+  element;
+  attributeName;
+  constructor(element, attributeName = "class") {
+    this.element = element;
+    this.attributeName = attributeName;
+  }
+  get length() {
+    return this.tokens().length;
+  }
+  get value() {
+    return this.element.getAttribute(this.attributeName) ?? "";
+  }
+  set value(value) {
+    this.setTokens(splitTokens(value));
+  }
+  item(index) {
+    return this.tokens()[index] ?? null;
+  }
+  contains(token) {
+    return this.tokens().includes(token);
+  }
+  add(...tokens) {
+    const current = new Set(this.tokens());
+    for (const token of tokens) {
+      if (token) {
+        current.add(token);
+      }
+    }
+    this.setTokens([...current]);
+  }
+  remove(...tokens) {
+    const current = new Set(this.tokens());
+    for (const token of tokens) {
+      current.delete(token);
+    }
+    this.setTokens([...current]);
+  }
+  toggle(token, force) {
+    const current = new Set(this.tokens());
+    const shouldAdd = force ?? !current.has(token);
+    if (shouldAdd) {
+      current.add(token);
+    } else {
+      current.delete(token);
+    }
+    this.setTokens([...current]);
+    return shouldAdd;
+  }
+  replace(oldToken, newToken) {
+    const current = this.tokens();
+    const index = current.indexOf(oldToken);
+    if (index < 0) {
+      return false;
+    }
+    current[index] = newToken;
+    this.setTokens(current);
+    return true;
+  }
+  [Symbol.iterator]() {
+    return this.tokens()[Symbol.iterator]();
+  }
+  forEach(callback) {
+    this.tokens().forEach((value, index) => callback(value, index, this));
+  }
+  toString() {
+    return this.value;
+  }
+  tokens() {
+    return splitTokens(this.element.getAttribute(this.attributeName) ?? "");
+  }
+  setTokens(tokens) {
+    const value = tokens.filter(Boolean).join(" ");
+    if (value) {
+      this.element.setAttribute(this.attributeName, value);
+    } else {
+      this.element.removeAttribute(this.attributeName);
+    }
+  }
+}
+function splitTokens(value) {
+  return value.trim().split(/\s+/).filter(Boolean);
+}
+function normalizeCssProperty(property) {
+  return property.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+function createStyleDeclaration() {
+  const properties = new Map;
+  const target = {
+    properties,
+    setProperty(property, value, priority = "") {
+      const name = normalizeCssProperty(property);
+      if (value === "") {
+        properties.delete(name);
+      } else {
+        properties.set(name, { value, priority });
+      }
+    },
+    getPropertyValue(property) {
+      return properties.get(normalizeCssProperty(property))?.value ?? "";
+    },
+    getPropertyPriority(property) {
+      return properties.get(normalizeCssProperty(property))?.priority ?? "";
+    },
+    removeProperty(property) {
+      const name = normalizeCssProperty(property);
+      const previous = properties.get(name)?.value ?? "";
+      properties.delete(name);
+      return previous;
+    },
+    item(index) {
+      return [...properties.keys()][index] ?? "";
+    },
+    get length() {
+      return properties.size;
+    },
+    get cssText() {
+      return [...properties.entries()].map(([name, entry]) => `${name}: ${entry.value}${entry.priority ? ` ${entry.priority}` : ""};`).join(" ");
+    },
+    set cssText(value) {
+      properties.clear();
+      for (const declaration of value.split(";")) {
+        const trimmed = declaration.trim();
+        if (!trimmed) {
+          continue;
+        }
+        const separator = trimmed.indexOf(":");
+        if (separator < 0) {
+          continue;
+        }
+        const name = trimmed.slice(0, separator).trim();
+        const propertyValue = trimmed.slice(separator + 1).trim();
+        if (name) {
+          target.setProperty(name, propertyValue);
+        }
+      }
+    }
+  };
+  const handler = {
+    get(t, property, receiver) {
+      if (typeof property === "symbol") {
+        return Reflect.get(t, property, receiver);
+      }
+      if (property in t) {
+        const value = Reflect.get(t, property, receiver);
+        return typeof value === "function" ? value.bind(t) : value;
+      }
+      return t.getPropertyValue(property);
+    },
+    set(t, property, value, receiver) {
+      if (typeof property === "symbol") {
+        return Reflect.set(t, property, value, receiver);
+      }
+      if (property in t) {
+        return Reflect.set(t, property, value, receiver);
+      }
+      t.setProperty(property, String(value));
+      return true;
+    },
+    has(t, property) {
+      if (typeof property === "symbol") {
+        return Reflect.has(t, property);
+      }
+      if (property in t) {
+        return true;
+      }
+      return t.getPropertyValue(property) !== "";
+    },
+    ownKeys() {
+      return [
+        ...Reflect.ownKeys(target),
+        ...[...properties.keys()].map((name) => camelCaseProperty(name))
+      ];
+    },
+    getOwnPropertyDescriptor(t, property) {
+      if (typeof property === "symbol") {
+        return Reflect.getOwnPropertyDescriptor(t, property);
+      }
+      if (property in t) {
+        return Reflect.getOwnPropertyDescriptor(t, property);
+      }
+      const value = t.getPropertyValue(property);
+      if (value !== "") {
+        return { configurable: true, enumerable: true, writable: true, value };
+      }
+      return;
+    }
+  };
+  return new Proxy(target, handler);
+}
+function camelCaseProperty(property) {
+  return property.replace(/-([a-z])/g, (_match, char) => char.toUpperCase());
+}
+
+class NodeList {
+  items;
+  constructor(items = []) {
+    this.items = items;
+    for (let index = 0;index < items.length; index += 1) {
+      Object.defineProperty(this, String(index), {
+        configurable: true,
+        enumerable: true,
+        get: () => this.items[index]
+      });
+    }
+  }
+  get length() {
+    return this.items.length;
+  }
+  item(index) {
+    return this.items[index] ?? null;
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  forEach(callback) {
+    this.items.forEach((value, index) => callback(value, index, this));
+  }
+  entries() {
+    return this.items.entries();
+  }
+  keys() {
+    return this.items.keys();
+  }
+  values() {
+    return this.items.values();
+  }
+  toArray() {
+    return [...this.items];
+  }
+}
+
+class Node extends EventTarget {
+  static ELEMENT_NODE = 1 /* ELEMENT_NODE */;
+  static TEXT_NODE = 3 /* TEXT_NODE */;
+  static COMMENT_NODE = 8 /* COMMENT_NODE */;
+  static DOCUMENT_NODE = 9 /* DOCUMENT_NODE */;
+  static DOCUMENT_FRAGMENT_NODE = 11 /* DOCUMENT_FRAGMENT_NODE */;
+  nodeType;
+  nodeName;
+  parentNode = null;
+  ownerDocument = null;
+  childList = [];
+  constructor(nodeType, nodeName) {
+    super();
+    this.nodeType = nodeType;
+    this.nodeName = nodeName;
+  }
+  get parentElement() {
+    const parent = this.parentNode;
+    return parent instanceof Element ? parent : null;
+  }
+  get childNodes() {
+    return new NodeList([...this.childList]);
+  }
+  get firstChild() {
+    return this.childList[0] ?? null;
+  }
+  get lastChild() {
+    return this.childList[this.childList.length - 1] ?? null;
+  }
+  get nextSibling() {
+    const parent = this.parentNode;
+    if (!parent) {
+      return null;
+    }
+    const index = parent.childList.indexOf(this);
+    return index >= 0 ? parent.childList[index + 1] ?? null : null;
+  }
+  get previousSibling() {
+    const parent = this.parentNode;
+    if (!parent) {
+      return null;
+    }
+    const index = parent.childList.indexOf(this);
+    return index > 0 ? parent.childList[index - 1] : null;
+  }
+  get textContent() {
+    let text = "";
+    for (const child of this.childList) {
+      if (child.nodeType === 3 /* TEXT_NODE */) {
+        text += child.data;
+      } else if (child.nodeType === 1 /* ELEMENT_NODE */) {
+        text += child.textContent;
+      }
+    }
+    return text;
+  }
+  set textContent(value) {
+    this.childList = [];
+    if (value) {
+      const textNode = new Text(value);
+      textNode.ownerDocument = this.ownerDocument;
+      textNode.parentNode = this;
+      this.childList.push(textNode);
+    }
+  }
+  hasChildNodes() {
+    return this.childList.length > 0;
+  }
+  appendChild(node) {
+    if (node === this) {
+      throw new Error("Cannot append a node to itself");
+    }
+    this.insertBefore(node, null);
+    return node;
+  }
+  insertBefore(node, reference) {
+    if (node === this) {
+      throw new Error("Cannot insert a node before itself");
+    }
+    if (node.parentNode) {
+      node.parentNode.removeChild(node);
+    }
+    node.parentNode = this;
+    if (node.ownerDocument === null) {
+      node.ownerDocument = this.ownerDocument;
+    }
+    if (reference === null) {
+      this.childList.push(node);
+      return node;
+    }
+    const index = this.childList.indexOf(reference);
+    if (index < 0) {
+      throw new Error("Reference node is not a child of this node");
+    }
+    this.childList.splice(index, 0, node);
+    return node;
+  }
+  removeChild(node) {
+    const index = this.childList.indexOf(node);
+    if (index < 0) {
+      throw new Error("Node is not a child of this node");
+    }
+    this.childList.splice(index, 1);
+    node.parentNode = null;
+    return node;
+  }
+  replaceChild(newChild, oldChild) {
+    const index = this.childList.indexOf(oldChild);
+    if (index < 0) {
+      throw new Error("Old child is not a child of this node");
+    }
+    if (newChild.parentNode) {
+      newChild.parentNode.removeChild(newChild);
+    }
+    newChild.parentNode = this;
+    if (newChild.ownerDocument === null) {
+      newChild.ownerDocument = this.ownerDocument;
+    }
+    this.childList[index] = newChild;
+    oldChild.parentNode = null;
+    return newChild;
+  }
+  replaceChildren(...nodes) {
+    for (const child of [...this.childList]) {
+      this.removeChild(child);
+    }
+    for (const node of nodes) {
+      this.appendChild(node);
+    }
+  }
+  contains(node) {
+    if (!node) {
+      return false;
+    }
+    let current = node;
+    while (current) {
+      if (current === this) {
+        return true;
+      }
+      current = current.parentNode;
+    }
+    return false;
+  }
+  remove() {
+    this.parentNode?.removeChild(this);
+  }
+  cloneNode(deep = false) {
+    const clone = this.createClone();
+    if (deep) {
+      for (const child of this.childList) {
+        clone.appendChild(child.cloneNode(true));
+      }
+    }
+    return clone;
+  }
+  createClone() {
+    const clone = new Node(this.nodeType, this.nodeName);
+    clone.ownerDocument = this.ownerDocument;
+    return clone;
+  }
+  getRootNode() {
+    if (!this.parentNode) {
+      return this;
+    }
+    let parent = this.parentNode;
+    while (parent.parentNode) {
+      parent = parent.parentNode;
+    }
+    return parent;
+  }
+  isConnected() {
+    return this.getRootNode().nodeType === 9 /* DOCUMENT_NODE */;
+  }
+}
+
+class Element extends Node {
+  namespaceURI;
+  attributeList = [];
+  styleValue;
+  classListValue;
+  datasetProxy;
+  constructor(tagName, namespaceURI = null) {
+    super(1 /* ELEMENT_NODE */, tagName.toUpperCase());
+    this.namespaceURI = namespaceURI;
+  }
+  get tagName() {
+    return this.nodeName;
+  }
+  get localName() {
+    return this.nodeName.toLowerCase();
+  }
+  get id() {
+    return this.getAttribute("id") ?? "";
+  }
+  set id(value) {
+    this.setAttribute("id", value);
+  }
+  get className() {
+    return this.getAttribute("class") ?? "";
+  }
+  set className(value) {
+    this.setAttribute("class", value);
+  }
+  get classList() {
+    if (!this.classListValue) {
+      this.classListValue = new DOMTokenList(this, "class");
+    }
+    return this.classListValue;
+  }
+  get style() {
+    if (!this.styleValue) {
+      this.styleValue = createStyleDeclaration();
+    }
+    return this.styleValue;
+  }
+  get dataset() {
+    if (!this.datasetProxy) {
+      this.datasetProxy = createDatasetProxy(this);
+    }
+    return this.datasetProxy;
+  }
+  get children() {
+    return new NodeList(this.childList.filter((child) => child.nodeType === 1 /* ELEMENT_NODE */));
+  }
+  get firstElementChild() {
+    return this.children.item(0);
+  }
+  get lastElementChild() {
+    return this.children.item(this.children.length - 1);
+  }
+  get childElementCount() {
+    return this.children.length;
+  }
+  get attributes() {
+    return new NamedNodeMap(this);
+  }
+  getAttribute(name) {
+    const entry = this.findAttribute(name);
+    return entry ? entry.value : null;
+  }
+  getAttributeNames() {
+    return this.attributeList.map((entry) => entry.name);
+  }
+  setAttribute(name, value) {
+    const stringValue = String(value);
+    if (name === "style") {
+      this.styleValue = createStyleDeclaration();
+      this.styleValue.cssText = stringValue;
+    }
+    const entry = this.findAttribute(name);
+    if (entry) {
+      entry.value = stringValue;
+    } else {
+      this.attributeList.push({ name, value: stringValue });
+    }
+  }
+  removeAttribute(name) {
+    if (name === "style") {
+      this.styleValue = createStyleDeclaration();
+    }
+    const index = this.attributeList.findIndex((entry) => entry.name === name);
+    if (index >= 0) {
+      this.attributeList.splice(index, 1);
+    }
+  }
+  hasAttribute(name) {
+    return this.findAttribute(name) !== undefined;
+  }
+  toggleAttribute(name, force) {
+    const shouldAdd = force ?? !this.hasAttribute(name);
+    if (shouldAdd) {
+      this.setAttribute(name, "");
+    } else {
+      this.removeAttribute(name);
+    }
+    return shouldAdd;
+  }
+  hasAttributes() {
+    return this.attributeList.length > 0;
+  }
+  get innerHTML() {
+    return serializeChildren(this);
+  }
+  set innerHTML(value) {
+    this.replaceChildren(...parseHtmlFragment(value, this.ownerDocument));
+  }
+  get outerHTML() {
+    return serializeNode(this);
+  }
+  get value() {
+    return this.getAttribute("value") ?? "";
+  }
+  set value(value) {
+    this.setAttribute("value", value);
+  }
+  querySelector(selector) {
+    return querySelectorAll(this, selector).item(0);
+  }
+  querySelectorAll(selector) {
+    return querySelectorAll(this, selector);
+  }
+  getElementsByTagName(tagName) {
+    const lowered = tagName.toLowerCase();
+    const results = [];
+    collectElements(this, (element) => {
+      if (element.localName === lowered) {
+        results.push(element);
+      }
+    });
+    return new NodeList(results);
+  }
+  matches(selector) {
+    return matchSelector(this, selector);
+  }
+  closest(selector) {
+    if (this.matches(selector)) {
+      return this;
+    }
+    let parent = this.parentElement;
+    while (parent) {
+      if (parent.matches(selector)) {
+        return parent;
+      }
+      parent = parent.parentElement;
+    }
+    return null;
+  }
+  getBoundingClientRect() {
+    return {
+      x: 0,
+      y: 0,
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0,
+      width: 0,
+      height: 0,
+      toJSON() {
+        return {
+          x: 0,
+          y: 0,
+          top: 0,
+          left: 0,
+          right: 0,
+          bottom: 0,
+          width: 0,
+          height: 0
+        };
+      }
+    };
+  }
+  scrollIntoView() {}
+  focus() {}
+  blur() {}
+  click() {
+    this.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+  }
+  append(...nodes) {
+    for (const node of nodes) {
+      if (typeof node === "string") {
+        const textNode = new Text(node);
+        textNode.ownerDocument = this.ownerDocument;
+        this.appendChild(textNode);
+      } else {
+        this.appendChild(node);
+      }
+    }
+  }
+  prepend(...nodes) {
+    const reference = this.firstChild;
+    for (const node of nodes) {
+      if (typeof node === "string") {
+        const textNode = new Text(node);
+        textNode.ownerDocument = this.ownerDocument;
+        this.insertBefore(textNode, reference);
+      } else {
+        this.insertBefore(node, reference);
+      }
+    }
+  }
+  before(...nodes) {
+    const parent = this.parentNode;
+    if (!parent) {
+      return;
+    }
+    for (const node of nodes) {
+      if (typeof node === "string") {
+        const textNode = new Text(node);
+        textNode.ownerDocument = this.ownerDocument;
+        parent.insertBefore(textNode, this);
+      } else {
+        parent.insertBefore(node, this);
+      }
+    }
+  }
+  after(...nodes) {
+    const parent = this.parentNode;
+    if (!parent) {
+      return;
+    }
+    const reference = this.nextSibling;
+    for (const node of nodes) {
+      if (typeof node === "string") {
+        const textNode = new Text(node);
+        textNode.ownerDocument = this.ownerDocument;
+        parent.insertBefore(textNode, reference);
+      } else {
+        parent.insertBefore(node, reference);
+      }
+    }
+  }
+  replaceWith(...nodes) {
+    const parent = this.parentNode;
+    if (!parent) {
+      return;
+    }
+    const reference = this.nextSibling;
+    parent.removeChild(this);
+    for (const node of nodes) {
+      if (typeof node === "string") {
+        const textNode = new Text(node);
+        textNode.ownerDocument = this.ownerDocument;
+        parent.insertBefore(textNode, reference);
+      } else {
+        parent.insertBefore(node, reference);
+      }
+    }
+  }
+  setAttributeNS(_namespace, name, value) {
+    this.setAttribute(name, value);
+  }
+  removeAttributeNS(_namespace, name) {
+    this.removeAttribute(name);
+  }
+  hasAttributeNS(_namespace, name) {
+    return this.hasAttribute(name);
+  }
+  getAttributeNS(_namespace, name) {
+    return this.getAttribute(name);
+  }
+  findAttribute(name) {
+    return this.attributeList.find((entry) => entry.name === name);
+  }
+  attributeEntries() {
+    return [...this.attributeList];
+  }
+  inlineStyleText() {
+    return this.styleValue?.cssText ?? "";
+  }
+  createClone() {
+    const clone = createElementForTag(this.localName, this.ownerDocument);
+    for (const entry of this.attributeList) {
+      clone.setAttribute(entry.name, entry.value);
+    }
+    return clone;
+  }
+}
+
+class HTMLElement extends Element {
+  constructor(tagName) {
+    super(tagName);
+  }
+}
+
+class NamedNodeMap {
+  element;
+  constructor(element) {
+    this.element = element;
+    for (let index = 0;index < element.attributeEntries().length; index += 1) {
+      Object.defineProperty(this, String(index), {
+        configurable: true,
+        enumerable: true,
+        get: () => this.element.attributeEntries()[index] ?? null
+      });
+    }
+  }
+  get length() {
+    return this.element.attributeEntries().length;
+  }
+  item(index) {
+    return this.element.attributeEntries()[index] ?? null;
+  }
+  getNamedItem(name) {
+    return this.element.findAttribute(name) ?? null;
+  }
+  setNamedItem(attr) {
+    this.element.setAttribute(attr.name, attr.value);
+  }
+  removeNamedItem(name) {
+    this.element.removeAttribute(name);
+  }
+  [Symbol.iterator]() {
+    return this.element.attributeEntries()[Symbol.iterator]();
+  }
+}
+
+class HTMLOptionElement extends HTMLElement {
+  selectedValue;
+  constructor(tagName = "option") {
+    super(tagName);
+  }
+  get value() {
+    return this.getAttribute("value") ?? this.textContent;
+  }
+  set value(value) {
+    this.setAttribute("value", value);
+  }
+  get text() {
+    return this.textContent;
+  }
+  get label() {
+    return this.getAttribute("label") ?? this.textContent;
+  }
+  get selected() {
+    return this.hasSelectedValue();
+  }
+  set selected(value) {
+    this.setSelectedRaw(value);
+    if (value) {
+      const select = this.parentElement;
+      if (select instanceof HTMLSelectElement && !select.multiple) {
+        for (const option of select.options.toArray()) {
+          if (option !== this) {
+            option.setSelectedRaw(false);
+          }
+        }
+      }
+    }
+  }
+  setSelectedRaw(value) {
+    this.selectedValue = value;
+    if (value) {
+      this.setAttribute("selected", "");
+    } else {
+      this.removeAttribute("selected");
+    }
+  }
+  hasSelectedValue() {
+    if (this.selectedValue !== undefined) {
+      return this.selectedValue;
+    }
+    return this.hasAttribute("selected");
+  }
+}
+
+class HTMLSelectElement extends HTMLElement {
+  constructor(tagName = "select") {
+    super(tagName);
+  }
+  get multiple() {
+    return this.hasAttribute("multiple");
+  }
+  set multiple(value) {
+    if (value) {
+      this.setAttribute("multiple", "");
+    } else {
+      this.removeAttribute("multiple");
+    }
+  }
+  get options() {
+    const options = [];
+    collectElements(this, (element) => {
+      if (element instanceof HTMLOptionElement) {
+        options.push(element);
+      }
+    });
+    return new HTMLOptionsCollection(options);
+  }
+  get selectedOptions() {
+    return new NodeList(this.options.toArray().filter((option) => option.hasSelectedValue()));
+  }
+  get selectedIndex() {
+    return this.options.toArray().findIndex((option) => option.hasSelectedValue());
+  }
+  set selectedIndex(index) {
+    const options = this.options.toArray();
+    options.forEach((option, optionIndex) => option.setSelectedRaw(optionIndex === index));
+  }
+  get value() {
+    const options = this.options.toArray();
+    const selected = options.find((option) => option.hasSelectedValue());
+    if (selected) {
+      return selected.value;
+    }
+    if (!this.multiple && options.length > 0) {
+      return options[0].value;
+    }
+    return "";
+  }
+  set value(value) {
+    const options = this.options.toArray();
+    for (const option of options) {
+      const shouldSelect = option.value === value;
+      if (shouldSelect) {
+        if (this.multiple) {
+          option.setSelectedRaw(true);
+        } else {
+          for (const other of options) {
+            other.setSelectedRaw(other === option);
+          }
+          return;
+        }
+      }
+    }
+  }
+  add(option) {
+    this.appendChild(option);
+  }
+  removeOption(index) {
+    const options = this.options.toArray();
+    const option = options[index];
+    if (option) {
+      option.remove();
+    }
+  }
+}
+
+class HTMLOptionsCollection {
+  items;
+  constructor(items) {
+    this.items = items;
+    for (let index = 0;index < items.length; index += 1) {
+      Object.defineProperty(this, String(index), {
+        configurable: true,
+        enumerable: true,
+        get: () => this.items[index]
+      });
+    }
+  }
+  get length() {
+    return this.items.length;
+  }
+  item(index) {
+    return this.items[index] ?? null;
+  }
+  get value() {
+    return this.items.find((option) => option.hasSelectedValue())?.value ?? "";
+  }
+  get selectedIndex() {
+    return this.items.findIndex((option) => option.hasSelectedValue());
+  }
+  toArray() {
+    return [...this.items];
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+}
+
+class HTMLInputElement extends HTMLElement {
+  inputValue;
+  checkedValue;
+  constructor(tagName = "input") {
+    super(tagName);
+  }
+  get type() {
+    return this.getAttribute("type") ?? "text";
+  }
+  set type(value) {
+    this.setAttribute("type", value);
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set name(value) {
+    this.setAttribute("name", value);
+  }
+  get value() {
+    return this.inputValue ?? this.getAttribute("value") ?? "";
+  }
+  set value(value) {
+    this.inputValue = value;
+  }
+  get defaultValue() {
+    return this.getAttribute("value") ?? "";
+  }
+  get checked() {
+    return this.checkedValue ?? this.hasAttribute("checked");
+  }
+  set checked(value) {
+    this.checkedValue = value;
+  }
+  get disabled() {
+    return this.hasAttribute("disabled");
+  }
+  set disabled(value) {
+    if (value) {
+      this.setAttribute("disabled", "");
+    } else {
+      this.removeAttribute("disabled");
+    }
+  }
+  createClone() {
+    const clone = super.createClone();
+    clone.inputValue = this.inputValue;
+    clone.checkedValue = this.checkedValue;
+    return clone;
+  }
+}
+
+class HTMLTextAreaElement extends HTMLElement {
+  textareaValue;
+  constructor(tagName = "textarea") {
+    super(tagName);
+  }
+  get value() {
+    return this.textareaValue ?? this.textContent;
+  }
+  set value(value) {
+    this.textareaValue = value;
+  }
+}
+
+class HTMLButtonElement extends HTMLElement {
+  constructor(tagName = "button") {
+    super(tagName);
+  }
+  get type() {
+    return this.getAttribute("type") ?? "submit";
+  }
+}
+
+class HTMLStyleElement extends HTMLElement {
+  constructor(tagName = "style") {
+    super(tagName);
+  }
+}
+
+class HTMLAnchorElement extends HTMLElement {
+  constructor(tagName = "a") {
+    super(tagName);
+  }
+  get href() {
+    return this.getAttribute("href") ?? "";
+  }
+  set href(value) {
+    this.setAttribute("href", value);
+  }
+}
+
+class Text extends Node {
+  data;
+  constructor(data = "") {
+    super(3 /* TEXT_NODE */, "#text");
+    this.data = data;
+  }
+  get nodeValue() {
+    return this.data;
+  }
+  set nodeValue(value) {
+    this.data = value;
+  }
+  get textContent() {
+    return this.data;
+  }
+  set textContent(value) {
+    this.data = value;
+  }
+  get wholeText() {
+    return this.data;
+  }
+  createClone() {
+    const clone = new Text(this.data);
+    clone.ownerDocument = this.ownerDocument;
+    return clone;
+  }
+}
+
+class Comment extends Node {
+  data;
+  constructor(data = "") {
+    super(8 /* COMMENT_NODE */, "#comment");
+    this.data = data;
+  }
+  get nodeValue() {
+    return this.data;
+  }
+  set nodeValue(value) {
+    this.data = value;
+  }
+  createClone() {
+    const clone = new Comment(this.data);
+    clone.ownerDocument = this.ownerDocument;
+    return clone;
+  }
+}
+
+class DocumentFragment extends Node {
+  constructor() {
+    super(11 /* DOCUMENT_FRAGMENT_NODE */, "#document-fragment");
+  }
+}
+
+class Document extends Node {
+  defaultView = null;
+  constructor() {
+    super(9 /* DOCUMENT_NODE */, "#document");
+  }
+  createElement(tagName) {
+    return createElementForTag(tagName, this);
+  }
+  createElementNS(namespaceURI, tagName) {
+    const element = createElementForTag(tagName, this);
+    element.namespaceURI = namespaceURI;
+    return element;
+  }
+  createTextNode(data) {
+    const text = new Text(data);
+    text.ownerDocument = this;
+    return text;
+  }
+  createComment(data) {
+    const comment = new Comment(data);
+    comment.ownerDocument = this;
+    return comment;
+  }
+  createDocumentFragment() {
+    const fragment = new DocumentFragment;
+    fragment.ownerDocument = this;
+    return fragment;
+  }
+  createEvent(type) {
+    if (type === "MouseEvent" || type === "mouseevent") {
+      return new MouseEvent("");
+    }
+    if (type === "KeyboardEvent" || type === "keyboardevent") {
+      return new KeyboardEvent("");
+    }
+    if (type === "CustomEvent" || type === "customevent") {
+      return new CustomEvent("");
+    }
+    return new Event("");
+  }
+  get documentElement() {
+    const html = this.childList.find((child) => child.nodeType === 1 /* ELEMENT_NODE */);
+    if (html) {
+      return html;
+    }
+    const created = createElementForTag("html", this);
+    this.appendChild(created);
+    return created;
+  }
+  get head() {
+    return this.ensureDocumentChild("head");
+  }
+  get body() {
+    return this.ensureDocumentChild("body");
+  }
+  get title() {
+    const titleElement = this.querySelector("title");
+    return titleElement?.textContent ?? "";
+  }
+  set title(value) {
+    let titleElement = this.querySelector("title");
+    if (!titleElement) {
+      titleElement = createElementForTag("title", this);
+      this.head.appendChild(titleElement);
+    }
+    titleElement.textContent = value;
+  }
+  querySelector(selector) {
+    return querySelectorAll(this, selector).item(0);
+  }
+  querySelectorAll(selector) {
+    return querySelectorAll(this, selector);
+  }
+  getElementById(id) {
+    let result = null;
+    collectElements(this, (element) => {
+      if (!result && element.id === id) {
+        result = element;
+      }
+    });
+    return result;
+  }
+  getElementsByTagName(tagName) {
+    return this.documentElement.getElementsByTagName(tagName);
+  }
+  createClone() {
+    return new Document;
+  }
+  ensureDocumentChild(tagName) {
+    const documentElement = this.documentElement;
+    let child = documentElement.childList.find((node) => node.nodeType === 1 /* ELEMENT_NODE */ && node.localName === tagName);
+    if (!child) {
+      child = createElementForTag(tagName, this);
+      documentElement.appendChild(child);
+    }
+    return child;
+  }
+}
+
+class Location {
+  url;
+  constructor(url) {
+    this.url = new URL(url);
+  }
+  get href() {
+    return this.url.href;
+  }
+  set href(value) {
+    this.url = new URL(value, this.url.href);
+  }
+  get origin() {
+    return this.url.origin;
+  }
+  get protocol() {
+    return this.url.protocol;
+  }
+  get host() {
+    return this.url.host;
+  }
+  get hostname() {
+    return this.url.hostname;
+  }
+  get port() {
+    return this.url.port;
+  }
+  get pathname() {
+    return this.url.pathname;
+  }
+  set pathname(value) {
+    const url = this.url;
+    const next = new URL(value, url.href);
+    url.pathname = next.pathname;
+  }
+  get search() {
+    return this.url.search;
+  }
+  set search(value) {
+    this.url.search = value.startsWith("?") ? value : `?${value}`;
+  }
+  get hash() {
+    return this.url.hash;
+  }
+  set hash(value) {
+    const nextHash = value.startsWith("#") ? value : `#${value}`;
+    this.url.hash = nextHash;
+  }
+  get username() {
+    return this.url.username;
+  }
+  get password() {
+    return this.url.password;
+  }
+  assign(value) {
+    this.url = new URL(value, this.url.href);
+  }
+  replace(value) {
+    this.url = new URL(value, this.url.href);
+  }
+  reload() {}
+  toString() {
+    return this.url.href;
+  }
+  getHashPath() {
+    return this.url.hash.slice(1);
+  }
+  getHrefWithoutHash() {
+    const url = this.url;
+    return `${url.origin}${url.pathname}${url.search}`;
+  }
+}
+
+class History {
+  windowRef;
+  entries = [];
+  index = 0;
+  scrollRestoration = "auto";
+  constructor(windowRef) {
+    this.windowRef = windowRef;
+    this.entries = [{ state: null, url: windowRef.location.href }];
+  }
+  get length() {
+    return this.entries.length;
+  }
+  get state() {
+    return this.entries[this.index]?.state ?? null;
+  }
+  pushState(state, _unusedTitle, url) {
+    const nextUrl = url ? new URL(url, this.windowRef.location.href).href : this.windowRef.location.href;
+    this.entries = this.entries.slice(0, this.index + 1);
+    this.entries.push({ state, url: nextUrl });
+    this.index = this.entries.length - 1;
+    this.windowRef.setLocationUrl(nextUrl);
+  }
+  replaceState(state, _unusedTitle, url) {
+    const nextUrl = url ? new URL(url, this.windowRef.location.href).href : this.windowRef.location.href;
+    this.entries[this.index] = { state, url: nextUrl };
+    this.windowRef.setLocationUrl(nextUrl);
+  }
+  back() {
+    this.go(-1);
+  }
+  forward() {
+    this.go(1);
+  }
+  go(delta = 0) {
+    const nextIndex = this.index + delta;
+    if (nextIndex < 0 || nextIndex >= this.entries.length) {
+      return;
+    }
+    this.index = nextIndex;
+    this.windowRef.setLocationUrl(this.entries[nextIndex].url);
+    this.windowRef.dispatchEvent(new Event("popstate", { bubbles: false, cancelable: false }));
+  }
+}
+
+class Storage {
+  store = new Map;
+  get length() {
+    return this.store.size;
+  }
+  key(index) {
+    return [...this.store.keys()][index] ?? null;
+  }
+  getItem(key) {
+    return this.store.has(key) ? this.store.get(key) : null;
+  }
+  setItem(key, value) {
+    this.store.set(key, String(value));
+  }
+  removeItem(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+}
+
+class Navigator {
+  userAgent = "TSone/0.2.1";
+  platform = "TSone";
+  language = "zh-CN";
+  languages = ["zh-CN"];
+  onLine = true;
+  maxTouchPoints = 0;
+}
+function createMatchMedia(_windowRef, query) {
+  const listeners = new Set;
+  const matches = false;
+  const list = {
+    media: query,
+    matches,
+    onchange: null,
+    addEventListener(type, listener) {
+      if (type === "change") {
+        listeners.add(listener);
+      }
+    },
+    removeEventListener(type, listener) {
+      if (type === "change") {
+        listeners.delete(listener);
+      }
+    },
+    addListener(listener) {
+      listeners.add(listener);
+    },
+    removeListener(listener) {
+      listeners.delete(listener);
+    },
+    dispatchEvent(event) {
+      for (const listener of [...listeners]) {
+        if (typeof listener === "function") {
+          listener.call(list, event);
+        } else {
+          listener.handleEvent(event);
+        }
+      }
+      return true;
+    }
+  };
+  return list;
+}
+
+class ResizeObserver {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+}
+var DOM_GLOBAL_KEYS = [
+  "window",
+  "document",
+  "Node",
+  "Text",
+  "Comment",
+  "Element",
+  "HTMLElement",
+  "HTMLInputElement",
+  "HTMLTextAreaElement",
+  "HTMLSelectElement",
+  "HTMLButtonElement",
+  "HTMLOptionElement",
+  "HTMLStyleElement",
+  "HTMLAnchorElement",
+  "DocumentFragment",
+  "Document",
+  "Event",
+  "MouseEvent",
+  "KeyboardEvent",
+  "CustomEvent",
+  "EventTarget",
+  "DOMException",
+  "history",
+  "location",
+  "navigator",
+  "localStorage",
+  "matchMedia",
+  "getComputedStyle",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "ResizeObserver"
+];
+
+class DomWindow extends EventTarget {
+  window = this;
+  document;
+  location;
+  history;
+  localStorage = new Storage;
+  navigator = new Navigator;
+  Node = Node;
+  Text = Text;
+  Comment = Comment;
+  Element = Element;
+  HTMLElement = HTMLElement;
+  HTMLInputElement = HTMLInputElement;
+  HTMLTextAreaElement = HTMLTextAreaElement;
+  HTMLSelectElement = HTMLSelectElement;
+  HTMLButtonElement = HTMLButtonElement;
+  HTMLOptionElement = HTMLOptionElement;
+  HTMLStyleElement = HTMLStyleElement;
+  HTMLAnchorElement = HTMLAnchorElement;
+  DocumentFragment = DocumentFragment;
+  Document = Document;
+  Event = Event;
+  MouseEvent = MouseEvent;
+  KeyboardEvent = KeyboardEvent;
+  CustomEvent = CustomEvent;
+  EventTarget = EventTarget;
+  DOMException = DOMException;
+  NodeList = NodeList;
+  constructor(options = {}) {
+    super();
+    const url = options.url ?? "http://localhost/";
+    this.location = new Location(url);
+    this.history = new History(this);
+    this.document = new Document;
+    this.document.defaultView = this;
+    setupDocumentTree(this.document);
+  }
+  matchMedia(query) {
+    return createMatchMedia(this, query);
+  }
+  getComputedStyle(element) {
+    return element.style;
+  }
+  requestAnimationFrame(callback) {
+    return setTimeout(() => callback(Date.now()), 0);
+  }
+  cancelAnimationFrame(handle) {
+    clearTimeout(handle);
+  }
+  setLocationUrl(url) {
+    this.location.href = url;
+  }
+  installKeys() {
+    return [...DOM_GLOBAL_KEYS];
+  }
+}
+function createDomWindow(options = {}) {
+  return new DomWindow(options);
+}
+function installDomGlobals(windowRef, target = globalThis) {
+  const previous = new Map;
+  const keys = windowRef.installKeys();
+  for (const key of keys) {
+    previous.set(key, Object.getOwnPropertyDescriptor(target, key));
+  }
+  for (const key of keys) {
+    Object.defineProperty(target, key, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: windowRef[key]
+    });
+  }
+  Object.defineProperty(target, "window", {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value: windowRef
+  });
+  return () => {
+    for (const key of keys) {
+      const descriptor = previous.get(key);
+      if (descriptor) {
+        Object.defineProperty(target, key, descriptor);
+      } else {
+        Reflect.deleteProperty(target, key);
+      }
+    }
+  };
+}
+function parseHtmlFragment(source, documentRef) {
+  const root = new DocumentFragment;
+  if (documentRef) {
+    root.ownerDocument = documentRef;
+  }
+  parseInto(root, source, documentRef);
+  return [...root.childList];
+}
+function parseInto(parent, source, documentRef) {
+  const stack = [];
+  let current = parent;
+  let index = 0;
+  const length = source.length;
+  const append = (node) => {
+    if (node.ownerDocument === null) {
+      node.ownerDocument = documentRef;
+    }
+    current.appendChild(node);
+  };
+  while (index < length) {
+    const openIndex = source.indexOf("<", index);
+    if (openIndex < 0) {
+      append(new Text(source.slice(index)));
+      break;
+    }
+    if (openIndex > index) {
+      append(new Text(source.slice(index, openIndex)));
+    }
+    if (source.startsWith("<!--", openIndex)) {
+      const closeIndex = source.indexOf("-->", openIndex + 4);
+      const commentEnd = closeIndex < 0 ? length : closeIndex;
+      append(new Comment(source.slice(openIndex + 4, commentEnd)));
+      index = closeIndex < 0 ? length : closeIndex + 3;
+      continue;
+    }
+    const tagEnd = findTagEnd(source, openIndex);
+    if (tagEnd < 0) {
+      append(new Text(source.slice(openIndex)));
+      break;
+    }
+    const tagSource = source.slice(openIndex + 1, tagEnd);
+    const trimmed = tagSource.trim();
+    if (trimmed.startsWith("/")) {
+      const tagName = trimmed.slice(1).trim().toLowerCase();
+      if (stack.length > 0 && stack[stack.length - 1].localName === tagName) {
+        stack.pop();
+        current = stack[stack.length - 1] ?? parent;
+      }
+      index = tagEnd + 1;
+      continue;
+    }
+    const selfClosing = trimmed.endsWith("/");
+    const parsed = parseTag(trimmed.replace(/\/$/, "").trim());
+    if (!parsed) {
+      index = tagEnd + 1;
+      continue;
+    }
+    const element = createElementForTag(parsed.name, documentRef);
+    for (const attr of parsed.attributes) {
+      element.setAttribute(attr.name, attr.value);
+    }
+    append(element);
+    if (VOID_TAGS.has(parsed.name) || selfClosing) {
+      index = tagEnd + 1;
+      continue;
+    }
+    if (RAW_TEXT_TAGS.has(parsed.name)) {
+      const closeTag = `</${parsed.name}>`;
+      const rawEnd = source.toLowerCase().indexOf(closeTag, tagEnd + 1);
+      const rawText = source.slice(tagEnd + 1, rawEnd < 0 ? length : rawEnd);
+      element.appendChild(documentRef?.createTextNode(rawText) ?? new Text(rawText));
+      index = rawEnd < 0 ? length : rawEnd + closeTag.length;
+      continue;
+    }
+    stack.push(element);
+    current = element;
+    index = tagEnd + 1;
+  }
+}
+var VOID_TAGS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var RAW_TEXT_TAGS = new Set(["script", "style", "textarea", "title"]);
+function findTagEnd(source, openIndex) {
+  let inQuote = null;
+  for (let index = openIndex + 1;index < source.length; index += 1) {
+    const char = source[index];
+    if (inQuote) {
+      if (char === inQuote) {
+        inQuote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inQuote = char;
+      continue;
+    }
+    if (char === ">") {
+      return index;
+    }
+  }
+  return -1;
+}
+function parseTag(source) {
+  const match = source.match(/^([a-zA-Z][a-zA-Z0-9-]*)\s*(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const name = match[1].toLowerCase();
+  const attributes = [];
+  const attributeSource = match[2];
+  const pattern = /([a-zA-Z_:][a-zA-Z0-9_:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+  let attributeMatch;
+  while ((attributeMatch = pattern.exec(attributeSource)) !== null) {
+    const attrName = attributeMatch[1];
+    const value = attributeMatch[2] ?? attributeMatch[3] ?? attributeMatch[4] ?? "";
+    attributes.push({ name: attrName, value: decodeEntities(value) });
+  }
+  return { name, attributes };
+}
+function decodeEntities(value) {
+  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ");
+}
+function encodeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function encodeAttribute(value) {
+  return encodeText(value).replace(/"/g, "&quot;");
+}
+function serializeNode(node) {
+  switch (node.nodeType) {
+    case 3 /* TEXT_NODE */:
+      return encodeText(node.data);
+    case 8 /* COMMENT_NODE */:
+      return `<!--${node.data}-->`;
+    case 1 /* ELEMENT_NODE */:
+      return serializeElement(node);
+    default:
+      return "";
+  }
+}
+function serializeElement(element) {
+  const tag = element.localName;
+  const attributes = [];
+  for (const entry of element.attributeEntries()) {
+    if (entry.name === "style") {
+      continue;
+    }
+    attributes.push(`${entry.name}="${encodeAttribute(entry.value)}"`);
+  }
+  const inlineStyle = element.inlineStyleText();
+  if (inlineStyle) {
+    attributes.push(`style="${encodeAttribute(inlineStyle)}"`);
+  }
+  const attributeText = attributes.length > 0 ? ` ${attributes.join(" ")}` : "";
+  if (VOID_TAGS.has(tag)) {
+    return `<${tag}${attributeText}>`;
+  }
+  if (RAW_TEXT_TAGS.has(tag)) {
+    return `<${tag}${attributeText}>${element.textContent}</${tag}>`;
+  }
+  return `<${tag}${attributeText}>${serializeChildren(element)}</${tag}>`;
+}
+function serializeChildren(element) {
+  return element.childList.map((child) => serializeNode(child)).join("");
+}
+function parseSelector(selector) {
+  return selector.split(",").map((group) => {
+    const segments = [];
+    let index = 0;
+    while (index < group.length) {
+      while (index < group.length && group[index] === " ") {
+        index += 1;
+      }
+      if (index >= group.length) {
+        break;
+      }
+      if (group[index] === ">") {
+        segments.push({ type: "child" });
+        index += 1;
+        continue;
+      }
+      const start = index;
+      while (index < group.length && group[index] !== " " && group[index] !== ">") {
+        index += 1;
+      }
+      segments.push(parseCompound(group.slice(start, index)));
+    }
+    return segments;
+  });
+}
+function parseCompound(source) {
+  const selectors = [];
+  let index = 0;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === "*") {
+      selectors.push({ type: "universal" });
+      index += 1;
+    } else if (char === "#") {
+      const end = scanIdentifier(source, index + 1);
+      selectors.push({ type: "id", id: source.slice(index + 1, end) });
+      index = end;
+    } else if (char === ".") {
+      const end = scanIdentifier(source, index + 1);
+      selectors.push({
+        type: "class",
+        className: source.slice(index + 1, end)
+      });
+      index = end;
+    } else if (char === "[") {
+      const end = source.indexOf("]", index);
+      const inner = source.slice(index + 1, end < 0 ? source.length : end).trim();
+      const attrMatch = inner.match(/^([a-zA-Z_:][a-zA-Z0-9_:.-]*)(?:([~|^$*]?=)(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?$/);
+      if (attrMatch) {
+        selectors.push({
+          type: "attribute",
+          name: attrMatch[1],
+          operator: attrMatch[2],
+          value: attrMatch[3] ?? attrMatch[4] ?? attrMatch[5]
+        });
+      } else {
+        selectors.push({ type: "attribute", name: inner });
+      }
+      index = end < 0 ? source.length : end + 1;
+    } else if (/[a-zA-Z_]/.test(char)) {
+      const end = scanIdentifier(source, index);
+      selectors.push({
+        type: "tag",
+        name: source.slice(index, end).toLowerCase()
+      });
+      index = end;
+    } else {
+      index += 1;
+    }
+  }
+  if (selectors.length === 1) {
+    return selectors[0];
+  }
+  return { type: "compound", parts: selectors };
+}
+function scanIdentifier(source, start) {
+  let index = start;
+  while (index < source.length && /[a-zA-Z0-9:_-]/.test(source[index])) {
+    index += 1;
+  }
+  return index;
+}
+function matchSelector(element, selector) {
+  const groups = parseSelector(selector);
+  return groups.some((group) => matchGroup(element, group));
+}
+function matchGroup(element, group) {
+  let index = group.length - 1;
+  if (index < 0) {
+    return true;
+  }
+  if (!matchSegment(element, group[index])) {
+    return false;
+  }
+  if (index === 0) {
+    return true;
+  }
+  let current = element.parentElement;
+  index -= 1;
+  while (current) {
+    const selector = group[index];
+    if (!selector) {
+      return true;
+    }
+    if (selector.type === "child") {
+      const parentSelector = group[index - 1];
+      if (!parentSelector || !matchSegment(current, parentSelector)) {
+        return false;
+      }
+      index -= 2;
+      if (index < 0) {
+        return true;
+      }
+      current = current.parentElement;
+      continue;
+    }
+    if (matchSegment(current, selector)) {
+      index -= 1;
+      if (index < 0) {
+        return true;
+      }
+    }
+    current = current.parentElement;
+  }
+  return false;
+}
+function matchSegment(element, selector) {
+  switch (selector.type) {
+    case "universal":
+      return true;
+    case "tag":
+      return element.localName === selector.name;
+    case "id":
+      return element.id === selector.id;
+    case "class":
+      return element.classList.contains(selector.className);
+    case "attribute":
+      return matchAttribute(element, selector);
+    case "compound":
+      return selector.parts.every((part) => matchSegment(element, part));
+    case "child":
+      return false;
+    default:
+      return false;
+  }
+}
+function matchAttribute(element, selector) {
+  const attributeValue = element.getAttribute(selector.name);
+  if (!selector.operator) {
+    return attributeValue !== null;
+  }
+  if (attributeValue === null) {
+    return false;
+  }
+  const expected = selector.value ?? "";
+  switch (selector.operator) {
+    case "=":
+      return attributeValue === expected;
+    case "~=":
+      return attributeValue.split(/\s+/).includes(expected);
+    case "|=":
+      return attributeValue === expected || attributeValue.startsWith(`${expected}-`);
+    case "^=":
+      return attributeValue.startsWith(expected);
+    case "$=":
+      return attributeValue.endsWith(expected);
+    case "*=":
+      return attributeValue.includes(expected);
+    default:
+      return false;
+  }
+}
+function querySelectorAll(root, selector) {
+  const results = [];
+  collectElements(root, (element) => {
+    if (element !== root && matchSelector(element, selector)) {
+      results.push(element);
+    }
+  });
+  return new NodeList(results);
+}
+function collectElements(root, visit) {
+  for (const child of root.childList) {
+    if (child.nodeType === 1 /* ELEMENT_NODE */) {
+      visit(child);
+      collectElements(child, visit);
+    }
+  }
+}
+function createElementForTag(tagName, documentRef) {
+  const tag = tagName.toLowerCase();
+  let element;
+  if (tag === "input") {
+    element = new HTMLInputElement(tag);
+  } else if (tag === "textarea") {
+    element = new HTMLTextAreaElement(tag);
+  } else if (tag === "select") {
+    element = new HTMLSelectElement(tag);
+  } else if (tag === "option") {
+    element = new HTMLOptionElement(tag);
+  } else if (tag === "button") {
+    element = new HTMLButtonElement(tag);
+  } else if (tag === "style") {
+    element = new HTMLStyleElement(tag);
+  } else if (tag === "a") {
+    element = new HTMLAnchorElement(tag);
+  } else {
+    element = new HTMLElement(tag);
+  }
+  element.ownerDocument = documentRef;
+  return element;
+}
+function setupDocumentTree(documentRef) {
+  const html = documentRef.createElement("html");
+  html.setAttribute("lang", "en");
+  documentRef.appendChild(html);
+  const head = documentRef.createElement("head");
+  const body = documentRef.createElement("body");
+  html.appendChild(head);
+  html.appendChild(body);
+}
+function createDatasetProxy(element) {
+  const handler = {
+    get(_target, property) {
+      if (typeof property === "symbol") {
+        return;
+      }
+      return element.getAttribute(`data-${toKebabCase(property)}`) ?? "";
+    },
+    set(_target, property, value) {
+      if (typeof property === "symbol") {
+        return true;
+      }
+      if (value === "" || value === null || value === undefined) {
+        element.removeAttribute(`data-${toKebabCase(property)}`);
+      } else {
+        element.setAttribute(`data-${toKebabCase(property)}`, String(value));
+      }
+      return true;
+    },
+    deleteProperty(_target, property) {
+      if (typeof property !== "symbol") {
+        element.removeAttribute(`data-${toKebabCase(property)}`);
+      }
+      return true;
+    },
+    has(_target, property) {
+      if (typeof property === "symbol") {
+        return false;
+      }
+      return element.hasAttribute(`data-${toKebabCase(property)}`);
+    },
+    ownKeys() {
+      const keys = [];
+      for (const entry of element.attributeEntries()) {
+        if (entry.name.startsWith("data-")) {
+          keys.push(toCamelCase(entry.name.slice(5)));
+        }
+      }
+      return keys;
+    },
+    getOwnPropertyDescriptor(_target, property) {
+      if (typeof property === "symbol") {
+        return;
+      }
+      if (element.hasAttribute(`data-${toKebabCase(property)}`)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: true,
+          value: element.getAttribute(`data-${toKebabCase(property)}`)
+        };
+      }
+      return;
+    }
+  };
+  return new Proxy({}, handler);
+}
+function toKebabCase(value) {
+  return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+function toCamelCase(value) {
+  return value.replace(/-([a-z])/g, (_match, char) => char.toUpperCase());
+}
+export {
+  Comment,
+  CustomEvent,
+  DOMException,
+  DOMTokenList,
+  DOM_GLOBAL_KEYS,
+  Document,
+  DocumentFragment,
+  DomNodeType,
+  DomWindow,
+  Element,
+  Event,
+  EventTarget,
+  HTMLAnchorElement,
+  HTMLButtonElement,
+  HTMLElement,
+  HTMLInputElement,
+  HTMLOptionElement,
+  HTMLOptionsCollection,
+  HTMLSelectElement,
+  HTMLStyleElement,
+  HTMLTextAreaElement,
+  History,
+  KeyboardEvent,
+  Location,
+  MouseEvent,
+  NamedNodeMap,
+  Navigator,
+  Node,
+  NodeList,
+  ResizeObserver,
+  Storage,
+  Text,
+  createDomWindow,
+  createMatchMedia,
+  createStyleDeclaration,
+  installDomGlobals,
+  parseHtmlFragment
+};
+
+//# debugId=7D13E902DBE25F4664756E2164756E21
+//# sourceMappingURL=index.js.map