@geektech/tsone-cli 0.1.0 → 0.2.2

package/dist/{index-p7jrckn1.js → index-y6qrqbwv.js}

@@ -222,75 +222,60 @@ function isJavaScriptPath(path) {
 }
 
 // ../tsone/dist/dom/index.js
-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 ||= {});
+var ce;
+((s) => {
+  s[s.ELEMENT_NODE = 1] = "ELEMENT_NODE";
+  s[s.TEXT_NODE = 3] = "TEXT_NODE";
+  s[s.COMMENT_NODE = 8] = "COMMENT_NODE";
+  s[s.DOCUMENT_NODE = 9] = "DOCUMENT_NODE";
+  s[s.DOCUMENT_FRAGMENT_NODE = 11] = "DOCUMENT_FRAGMENT_NODE";
+})(ce ||= {});
 
-class DOMException extends Error {
+class K extends Error {
   code;
-  constructor(message, name = "Error") {
-    super(message);
-    this.name = name;
-    this.code = 0;
+  constructor(e, t = "Error") {
+    super(e);
+    this.name = t, this.code = 0;
   }
 }
 
-class EventTarget {
+class A {
   listenerMap = new Map;
-  addEventListener(type, listener, options) {
-    if (!listener) {
+  addEventListener(e, t, n) {
+    if (!t)
       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)) {
+    let i = typeof n === "boolean" ? n : n?.capture ?? false, r = typeof n === "object" ? n.once ?? false : false, s = typeof n === "object" ? n.passive ?? false : false, l = this.listenerMap.get(e);
+    if (!l)
+      l = [], this.listenerMap.set(e, l);
+    if (l.some((a) => a.listener === t && a.capture === i))
       return;
-    }
-    entries.push({ listener, capture, once, passive });
+    l.push({ listener: t, capture: i, once: r, passive: s });
   }
-  removeEventListener(type, listener, options) {
-    if (!listener) {
+  removeEventListener(e, t, n) {
+    if (!t)
       return;
-    }
-    const capture = typeof options === "boolean" ? options : options?.capture ?? false;
-    const entries = this.listenerMap.get(type);
-    if (!entries) {
+    let i = typeof n === "boolean" ? n : n?.capture ?? false, r = this.listenerMap.get(e);
+    if (!r)
       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);
-    }
+    let s = r.findIndex((l) => l.listener === t && l.capture === i);
+    if (s >= 0)
+      r.splice(s, 1);
+    if (r.length === 0)
+      this.listenerMap.delete(e);
   }
-  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);
+  dispatchEvent(e) {
+    if (!(e instanceof c))
+      throw TypeError("dispatchEvent requires an Event instance");
+    if (e.dispatched)
+      throw Error("Event has already been dispatched");
+    return pe(this, e);
   }
-  getListeners(type) {
-    return this.listenerMap.get(type) ?? [];
+  getListeners(e) {
+    return this.listenerMap.get(e) ?? [];
   }
 }
 
-class Event {
+class c {
   static NONE = 0;
   static CAPTURING_PHASE = 1;
   static AT_TARGET = 2;
@@ -301,7 +286,7 @@ class Event {
   composed;
   target = null;
   currentTarget = null;
-  eventPhase = Event.NONE;
+  eventPhase = c.NONE;
   defaultPrevented = false;
   isTrusted = false;
   timeStamp;
@@ -310,26 +295,18 @@ class Event {
   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();
+  constructor(e, t) {
+    this.type = e, this.bubbles = t?.bubbles ?? false, this.cancelable = t?.cancelable ?? false, this.composed = t?.composed ?? false, this.timeStamp = Date.now();
   }
   preventDefault() {
-    if (this.cancelable) {
+    if (this.cancelable)
       this.canceled = true;
-    }
   }
   stopPropagation() {
-    this.propagationStopped = true;
-    this.cancelBubble = true;
+    this.propagationStopped = true, this.cancelBubble = true;
   }
   stopImmediatePropagation() {
-    this.propagationStopped = true;
-    this.immediateStopped = true;
-    this.cancelBubble = true;
+    this.propagationStopped = true, this.immediateStopped = true, this.cancelBubble = true;
   }
   propagationPrevented() {
     return this.propagationStopped;
@@ -342,131 +319,104 @@ class Event {
   }
 }
 
-class CustomEvent extends Event {
+class I extends c {
   detail;
-  constructor(type, init) {
-    super(type, init);
-    this.detail = init?.detail;
+  constructor(e, t) {
+    super(e, t);
+    this.detail = t?.detail;
   }
 }
 
-class MouseEvent extends Event {
+class O extends c {
   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;
+  constructor(e, t) {
+    super(e, t);
+    this.clientX = t?.clientX ?? 0, this.clientY = t?.clientY ?? 0, this.button = t?.button ?? 0, this.buttons = t?.buttons ?? 0, this.relatedTarget = t?.relatedTarget ?? null;
   }
 }
 
-class KeyboardEvent extends Event {
+class H extends c {
   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()) {
+  constructor(e, t) {
+    super(e, t);
+    this.key = t?.key ?? "", this.code = t?.code ?? "";
+  }
+}
+function de(e, t) {
+  let n = e.listener;
+  if (typeof n === "function")
+    n.call(t.currentTarget, t);
+  else
+    n.handleEvent(t);
+}
+function pe(e, t) {
+  t.dispatched = true, t.target = e;
+  let i = [...he(e)].reverse(), r = i.length - 1;
+  t.eventPhase = c.CAPTURING_PHASE;
+  for (let s = 0;s < r; s += 1) {
+    let l = i[s];
+    if (t.propagationPrevented())
       break;
-    }
-    event.currentTarget = current;
-    runListeners(current, event, true);
+    t.currentTarget = l, x(l, t, true);
   }
-  if (!event.propagationPrevented()) {
-    event.eventPhase = Event.AT_TARGET;
-    event.currentTarget = target;
-    runListeners(target, event, true);
-    if (!event.immediatePrevented()) {
-      runListeners(target, event, false);
-    }
+  if (!t.propagationPrevented()) {
+    if (t.eventPhase = c.AT_TARGET, t.currentTarget = e, x(e, t, true), !t.immediatePrevented())
+      x(e, t, 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()) {
+  if (t.bubbles && !t.propagationPrevented()) {
+    t.eventPhase = c.BUBBLING_PHASE;
+    for (let s = i.length - 2;s >= 0; s -= 1) {
+      let l = i[s];
+      if (t.propagationPrevented())
         break;
-      }
-      event.currentTarget = current;
-      runListeners(current, event, false);
+      t.currentTarget = l, x(l, t, false);
     }
   }
-  event.eventPhase = Event.NONE;
-  event.currentTarget = null;
-  return !event.wasCanceled();
+  return t.eventPhase = c.NONE, t.currentTarget = null, !t.wasCanceled();
 }
-function runListeners(target, event, capture) {
-  const listeners = target.getListeners(event.type);
-  for (const entry of [...listeners]) {
-    if (entry.capture !== capture) {
+function x(e, t, n) {
+  let i = e.getListeners(t.type);
+  for (let r of [...i]) {
+    if (r.capture !== n)
       continue;
-    }
-    if (event.immediatePrevented()) {
+    if (t.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) {
-      const view = node.defaultView;
-      if (view) {
-        path.push(view);
-      }
+    if (r.once)
+      e.removeEventListener(t.type, r.listener, { capture: r.capture });
+    de(r, t);
+  }
+}
+function he(e) {
+  let t = [], n = e;
+  while (n) {
+    t.push(n);
+    let i = n;
+    if (i.nodeType === 9) {
+      let s = i.defaultView;
+      if (s)
+        t.push(s);
       break;
     }
-    const parent = node.parentNode;
-    if (parent) {
-      current = parent;
+    let r = i.parentNode;
+    if (r) {
+      n = r;
       continue;
     }
     break;
   }
-  return path;
+  return t;
 }
 
-class DOMTokenList {
+class X {
   element;
   attributeName;
-  constructor(element, attributeName = "class") {
-    this.element = element;
-    this.attributeName = attributeName;
+  constructor(e, t = "class") {
+    this.element = e, this.attributeName = t;
   }
   get length() {
     return this.tokens().length;
@@ -474,210 +424,157 @@ class DOMTokenList {
   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) {
+  set value(e) {
+    this.setTokens(q(e));
+  }
+  item(e) {
+    return this.tokens()[e] ?? null;
+  }
+  contains(e) {
+    return this.tokens().includes(e);
+  }
+  add(...e) {
+    let t = new Set(this.tokens());
+    for (let n of e)
+      if (n)
+        t.add(n);
+    this.setTokens([...t]);
+  }
+  remove(...e) {
+    let t = new Set(this.tokens());
+    for (let n of e)
+      t.delete(n);
+    this.setTokens([...t]);
+  }
+  toggle(e, t) {
+    let n = new Set(this.tokens()), i = t ?? !n.has(e);
+    if (i)
+      n.add(e);
+    else
+      n.delete(e);
+    return this.setTokens([...n]), i;
+  }
+  replace(e, t) {
+    let n = this.tokens(), i = n.indexOf(e);
+    if (i < 0)
       return false;
-    }
-    current[index] = newToken;
-    this.setTokens(current);
-    return true;
+    return n[i] = t, this.setTokens(n), true;
   }
   [Symbol.iterator]() {
     return this.tokens()[Symbol.iterator]();
   }
-  forEach(callback) {
-    this.tokens().forEach((value, index) => callback(value, index, this));
+  forEach(e) {
+    this.tokens().forEach((t, n) => e(t, n, this));
   }
   toString() {
     return this.value;
   }
   tokens() {
-    return splitTokens(this.element.getAttribute(this.attributeName) ?? "");
+    return q(this.element.getAttribute(this.attributeName) ?? "");
   }
-  setTokens(tokens) {
-    const value = tokens.filter(Boolean).join(" ");
-    if (value) {
-      this.element.setAttribute(this.attributeName, value);
-    } else {
+  setTokens(e) {
+    let t = e.filter(Boolean).join(" ");
+    if (t)
+      this.element.setAttribute(this.attributeName, t);
+    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));
+function q(e) {
+  return e.trim().split(/\s+/).filter(Boolean);
+}
+function L(e) {
+  return e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+}
+function R() {
+  let e = new Map, t = { properties: e, setProperty(i, r, s = "") {
+    let l = L(i);
+    if (r === "")
+      e.delete(l);
+    else
+      e.set(l, { value: r, priority: s });
+  }, getPropertyValue(i) {
+    return e.get(L(i))?.value ?? "";
+  }, getPropertyPriority(i) {
+    return e.get(L(i))?.priority ?? "";
+  }, removeProperty(i) {
+    let r = L(i), s = e.get(r)?.value ?? "";
+    return e.delete(r), s;
+  }, item(i) {
+    return [...e.keys()][i] ?? "";
+  }, get length() {
+    return e.size;
+  }, get cssText() {
+    return [...e.entries()].map(([i, r]) => `${i}: ${r.value}${r.priority ? ` ${r.priority}` : ""};`).join(" ");
+  }, set cssText(i) {
+    e.clear();
+    for (let r of i.split(";")) {
+      let s = r.trim();
+      if (!s)
+        continue;
+      let l = s.indexOf(":");
+      if (l < 0)
+        continue;
+      let a = s.slice(0, l).trim(), o = s.slice(l + 1).trim();
+      if (a)
+        t.setProperty(a, o);
+    }
+  } };
+  return new Proxy(t, { get(i, r, s) {
+    if (typeof r === "symbol")
+      return Reflect.get(i, r, s);
+    if (r in i) {
+      let l = Reflect.get(i, r, s);
+      return typeof l === "function" ? l.bind(i) : l;
+    }
+    return i.getPropertyValue(r);
+  }, set(i, r, s, l) {
+    if (typeof r === "symbol")
+      return Reflect.set(i, r, s, l);
+    if (r in i)
+      return Reflect.set(i, r, s, l);
+    return i.setProperty(r, String(s)), true;
+  }, has(i, r) {
+    if (typeof r === "symbol")
+      return Reflect.has(i, r);
+    if (r in i)
       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);
+    return i.getPropertyValue(r) !== "";
+  }, ownKeys() {
+    return [...Reflect.ownKeys(t), ...[...e.keys()].map((i) => be(i))];
+  }, getOwnPropertyDescriptor(i, r) {
+    if (typeof r === "symbol")
+      return Reflect.getOwnPropertyDescriptor(i, r);
+    if (r in i)
+      return Reflect.getOwnPropertyDescriptor(i, r);
+    let s = i.getPropertyValue(r);
+    if (s !== "")
+      return { configurable: true, enumerable: true, writable: true, value: s };
+    return;
+  } });
 }
-function camelCaseProperty(property) {
-  return property.replace(/-([a-z])/g, (_match, char) => char.toUpperCase());
+function be(e) {
+  return e.replace(/-([a-z])/g, (t, n) => n.toUpperCase());
 }
 
-class NodeList {
+class f {
   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]
-      });
-    }
+  constructor(e = []) {
+    this.items = e;
+    for (let t = 0;t < e.length; t += 1)
+      Object.defineProperty(this, String(t), { configurable: true, enumerable: true, get: () => this.items[t] });
   }
   get length() {
     return this.items.length;
   }
-  item(index) {
-    return this.items[index] ?? null;
+  item(e) {
+    return this.items[e] ?? null;
   }
   [Symbol.iterator]() {
     return this.items[Symbol.iterator]();
   }
-  forEach(callback) {
-    this.items.forEach((value, index) => callback(value, index, this));
+  forEach(e) {
+    this.items.forEach((t, n) => e(t, n, this));
   }
   entries() {
     return this.items.entries();
@@ -693,7 +590,7 @@ class NodeList {
   }
 }
 
-class Node extends EventTarget {
+class b extends A {
   static ELEMENT_NODE = 1;
   static TEXT_NODE = 3;
   static COMMENT_NODE = 8;
@@ -704,17 +601,16 @@ class Node extends EventTarget {
   parentNode = null;
   ownerDocument = null;
   childList = [];
-  constructor(nodeType, nodeName) {
+  constructor(e, t) {
     super();
-    this.nodeType = nodeType;
-    this.nodeName = nodeName;
+    this.nodeType = e, this.nodeName = t;
   }
   get parentElement() {
-    const parent = this.parentNode;
-    return parent instanceof Element ? parent : null;
+    let e = this.parentNode;
+    return e instanceof M ? e : null;
   }
   get childNodes() {
-    return new NodeList([...this.childList]);
+    return new f([...this.childList]);
   }
   get firstChild() {
     return this.childList[0] ?? null;
@@ -723,160 +619,125 @@ class Node extends EventTarget {
     return this.childList[this.childList.length - 1] ?? null;
   }
   get nextSibling() {
-    const parent = this.parentNode;
-    if (!parent) {
+    let e = this.parentNode;
+    if (!e)
       return null;
-    }
-    const index = parent.childList.indexOf(this);
-    return index >= 0 ? parent.childList[index + 1] ?? null : null;
+    let t = e.childList.indexOf(this);
+    return t >= 0 ? e.childList[t + 1] ?? null : null;
   }
   get previousSibling() {
-    const parent = this.parentNode;
-    if (!parent) {
+    let e = this.parentNode;
+    if (!e)
       return null;
-    }
-    const index = parent.childList.indexOf(this);
-    return index > 0 ? parent.childList[index - 1] : null;
+    let t = e.childList.indexOf(this);
+    return t > 0 ? e.childList[t - 1] : null;
   }
   get textContent() {
-    let text = "";
-    for (const child of this.childList) {
-      if (child.nodeType === 3) {
-        text += child.data;
-      } else if (child.nodeType === 1) {
-        text += child.textContent;
-      }
-    }
-    return text;
+    let e = "";
+    for (let t of this.childList)
+      if (t.nodeType === 3)
+        e += t.data;
+      else if (t.nodeType === 1)
+        e += t.textContent;
+    return e;
   }
-  set textContent(value) {
-    this.childList = [];
-    if (value) {
-      const textNode = new Text(value);
-      textNode.ownerDocument = this.ownerDocument;
-      textNode.parentNode = this;
-      this.childList.push(textNode);
+  set textContent(e) {
+    if (this.childList = [], e) {
+      let t = new u(e);
+      t.ownerDocument = this.ownerDocument, t.parentNode = this, this.childList.push(t);
     }
   }
   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) {
+  appendChild(e) {
+    if (e === this)
+      throw Error("Cannot append a node to itself");
+    return this.insertBefore(e, null), e;
+  }
+  insertBefore(e, t) {
+    if (e === this)
+      throw Error("Cannot insert a node before itself");
+    if (e.parentNode)
+      e.parentNode.removeChild(e);
+    if (e.parentNode = this, e.ownerDocument === null)
+      e.ownerDocument = this.ownerDocument;
+    if (t === null)
+      return this.childList.push(e), e;
+    let n = this.childList.indexOf(t);
+    if (n < 0)
+      throw Error("Reference node is not a child of this node");
+    return this.childList.splice(n, 0, e), e;
+  }
+  removeChild(e) {
+    let t = this.childList.indexOf(e);
+    if (t < 0)
+      throw Error("Node is not a child of this node");
+    return this.childList.splice(t, 1), e.parentNode = null, e;
+  }
+  replaceChild(e, t) {
+    let n = this.childList.indexOf(t);
+    if (n < 0)
+      throw Error("Old child is not a child of this node");
+    if (e.parentNode)
+      e.parentNode.removeChild(e);
+    if (e.parentNode = this, e.ownerDocument === null)
+      e.ownerDocument = this.ownerDocument;
+    return this.childList[n] = e, t.parentNode = null, e;
+  }
+  replaceChildren(...e) {
+    for (let t of [...this.childList])
+      this.removeChild(t);
+    for (let t of e)
+      this.appendChild(t);
+  }
+  contains(e) {
+    if (!e)
       return false;
-    }
-    let current = node;
-    while (current) {
-      if (current === this) {
+    let t = e;
+    while (t) {
+      if (t === this)
         return true;
-      }
-      current = current.parentNode;
+      t = t.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;
+  cloneNode(e = false) {
+    let t = this.createClone();
+    if (e)
+      for (let n of this.childList)
+        t.appendChild(n.cloneNode(true));
+    return t;
   }
   createClone() {
-    const clone = new Node(this.nodeType, this.nodeName);
-    clone.ownerDocument = this.ownerDocument;
-    return clone;
+    let e = new b(this.nodeType, this.nodeName);
+    return e.ownerDocument = this.ownerDocument, e;
   }
   getRootNode() {
-    if (!this.parentNode) {
+    if (!this.parentNode)
       return this;
-    }
-    let parent = this.parentNode;
-    while (parent.parentNode) {
-      parent = parent.parentNode;
-    }
-    return parent;
+    let e = this.parentNode;
+    while (e.parentNode)
+      e = e.parentNode;
+    return e;
   }
   isConnected() {
     return this.getRootNode().nodeType === 9;
   }
 }
 
-class Element extends Node {
+class M extends b {
   namespaceURI;
   attributeList = [];
   styleValue;
   classListValue;
   datasetProxy;
-  constructor(tagName, namespaceURI = null) {
-    super(1, tagName.toUpperCase());
-    this.namespaceURI = namespaceURI;
+  constructor(e, t = null) {
+    super(1, e.toUpperCase());
+    this.namespaceURI = t;
   }
   get tagName() {
     return this.nodeName;
@@ -887,35 +748,32 @@ class Element extends Node {
   get id() {
     return this.getAttribute("id") ?? "";
   }
-  set id(value) {
-    this.setAttribute("id", value);
+  set id(e) {
+    this.setAttribute("id", e);
   }
   get className() {
     return this.getAttribute("class") ?? "";
   }
-  set className(value) {
-    this.setAttribute("class", value);
+  set className(e) {
+    this.setAttribute("class", e);
   }
   get classList() {
-    if (!this.classListValue) {
-      this.classListValue = new DOMTokenList(this, "class");
-    }
+    if (!this.classListValue)
+      this.classListValue = new X(this, "class");
     return this.classListValue;
   }
   get style() {
-    if (!this.styleValue) {
-      this.styleValue = createStyleDeclaration();
-    }
+    if (!this.styleValue)
+      this.styleValue = R();
     return this.styleValue;
   }
   get dataset() {
-    if (!this.datasetProxy) {
-      this.datasetProxy = createDatasetProxy(this);
-    }
+    if (!this.datasetProxy)
+      this.datasetProxy = Ce(this);
     return this.datasetProxy;
   }
   get children() {
-    return new NodeList(this.childList.filter((child) => child.nodeType === 1));
+    return new f(this.childList.filter((e) => e.nodeType === 1));
   }
   get firstElementChild() {
     return this.children.item(0);
@@ -927,214 +785,166 @@ class Element extends Node {
     return this.children.length;
   }
   get attributes() {
-    return new NamedNodeMap(this);
+    return new Z(this);
   }
-  getAttribute(name) {
-    const entry = this.findAttribute(name);
-    return entry ? entry.value : null;
+  getAttribute(e) {
+    let t = this.findAttribute(e);
+    return t ? t.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;
+    return this.attributeList.map((e) => e.name);
+  }
+  setAttribute(e, t) {
+    let n = String(t);
+    if (e === "style")
+      this.styleValue = R(), this.styleValue.cssText = n;
+    let i = this.findAttribute(e);
+    if (i)
+      i.value = n;
+    else
+      this.attributeList.push({ name: e, value: n });
+  }
+  removeAttribute(e) {
+    if (e === "style")
+      this.styleValue = R();
+    let t = this.attributeList.findIndex((n) => n.name === e);
+    if (t >= 0)
+      this.attributeList.splice(t, 1);
+  }
+  hasAttribute(e) {
+    return this.findAttribute(e) !== undefined;
+  }
+  toggleAttribute(e, t) {
+    let n = t ?? !this.hasAttribute(e);
+    if (n)
+      this.setAttribute(e, "");
+    else
+      this.removeAttribute(e);
+    return n;
   }
   hasAttributes() {
     return this.attributeList.length > 0;
   }
   get innerHTML() {
-    return serializeChildren(this);
+    return oe(this);
   }
-  set innerHTML(value) {
-    this.replaceChildren(...parseHtmlFragment(value, this.ownerDocument));
+  set innerHTML(e) {
+    this.replaceChildren(...ye(e, this.ownerDocument));
   }
   get outerHTML() {
-    return serializeNode(this);
+    return le(this);
   }
   get value() {
     return this.getAttribute("value") ?? "";
   }
-  set value(value) {
-    this.setAttribute("value", value);
+  set value(e) {
+    this.setAttribute("value", e);
   }
-  querySelector(selector) {
-    return querySelectorAll(this, selector).item(0);
+  querySelector(e) {
+    return C(this, e).item(0);
   }
-  querySelectorAll(selector) {
-    return querySelectorAll(this, selector);
+  querySelectorAll(e) {
+    return C(this, e);
   }
-  getElementsByTagName(tagName) {
-    const lowered = tagName.toLowerCase();
-    const results = [];
-    collectElements(this, (element) => {
-      if (element.localName === lowered) {
-        results.push(element);
-      }
-    });
-    return new NodeList(results);
+  getElementsByTagName(e) {
+    let t = e.toLowerCase(), n = [];
+    return N(this, (i) => {
+      if (i.localName === t)
+        n.push(i);
+    }), new f(n);
   }
-  matches(selector) {
-    return matchSelector(this, selector);
+  matches(e) {
+    return ue(this, e);
   }
-  closest(selector) {
-    if (this.matches(selector)) {
+  closest(e) {
+    if (this.matches(e))
       return this;
-    }
-    let parent = this.parentElement;
-    while (parent) {
-      if (parent.matches(selector)) {
-        return parent;
-      }
-      parent = parent.parentElement;
+    let t = this.parentElement;
+    while (t) {
+      if (t.matches(e))
+        return t;
+      t = t.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
-        };
-      }
-    };
+    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) {
+    this.dispatchEvent(new O("click", { bubbles: true, cancelable: true }));
+  }
+  append(...e) {
+    for (let t of e)
+      if (typeof t === "string") {
+        let n = new u(t);
+        n.ownerDocument = this.ownerDocument, this.appendChild(n);
+      } else
+        this.appendChild(t);
+  }
+  prepend(...e) {
+    let t = this.firstChild;
+    for (let n of e)
+      if (typeof n === "string") {
+        let i = new u(n);
+        i.ownerDocument = this.ownerDocument, this.insertBefore(i, t);
+      } else
+        this.insertBefore(n, t);
+  }
+  before(...e) {
+    let t = this.parentNode;
+    if (!t)
       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) {
+    for (let n of e)
+      if (typeof n === "string") {
+        let i = new u(n);
+        i.ownerDocument = this.ownerDocument, t.insertBefore(i, this);
+      } else
+        t.insertBefore(n, this);
+  }
+  after(...e) {
+    let t = this.parentNode;
+    if (!t)
       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) {
+    let n = this.nextSibling;
+    for (let i of e)
+      if (typeof i === "string") {
+        let r = new u(i);
+        r.ownerDocument = this.ownerDocument, t.insertBefore(r, n);
+      } else
+        t.insertBefore(i, n);
+  }
+  replaceWith(...e) {
+    let t = this.parentNode;
+    if (!t)
       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);
-      }
-    }
+    let n = this.nextSibling;
+    t.removeChild(this);
+    for (let i of e)
+      if (typeof i === "string") {
+        let r = new u(i);
+        r.ownerDocument = this.ownerDocument, t.insertBefore(r, n);
+      } else
+        t.insertBefore(i, n);
   }
-  setAttributeNS(_namespace, name, value) {
-    this.setAttribute(name, value);
+  setAttributeNS(e, t, n) {
+    this.setAttribute(t, n);
   }
-  removeAttributeNS(_namespace, name) {
-    this.removeAttribute(name);
+  removeAttributeNS(e, t) {
+    this.removeAttribute(t);
   }
-  hasAttributeNS(_namespace, name) {
-    return this.hasAttribute(name);
+  hasAttributeNS(e, t) {
+    return this.hasAttribute(t);
   }
-  getAttributeNS(_namespace, name) {
-    return this.getAttribute(name);
+  getAttributeNS(e, t) {
+    return this.getAttribute(t);
   }
-  findAttribute(name) {
-    return this.attributeList.find((entry) => entry.name === name);
+  findAttribute(e) {
+    return this.attributeList.find((t) => t.name === e);
   }
   attributeEntries() {
     return [...this.attributeList];
@@ -1143,62 +953,56 @@ class Element extends Node {
     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;
+    let e = m(this.localName, this.ownerDocument);
+    for (let t of this.attributeList)
+      e.setAttribute(t.name, t.value);
+    return e;
   }
 }
 
-class HTMLElement extends Element {
-  constructor(tagName) {
-    super(tagName);
+class p extends M {
+  constructor(e) {
+    super(e);
   }
 }
 
-class NamedNodeMap {
+class Z {
   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
-      });
-    }
+  constructor(e) {
+    this.element = e;
+    for (let t = 0;t < e.attributeEntries().length; t += 1)
+      Object.defineProperty(this, String(t), { configurable: true, enumerable: true, get: () => this.element.attributeEntries()[t] ?? null });
   }
   get length() {
     return this.element.attributeEntries().length;
   }
-  item(index) {
-    return this.element.attributeEntries()[index] ?? null;
+  item(e) {
+    return this.element.attributeEntries()[e] ?? null;
   }
-  getNamedItem(name) {
-    return this.element.findAttribute(name) ?? null;
+  getNamedItem(e) {
+    return this.element.findAttribute(e) ?? null;
   }
-  setNamedItem(attr) {
-    this.element.setAttribute(attr.name, attr.value);
+  setNamedItem(e) {
+    this.element.setAttribute(e.name, e.value);
   }
-  removeNamedItem(name) {
-    this.element.removeAttribute(name);
+  removeNamedItem(e) {
+    this.element.removeAttribute(e);
   }
   [Symbol.iterator]() {
     return this.element.attributeEntries()[Symbol.iterator]();
   }
 }
 
-class HTMLOptionElement extends HTMLElement {
+class k extends p {
   selectedValue;
-  constructor(tagName = "option") {
-    super(tagName);
+  constructor(e = "option") {
+    super(e);
   }
   get value() {
     return this.getAttribute("value") ?? this.textContent;
   }
-  set value(value) {
-    this.setAttribute("value", value);
+  set value(e) {
+    this.setAttribute("value", e);
   }
   get text() {
     return this.textContent;
@@ -1209,130 +1013,106 @@ class HTMLOptionElement extends HTMLElement {
   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);
-          }
-        }
+  set selected(e) {
+    if (this.setSelectedRaw(e), e) {
+      let t = this.parentElement;
+      if (t instanceof P && !t.multiple) {
+        for (let n of t.options.toArray())
+          if (n !== this)
+            n.setSelectedRaw(false);
       }
     }
   }
-  setSelectedRaw(value) {
-    this.selectedValue = value;
-    if (value) {
+  setSelectedRaw(e) {
+    if (this.selectedValue = e, e)
       this.setAttribute("selected", "");
-    } else {
+    else
       this.removeAttribute("selected");
-    }
   }
   hasSelectedValue() {
-    if (this.selectedValue !== undefined) {
+    if (this.selectedValue !== undefined)
       return this.selectedValue;
-    }
     return this.hasAttribute("selected");
   }
 }
 
-class HTMLSelectElement extends HTMLElement {
-  constructor(tagName = "select") {
-    super(tagName);
+class P extends p {
+  constructor(e = "select") {
+    super(e);
   }
   get multiple() {
     return this.hasAttribute("multiple");
   }
-  set multiple(value) {
-    if (value) {
+  set multiple(e) {
+    if (e)
       this.setAttribute("multiple", "");
-    } else {
+    else
       this.removeAttribute("multiple");
-    }
   }
   get options() {
-    const options = [];
-    collectElements(this, (element) => {
-      if (element instanceof HTMLOptionElement) {
-        options.push(element);
-      }
-    });
-    return new HTMLOptionsCollection(options);
+    let e = [];
+    return N(this, (t) => {
+      if (t instanceof k)
+        e.push(t);
+    }), new Q(e);
   }
   get selectedOptions() {
-    return new NodeList(this.options.toArray().filter((option) => option.hasSelectedValue()));
+    return new f(this.options.toArray().filter((e) => e.hasSelectedValue()));
   }
   get selectedIndex() {
-    return this.options.toArray().findIndex((option) => option.hasSelectedValue());
+    return this.options.toArray().findIndex((e) => e.hasSelectedValue());
   }
-  set selectedIndex(index) {
-    const options = this.options.toArray();
-    options.forEach((option, optionIndex) => option.setSelectedRaw(optionIndex === index));
+  set selectedIndex(e) {
+    this.options.toArray().forEach((n, i) => n.setSelectedRaw(i === e));
   }
   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;
-    }
+    let e = this.options.toArray(), t = e.find((n) => n.hasSelectedValue());
+    if (t)
+      return t.value;
+    if (!this.multiple && e.length > 0)
+      return e[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);
-          }
+  set value(e) {
+    let t = this.options.toArray();
+    for (let n of t)
+      if (n.value === e)
+        if (this.multiple)
+          n.setSelectedRaw(true);
+        else {
+          for (let r of t)
+            r.setSelectedRaw(r === n);
           return;
         }
-      }
-    }
   }
-  add(option) {
-    this.appendChild(option);
+  add(e) {
+    this.appendChild(e);
   }
-  removeOption(index) {
-    const options = this.options.toArray();
-    const option = options[index];
-    if (option) {
-      option.remove();
-    }
+  removeOption(e) {
+    let n = this.options.toArray()[e];
+    if (n)
+      n.remove();
   }
 }
 
-class HTMLOptionsCollection {
+class Q {
   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]
-      });
-    }
+  constructor(e) {
+    this.items = e;
+    for (let t = 0;t < e.length; t += 1)
+      Object.defineProperty(this, String(t), { configurable: true, enumerable: true, get: () => this.items[t] });
   }
   get length() {
     return this.items.length;
   }
-  item(index) {
-    return this.items[index] ?? null;
+  item(e) {
+    return this.items[e] ?? null;
   }
   get value() {
-    return this.items.find((option) => option.hasSelectedValue())?.value ?? "";
+    return this.items.find((e) => e.hasSelectedValue())?.value ?? "";
   }
   get selectedIndex() {
-    return this.items.findIndex((option) => option.hasSelectedValue());
+    return this.items.findIndex((e) => e.hasSelectedValue());
   }
   toArray() {
     return [...this.items];
@@ -1342,29 +1122,29 @@ class HTMLOptionsCollection {
   }
 }
 
-class HTMLInputElement extends HTMLElement {
+class U extends p {
   inputValue;
   checkedValue;
-  constructor(tagName = "input") {
-    super(tagName);
+  constructor(e = "input") {
+    super(e);
   }
   get type() {
     return this.getAttribute("type") ?? "text";
   }
-  set type(value) {
-    this.setAttribute("type", value);
+  set type(e) {
+    this.setAttribute("type", e);
   }
   get name() {
     return this.getAttribute("name") ?? "";
   }
-  set name(value) {
-    this.setAttribute("name", value);
+  set name(e) {
+    this.setAttribute("name", e);
   }
   get value() {
     return this.inputValue ?? this.getAttribute("value") ?? "";
   }
-  set value(value) {
-    this.inputValue = value;
+  set value(e) {
+    this.inputValue = e;
   }
   get defaultValue() {
     return this.getAttribute("value") ?? "";
@@ -1372,168 +1152,154 @@ class HTMLInputElement extends HTMLElement {
   get checked() {
     return this.checkedValue ?? this.hasAttribute("checked");
   }
-  set checked(value) {
-    this.checkedValue = value;
+  set checked(e) {
+    this.checkedValue = e;
   }
   get disabled() {
     return this.hasAttribute("disabled");
   }
-  set disabled(value) {
-    if (value) {
+  set disabled(e) {
+    if (e)
       this.setAttribute("disabled", "");
-    } else {
+    else
       this.removeAttribute("disabled");
-    }
   }
   createClone() {
-    const clone = super.createClone();
-    clone.inputValue = this.inputValue;
-    clone.checkedValue = this.checkedValue;
-    return clone;
+    let e = super.createClone();
+    return e.inputValue = this.inputValue, e.checkedValue = this.checkedValue, e;
   }
 }
 
-class HTMLTextAreaElement extends HTMLElement {
+class B extends p {
   textareaValue;
-  constructor(tagName = "textarea") {
-    super(tagName);
+  constructor(e = "textarea") {
+    super(e);
   }
   get value() {
     return this.textareaValue ?? this.textContent;
   }
-  set value(value) {
-    this.textareaValue = value;
+  set value(e) {
+    this.textareaValue = e;
   }
 }
 
-class HTMLButtonElement extends HTMLElement {
-  constructor(tagName = "button") {
-    super(tagName);
+class W extends p {
+  constructor(e = "button") {
+    super(e);
   }
   get type() {
     return this.getAttribute("type") ?? "submit";
   }
 }
 
-class HTMLStyleElement extends HTMLElement {
-  constructor(tagName = "style") {
-    super(tagName);
+class z extends p {
+  constructor(e = "style") {
+    super(e);
   }
 }
 
-class HTMLAnchorElement extends HTMLElement {
-  constructor(tagName = "a") {
-    super(tagName);
+class G extends p {
+  constructor(e = "a") {
+    super(e);
   }
   get href() {
     return this.getAttribute("href") ?? "";
   }
-  set href(value) {
-    this.setAttribute("href", value);
+  set href(e) {
+    this.setAttribute("href", e);
   }
 }
 
-class Text extends Node {
+class u extends b {
   data;
-  constructor(data = "") {
+  constructor(e = "") {
     super(3, "#text");
-    this.data = data;
+    this.data = e;
   }
   get nodeValue() {
     return this.data;
   }
-  set nodeValue(value) {
-    this.data = value;
+  set nodeValue(e) {
+    this.data = e;
   }
   get textContent() {
     return this.data;
   }
-  set textContent(value) {
-    this.data = value;
+  set textContent(e) {
+    this.data = e;
   }
   get wholeText() {
     return this.data;
   }
   createClone() {
-    const clone = new Text(this.data);
-    clone.ownerDocument = this.ownerDocument;
-    return clone;
+    let e = new u(this.data);
+    return e.ownerDocument = this.ownerDocument, e;
   }
 }
 
-class Comment extends Node {
+class w extends b {
   data;
-  constructor(data = "") {
+  constructor(e = "") {
     super(8, "#comment");
-    this.data = data;
+    this.data = e;
   }
   get nodeValue() {
     return this.data;
   }
-  set nodeValue(value) {
-    this.data = value;
+  set nodeValue(e) {
+    this.data = e;
   }
   createClone() {
-    const clone = new Comment(this.data);
-    clone.ownerDocument = this.ownerDocument;
-    return clone;
+    let e = new w(this.data);
+    return e.ownerDocument = this.ownerDocument, e;
   }
 }
 
-class DocumentFragment extends Node {
+class _ extends b {
   constructor() {
     super(11, "#document-fragment");
   }
 }
 
-class Document extends Node {
+class S extends b {
   defaultView = null;
   constructor() {
     super(9, "#document");
   }
-  createElement(tagName) {
-    return createElementForTag(tagName, this);
+  createElement(e) {
+    return m(e, this);
   }
-  createElementNS(namespaceURI, tagName) {
-    const element = createElementForTag(tagName, this);
-    element.namespaceURI = namespaceURI;
-    return element;
+  createElementNS(e, t) {
+    let n = m(t, this);
+    return n.namespaceURI = e, n;
   }
-  createTextNode(data) {
-    const text = new Text(data);
-    text.ownerDocument = this;
-    return text;
+  createTextNode(e) {
+    let t = new u(e);
+    return t.ownerDocument = this, t;
   }
-  createComment(data) {
-    const comment = new Comment(data);
-    comment.ownerDocument = this;
-    return comment;
+  createComment(e) {
+    let t = new w(e);
+    return t.ownerDocument = this, t;
   }
   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("");
+    let e = new _;
+    return e.ownerDocument = this, e;
+  }
+  createEvent(e) {
+    if (e === "MouseEvent" || e === "mouseevent")
+      return new O("");
+    if (e === "KeyboardEvent" || e === "keyboardevent")
+      return new H("");
+    if (e === "CustomEvent" || e === "customevent")
+      return new I("");
+    return new c("");
   }
   get documentElement() {
-    const html = this.childList.find((child) => child.nodeType === 1);
-    if (html) {
-      return html;
-    }
-    const created = createElementForTag("html", this);
-    this.appendChild(created);
-    return created;
+    let e = this.childList.find((n) => n.nodeType === 1);
+    if (e)
+      return e;
+    let t = m("html", this);
+    return this.appendChild(t), t;
   }
   get head() {
     return this.ensureDocumentChild("head");
@@ -1542,59 +1308,51 @@ class Document extends Node {
     return this.ensureDocumentChild("body");
   }
   get title() {
-    const titleElement = this.querySelector("title");
-    return titleElement?.textContent ?? "";
+    return this.querySelector("title")?.textContent ?? "";
   }
-  set title(value) {
-    let titleElement = this.querySelector("title");
-    if (!titleElement) {
-      titleElement = createElementForTag("title", this);
-      this.head.appendChild(titleElement);
-    }
-    titleElement.textContent = value;
+  set title(e) {
+    let t = this.querySelector("title");
+    if (!t)
+      t = m("title", this), this.head.appendChild(t);
+    t.textContent = e;
   }
-  querySelector(selector) {
-    return querySelectorAll(this, selector).item(0);
+  querySelector(e) {
+    return C(this, e).item(0);
   }
-  querySelectorAll(selector) {
-    return querySelectorAll(this, selector);
+  querySelectorAll(e) {
+    return C(this, e);
   }
-  getElementById(id) {
-    let result = null;
-    collectElements(this, (element) => {
-      if (!result && element.id === id) {
-        result = element;
-      }
-    });
-    return result;
+  getElementById(e) {
+    let t = null;
+    return N(this, (n) => {
+      if (!t && n.id === e)
+        t = n;
+    }), t;
   }
-  getElementsByTagName(tagName) {
-    return this.documentElement.getElementsByTagName(tagName);
+  getElementsByTagName(e) {
+    return this.documentElement.getElementsByTagName(e);
   }
   createClone() {
-    return new Document;
+    return new S;
   }
-  ensureDocumentChild(tagName) {
-    const documentElement = this.documentElement;
-    let child = documentElement.childList.find((node) => node.nodeType === 1 && node.localName === tagName);
-    if (!child) {
-      child = createElementForTag(tagName, this);
-      documentElement.appendChild(child);
-    }
-    return child;
+  ensureDocumentChild(e) {
+    let t = this.documentElement, n = t.childList.find((i) => i.nodeType === 1 && i.localName === e);
+    if (!n)
+      n = m(e, this), t.appendChild(n);
+    return n;
   }
 }
 
-class Location {
+class Y {
   url;
-  constructor(url) {
-    this.url = new URL(url);
+  constructor(e) {
+    this.url = new URL(e);
   }
   get href() {
     return this.url.href;
   }
-  set href(value) {
-    this.url = new URL(value, this.url.href);
+  set href(e) {
+    this.url = new URL(e, this.url.href);
   }
   get origin() {
     return this.url.origin;
@@ -1614,23 +1372,22 @@ class Location {
   get pathname() {
     return this.url.pathname;
   }
-  set pathname(value) {
-    const url = this.url;
-    const next = new URL(value, url.href);
-    url.pathname = next.pathname;
+  set pathname(e) {
+    let t = this.url, n = new URL(e, t.href);
+    t.pathname = n.pathname;
   }
   get search() {
     return this.url.search;
   }
-  set search(value) {
-    this.url.search = value.startsWith("?") ? value : `?${value}`;
+  set search(e) {
+    this.url.search = e.startsWith("?") ? e : `?${e}`;
   }
   get hash() {
     return this.url.hash;
   }
-  set hash(value) {
-    const nextHash = value.startsWith("#") ? value : `#${value}`;
-    this.url.hash = nextHash;
+  set hash(e) {
+    let t = e.startsWith("#") ? e : `#${e}`;
+    this.url.hash = t;
   }
   get username() {
     return this.url.username;
@@ -1638,11 +1395,11 @@ class Location {
   get password() {
     return this.url.password;
   }
-  assign(value) {
-    this.url = new URL(value, this.url.href);
+  assign(e) {
+    this.url = new URL(e, this.url.href);
   }
-  replace(value) {
-    this.url = new URL(value, this.url.href);
+  replace(e) {
+    this.url = new URL(e, this.url.href);
   }
   reload() {}
   toString() {
@@ -1652,19 +1409,18 @@ class Location {
     return this.url.hash.slice(1);
   }
   getHrefWithoutHash() {
-    const url = this.url;
-    return `${url.origin}${url.pathname}${url.search}`;
+    let e = this.url;
+    return `${e.origin}${e.pathname}${e.search}`;
   }
 }
 
-class History {
+class J {
   windowRef;
   entries = [];
   index = 0;
   scrollRestoration = "auto";
-  constructor(windowRef) {
-    this.windowRef = windowRef;
-    this.entries = [{ state: null, url: windowRef.location.href }];
+  constructor(e) {
+    this.windowRef = e, this.entries = [{ state: null, url: e.location.href }];
   }
   get length() {
     return this.entries.length;
@@ -1672,17 +1428,13 @@ class History {
   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);
+  pushState(e, t, n) {
+    let i = n ? new URL(n, this.windowRef.location.href).href : this.windowRef.location.href;
+    this.entries = this.entries.slice(0, this.index + 1), this.entries.push({ state: e, url: i }), this.index = this.entries.length - 1, this.windowRef.setLocationUrl(i);
   }
-  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);
+  replaceState(e, t, n) {
+    let i = n ? new URL(n, this.windowRef.location.href).href : this.windowRef.location.href;
+    this.entries[this.index] = { state: e, url: i }, this.windowRef.setLocationUrl(i);
   }
   back() {
     this.go(-1);
@@ -1690,673 +1442,483 @@ class History {
   forward() {
     this.go(1);
   }
-  go(delta = 0) {
-    const nextIndex = this.index + delta;
-    if (nextIndex < 0 || nextIndex >= this.entries.length) {
+  go(e = 0) {
+    let t = this.index + e;
+    if (t < 0 || t >= this.entries.length)
       return;
-    }
-    this.index = nextIndex;
-    this.windowRef.setLocationUrl(this.entries[nextIndex].url);
-    this.windowRef.dispatchEvent(new Event("popstate", { bubbles: false, cancelable: false }));
+    this.index = t, this.windowRef.setLocationUrl(this.entries[t].url), this.windowRef.dispatchEvent(new c("popstate", { bubbles: false, cancelable: false }));
   }
 }
 
-class Storage {
+class ee {
   store = new Map;
   get length() {
     return this.store.size;
   }
-  key(index) {
-    return [...this.store.keys()][index] ?? null;
+  key(e) {
+    return [...this.store.keys()][e] ?? null;
   }
-  getItem(key) {
-    return this.store.has(key) ? this.store.get(key) : null;
+  getItem(e) {
+    return this.store.has(e) ? this.store.get(e) : null;
   }
-  setItem(key, value) {
-    this.store.set(key, String(value));
+  setItem(e, t) {
+    this.store.set(e, String(t));
   }
-  removeItem(key) {
-    this.store.delete(key);
+  removeItem(e) {
+    this.store.delete(e);
   }
   clear() {
     this.store.clear();
   }
 }
 
-class Navigator {
-  userAgent = "TSone/0.1.0";
+class te {
+  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;
-}
-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"
-];
+function ge(e, t) {
+  let n = new Set, i = false, r = { media: t, matches: false, onchange: null, addEventListener(s, l) {
+    if (s === "change")
+      n.add(l);
+  }, removeEventListener(s, l) {
+    if (s === "change")
+      n.delete(l);
+  }, addListener(s) {
+    n.add(s);
+  }, removeListener(s) {
+    n.delete(s);
+  }, dispatchEvent(s) {
+    for (let l of [...n])
+      if (typeof l === "function")
+        l.call(r, s);
+      else
+        l.handleEvent(s);
+    return true;
+  } };
+  return r;
+}
+var fe = ["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 {
+class ne extends A {
   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 = {}) {
+  localStorage = new ee;
+  navigator = new te;
+  Node = b;
+  Text = u;
+  Comment = w;
+  Element = M;
+  HTMLElement = p;
+  HTMLInputElement = U;
+  HTMLTextAreaElement = B;
+  HTMLSelectElement = P;
+  HTMLButtonElement = W;
+  HTMLOptionElement = k;
+  HTMLStyleElement = z;
+  HTMLAnchorElement = G;
+  DocumentFragment = _;
+  Document = S;
+  Event = c;
+  MouseEvent = O;
+  KeyboardEvent = H;
+  CustomEvent = I;
+  EventTarget = A;
+  DOMException = K;
+  NodeList = f;
+  constructor(e = {}) {
     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);
+    let t = e.url ?? "http://localhost/";
+    this.location = new Y(t), this.history = new J(this), this.document = new S, this.document.defaultView = this, Se(this.document);
   }
-  matchMedia(query) {
-    return createMatchMedia(this, query);
+  matchMedia(e) {
+    return ge(this, e);
   }
-  getComputedStyle(element) {
-    return element.style;
+  getComputedStyle(e) {
+    return e.style;
   }
-  requestAnimationFrame(callback) {
-    return setTimeout(() => callback(Date.now()), 0);
+  requestAnimationFrame(e) {
+    return setTimeout(() => e(Date.now()), 0);
   }
-  cancelAnimationFrame(handle) {
-    clearTimeout(handle);
+  cancelAnimationFrame(e) {
+    clearTimeout(e);
   }
-  setLocationUrl(url) {
-    this.location.href = url;
+  setLocationUrl(e) {
+    this.location.href = e;
   }
   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);
-      }
+    return [...fe];
+  }
+}
+function ke(e = {}) {
+  return new ne(e);
+}
+function Pe(e, t = globalThis) {
+  let n = new Map, i = e.installKeys();
+  for (let r of i)
+    n.set(r, Object.getOwnPropertyDescriptor(t, r));
+  for (let r of i)
+    Object.defineProperty(t, r, { configurable: true, enumerable: true, writable: true, value: e[r] });
+  return Object.defineProperty(t, "window", { configurable: true, enumerable: true, writable: true, value: e }), () => {
+    for (let r of i) {
+      let s = n.get(r);
+      if (s)
+        Object.defineProperty(t, r, s);
+      else
+        Reflect.deleteProperty(t, r);
     }
   };
 }
-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);
+function ye(e, t) {
+  let n = new _;
+  if (t)
+    n.ownerDocument = t;
+  return Ee(n, e, t), [...n.childList];
+}
+function Ee(e, t, n) {
+  let i = [], r = e, s = 0, l = t.length, a = (o) => {
+    if (o.ownerDocument === null)
+      o.ownerDocument = n;
+    r.appendChild(o);
   };
-  while (index < length) {
-    const openIndex = source.indexOf("<", index);
-    if (openIndex < 0) {
-      append(new Text(source.slice(index)));
+  while (s < l) {
+    let o = t.indexOf("<", s);
+    if (o < 0) {
+      a(new u(t.slice(s)));
       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;
+    if (o > s)
+      a(new u(t.slice(s, o)));
+    if (t.startsWith("<!--", o)) {
+      let d = t.indexOf("-->", o + 4), E = d < 0 ? l : d;
+      a(new w(t.slice(o + 4, E))), s = d < 0 ? l : d + 3;
       continue;
     }
-    const tagEnd = findTagEnd(source, openIndex);
-    if (tagEnd < 0) {
-      append(new Text(source.slice(openIndex)));
+    let h = ve(t, o);
+    if (h < 0) {
+      a(new u(t.slice(o)));
       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;
+    let T = t.slice(o + 1, h).trim();
+    if (T.startsWith("/")) {
+      let d = T.slice(1).trim().toLowerCase();
+      if (i.length > 0 && i[i.length - 1].localName === d)
+        i.pop(), r = i[i.length - 1] ?? e;
+      s = h + 1;
       continue;
     }
-    const selfClosing = trimmed.endsWith("/");
-    const parsed = parseTag(trimmed.replace(/\/$/, "").trim());
-    if (!parsed) {
-      index = tagEnd + 1;
+    let ae = T.endsWith("/"), y = we(T.replace(/\/$/, "").trim());
+    if (!y) {
+      s = h + 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;
+    let v = m(y.name, n);
+    for (let d of y.attributes)
+      v.setAttribute(d.name, d.value);
+    if (a(v), ie.has(y.name) || ae) {
+      s = h + 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;
+    if (re.has(y.name)) {
+      let d = `</${y.name}>`, E = t.toLowerCase().indexOf(d, h + 1), j = t.slice(h + 1, E < 0 ? l : E);
+      v.appendChild(n?.createTextNode(j) ?? new u(j)), s = E < 0 ? l : E + d.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;
-      }
+    i.push(v), r = v, s = h + 1;
+  }
+}
+var ie = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
+var re = new Set(["script", "style", "textarea", "title"]);
+function ve(e, t) {
+  let n = null;
+  for (let i = t + 1;i < e.length; i += 1) {
+    let r = e[i];
+    if (n) {
+      if (r === n)
+        n = null;
       continue;
     }
-    if (char === '"' || char === "'") {
-      inQuote = char;
+    if (r === '"' || r === "'") {
+      n = r;
       continue;
     }
-    if (char === ">") {
-      return index;
-    }
+    if (r === ">")
+      return i;
   }
   return -1;
 }
-function parseTag(source) {
-  const match = source.match(/^([a-zA-Z][a-zA-Z0-9-]*)\s*(.*)$/);
-  if (!match) {
+function we(e) {
+  let t = e.match(/^([a-zA-Z][a-zA-Z0-9-]*)\s*(.*)$/);
+  if (!t)
     return null;
+  let n = t[1].toLowerCase(), i = [], r = t[2], s = /([a-zA-Z_:][a-zA-Z0-9_:.-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g, l;
+  while ((l = s.exec(r)) !== null) {
+    let a = l[1], o = l[2] ?? l[3] ?? l[4] ?? "";
+    i.push({ name: a, value: Ne(o) });
   }
-  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 };
+  return { name: n, attributes: i };
 }
-function decodeEntities(value) {
-  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, "\xA0");
+function Ne(e) {
+  return e.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, "\xA0");
 }
-function encodeText(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function se(e) {
+  return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function encodeAttribute(value) {
-  return encodeText(value).replace(/"/g, "&quot;");
+function F(e) {
+  return se(e).replace(/"/g, "&quot;");
 }
-function serializeNode(node) {
-  switch (node.nodeType) {
+function le(e) {
+  switch (e.nodeType) {
     case 3:
-      return encodeText(node.data);
+      return se(e.data);
     case 8:
-      return `<!--${node.data}-->`;
+      return `<!--${e.data}-->`;
     case 1:
-      return serializeElement(node);
+      return Te(e);
     default:
       return "";
   }
 }
-function serializeElement(element) {
-  const tag = element.localName;
-  const attributes = [];
-  for (const entry of element.attributeEntries()) {
-    if (entry.name === "style") {
+function Te(e) {
+  let t = e.localName, n = [];
+  for (let s of e.attributeEntries()) {
+    if (s.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) {
+    n.push(`${s.name}="${F(s.value)}"`);
+  }
+  let i = e.inlineStyleText();
+  if (i)
+    n.push(`style="${F(i)}"`);
+  let r = n.length > 0 ? ` ${n.join(" ")}` : "";
+  if (ie.has(t))
+    return `<${t}${r}>`;
+  if (re.has(t))
+    return `<${t}${r}>${e.textContent}</${t}>`;
+  return `<${t}${r}>${oe(e)}</${t}>`;
+}
+function oe(e) {
+  return e.childList.map((t) => le(t)).join("");
+}
+function xe(e) {
+  return e.split(",").map((t) => {
+    let n = [], i = 0;
+    while (i < t.length) {
+      while (i < t.length && t[i] === " ")
+        i += 1;
+      if (i >= t.length)
         break;
-      }
-      if (group[index] === ">") {
-        segments.push({ type: "child" });
-        index += 1;
+      if (t[i] === ">") {
+        n.push({ type: "child" }), i += 1;
         continue;
       }
-      const start = index;
-      while (index < group.length && group[index] !== " " && group[index] !== ">") {
-        index += 1;
-      }
-      segments.push(parseCompound(group.slice(start, index)));
+      let r = i;
+      while (i < t.length && t[i] !== " " && t[i] !== ">")
+        i += 1;
+      n.push(Le(t.slice(r, i)));
     }
-    return segments;
+    return n;
   });
 }
-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) {
+function Le(e) {
+  let t = [], n = 0;
+  while (n < e.length) {
+    let i = e[n];
+    if (i === "*")
+      t.push({ type: "universal" }), n += 1;
+    else if (i === "#") {
+      let r = V(e, n + 1);
+      t.push({ type: "id", id: e.slice(n + 1, r) }), n = r;
+    } else if (i === ".") {
+      let r = V(e, n + 1);
+      t.push({ type: "class", className: e.slice(n + 1, r) }), n = r;
+    } else if (i === "[") {
+      let r = e.indexOf("]", n), s = e.slice(n + 1, r < 0 ? e.length : r).trim(), l = s.match(/^([a-zA-Z_:][a-zA-Z0-9_:.-]*)(?:([~|^$*]?=)(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?$/);
+      if (l)
+        t.push({ type: "attribute", name: l[1], operator: l[2], value: l[3] ?? l[4] ?? l[5] });
+      else
+        t.push({ type: "attribute", name: s });
+      n = r < 0 ? e.length : r + 1;
+    } else if (/[a-zA-Z_]/.test(i)) {
+      let r = V(e, n);
+      t.push({ type: "tag", name: e.slice(n, r).toLowerCase() }), n = r;
+    } else
+      n += 1;
+  }
+  if (t.length === 1)
+    return t[0];
+  return { type: "compound", parts: t };
+}
+function V(e, t) {
+  let n = t;
+  while (n < e.length && /[a-zA-Z0-9:_-]/.test(e[n]))
+    n += 1;
+  return n;
+}
+function ue(e, t) {
+  return xe(t).some((i) => De(e, i));
+}
+function De(e, t) {
+  let n = t.length - 1;
+  if (n < 0)
     return true;
-  }
-  if (!matchSegment(element, group[index])) {
+  if (!D(e, t[n]))
     return false;
-  }
-  if (index === 0) {
+  if (n === 0)
     return true;
-  }
-  let current = element.parentElement;
-  index -= 1;
-  while (current) {
-    const selector = group[index];
-    if (!selector) {
+  let i = e.parentElement;
+  n -= 1;
+  while (i) {
+    let r = t[n];
+    if (!r)
       return true;
-    }
-    if (selector.type === "child") {
-      const parentSelector = group[index - 1];
-      if (!parentSelector || !matchSegment(current, parentSelector)) {
+    if (r.type === "child") {
+      let s = t[n - 1];
+      if (!s || !D(i, s))
         return false;
-      }
-      index -= 2;
-      if (index < 0) {
+      if (n -= 2, n < 0)
         return true;
-      }
-      current = current.parentElement;
+      i = i.parentElement;
       continue;
     }
-    if (matchSegment(current, selector)) {
-      index -= 1;
-      if (index < 0) {
+    if (D(i, r)) {
+      if (n -= 1, n < 0)
         return true;
-      }
     }
-    current = current.parentElement;
+    i = i.parentElement;
   }
   return false;
 }
-function matchSegment(element, selector) {
-  switch (selector.type) {
+function D(e, t) {
+  switch (t.type) {
     case "universal":
       return true;
     case "tag":
-      return element.localName === selector.name;
+      return e.localName === t.name;
     case "id":
-      return element.id === selector.id;
+      return e.id === t.id;
     case "class":
-      return element.classList.contains(selector.className);
+      return e.classList.contains(t.className);
     case "attribute":
-      return matchAttribute(element, selector);
+      return Ae(e, t);
     case "compound":
-      return selector.parts.every((part) => matchSegment(element, part));
+      return t.parts.every((n) => D(e, n));
     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) {
+function Ae(e, t) {
+  let n = e.getAttribute(t.name);
+  if (!t.operator)
+    return n !== null;
+  if (n === null)
     return false;
-  }
-  const expected = selector.value ?? "";
-  switch (selector.operator) {
+  let i = t.value ?? "";
+  switch (t.operator) {
     case "=":
-      return attributeValue === expected;
+      return n === i;
     case "~=":
-      return attributeValue.split(/\s+/).includes(expected);
+      return n.split(/\s+/).includes(i);
     case "|=":
-      return attributeValue === expected || attributeValue.startsWith(`${expected}-`);
+      return n === i || n.startsWith(`${i}-`);
     case "^=":
-      return attributeValue.startsWith(expected);
+      return n.startsWith(i);
     case "$=":
-      return attributeValue.endsWith(expected);
+      return n.endsWith(i);
     case "*=":
-      return attributeValue.includes(expected);
+      return n.includes(i);
     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) {
-      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)}`);
-      }
+function C(e, t) {
+  let n = [];
+  return N(e, (i) => {
+    if (i !== e && ue(i, t))
+      n.push(i);
+  }), new f(n);
+}
+function N(e, t) {
+  for (let n of e.childList)
+    if (n.nodeType === 1)
+      t(n), N(n, t);
+}
+function m(e, t) {
+  let n = e.toLowerCase(), i;
+  if (n === "input")
+    i = new U(n);
+  else if (n === "textarea")
+    i = new B(n);
+  else if (n === "select")
+    i = new P(n);
+  else if (n === "option")
+    i = new k(n);
+  else if (n === "button")
+    i = new W(n);
+  else if (n === "style")
+    i = new z(n);
+  else if (n === "a")
+    i = new G(n);
+  else
+    i = new p(n);
+  return i.ownerDocument = t, i;
+}
+function Se(e) {
+  let t = e.createElement("html");
+  t.setAttribute("lang", "en"), e.appendChild(t);
+  let n = e.createElement("head"), i = e.createElement("body");
+  t.appendChild(n), t.appendChild(i);
+}
+function Ce(e) {
+  return new Proxy({}, { get(n, i) {
+    if (typeof i === "symbol")
+      return;
+    return e.getAttribute(`data-${g(i)}`) ?? "";
+  }, set(n, i, r) {
+    if (typeof i === "symbol")
       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)}`)
-        };
-      }
+    if (r === "" || r === null || r === undefined)
+      e.removeAttribute(`data-${g(i)}`);
+    else
+      e.setAttribute(`data-${g(i)}`, String(r));
+    return true;
+  }, deleteProperty(n, i) {
+    if (typeof i !== "symbol")
+      e.removeAttribute(`data-${g(i)}`);
+    return true;
+  }, has(n, i) {
+    if (typeof i === "symbol")
+      return false;
+    return e.hasAttribute(`data-${g(i)}`);
+  }, ownKeys() {
+    let n = [];
+    for (let i of e.attributeEntries())
+      if (i.name.startsWith("data-"))
+        n.push(Oe(i.name.slice(5)));
+    return n;
+  }, getOwnPropertyDescriptor(n, i) {
+    if (typeof i === "symbol")
       return;
-    }
-  };
-  return new Proxy({}, handler);
+    if (e.hasAttribute(`data-${g(i)}`))
+      return { configurable: true, enumerable: true, writable: true, value: e.getAttribute(`data-${g(i)}`) };
+    return;
+  } });
 }
-function toKebabCase(value) {
-  return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+function g(e) {
+  return e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
 }
-function toCamelCase(value) {
-  return value.replace(/-([a-z])/g, (_match, char) => char.toUpperCase());
+function Oe(e) {
+  return e.replace(/-([a-z])/g, (t, n) => n.toUpperCase());
 }
 
 // src/project.ts
-var PROJECT_GLOBAL_KEYS = [...DOM_GLOBAL_KEYS, "__APP__"];
+var PROJECT_GLOBAL_KEYS = [...fe, "__APP__"];
 var projectDomQueue = Promise.resolve();
 async function renderProjectHtml(config, options, entry = config.entry) {
   return withProjectDom(async () => {
@@ -2378,7 +1940,7 @@ async function withProjectDom(callback) {
   return task;
 }
 async function runWithProjectDom(callback) {
-  const windowRef = createDomWindow({ url: "http://127.0.0.1/" });
+  const windowRef = ke({ url: "http://127.0.0.1/" });
   Object.assign(windowRef, {
     Error,
     EvalError,
@@ -2390,7 +1952,7 @@ async function runWithProjectDom(callback) {
   });
   const descriptors = captureGlobalDescriptors();
   try {
-    installDomGlobals(windowRef);
+    Pe(windowRef);
     return await callback();
   } finally {
     restoreGlobalDescriptors(descriptors);
@@ -2538,6 +2100,7 @@ async function buildPage(config, route, entry) {
       outdir: config.build.outDir,
       target: "browser",
       format: "esm",
+      minify: process.env.TSONE_MINIFY !== "0",
       naming: { entry: "[name].[ext]", chunk: "[name]-[hash].[ext]" },
       throw: false
     });
@@ -3254,5 +2817,5 @@ function buildFailureResponse() {
 
 export { defineConfig, resolveConfig, build, startDevServer };
 
-//# debugId=41EA177E876A562564756E2164756E21
-//# sourceMappingURL=index-p7jrckn1.js.map
+//# debugId=12585AE602C4C51764756E2164756E21
+//# sourceMappingURL=index-y6qrqbwv.js.map