@geektech/tsone-cli 0.2.1 → 0.3.0

package/dist/index-r68229k4.js

@@ -0,0 +1,2978 @@
+// @bun
+// src/config.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var DEFAULT_CONFIG = {
+  entry: "src/main.ts",
+  server: {
+    host: "127.0.0.1",
+    port: 52211,
+    proxy: {}
+  },
+  build: {
+    outDir: "dist"
+  }
+};
+function defineConfig(config) {
+  return config;
+}
+async function resolveConfig(options = {}) {
+  const root = resolve(options.root ?? process.cwd());
+  const configFile = resolve(root, "tsone.config.ts");
+  const hasInlineConfig = options.config !== undefined;
+  const loadedConfig = hasInlineConfig ? { exists: false } : await loadConfigFile(configFile);
+  let fileConfig = {};
+  if (loadedConfig.exists) {
+    const config2 = loadedConfig.config;
+    validateUserConfig(config2);
+    fileConfig = config2;
+  }
+  if (hasInlineConfig) {
+    validateUserConfig(options.config);
+  }
+  const inlineOverrides = toInlineOverrides(options);
+  validateUserConfig(inlineOverrides);
+  const config = mergeConfig(fileConfig, options.config ?? {}, inlineOverrides);
+  const entry = resolve(root, config.entry);
+  if (!existsSync(entry)) {
+    throw new Error(`Entry file does not exist: ${entry}`);
+  }
+  const pages = await resolvePages(root, entry, config.pages);
+  return {
+    root,
+    ...loadedConfig.exists ? { configFile } : {},
+    entry,
+    pages,
+    server: {
+      host: config.server.host,
+      port: config.server.port,
+      proxy: config.server.proxy
+    },
+    build: {
+      outDir: resolve(root, config.build.outDir)
+    }
+  };
+}
+async function resolvePages(root, entry, pages) {
+  const resolved = { "/": entry };
+  for (const [route, pageEntry] of Object.entries(pages ?? {})) {
+    const normalized = normalizePageRoute(route);
+    const absolute = resolve(root, pageEntry);
+    if (!existsSync(absolute)) {
+      throw new Error(`Page entry file does not exist for "${normalized}": ${absolute}`);
+    }
+    resolved[normalized] = absolute;
+  }
+  return resolved;
+}
+function normalizePageRoute(route) {
+  if (route === "/") {
+    throw new Error('Config pages must not redefine the root page "/"; use config.entry instead');
+  }
+  const normalized = route.replace(/\/+$/, "");
+  if (normalized === "") {
+    throw new Error(`Page route must not be empty: ${route}`);
+  }
+  return normalized;
+}
+var configLoadSequence = 0;
+async function loadConfigFile(configFile) {
+  if (!existsSync(configFile)) {
+    return { exists: false };
+  }
+  configLoadSequence += 1;
+  const module = await import(`${configFile}?tsone_config=${configLoadSequence}`);
+  return { exists: true, config: module.default };
+}
+function toInlineOverrides(options) {
+  const server = {};
+  const build = {};
+  if (options.host !== undefined) {
+    server.host = options.host;
+  }
+  if (options.port !== undefined) {
+    server.port = options.port;
+  }
+  if (options.outDir !== undefined) {
+    build.outDir = options.outDir;
+  }
+  return {
+    ...Object.keys(server).length > 0 ? { server } : {},
+    ...Object.keys(build).length > 0 ? { build } : {}
+  };
+}
+function mergeConfig(...configs) {
+  return configs.reduce((merged, config) => {
+    const server = config.server;
+    const build = config.build;
+    return {
+      entry: config.entry ?? merged.entry,
+      pages: config.pages ?? merged.pages,
+      server: {
+        host: server?.host ?? merged.server.host,
+        port: server?.port ?? merged.server.port,
+        proxy: {
+          ...merged.server.proxy,
+          ...server?.proxy
+        }
+      },
+      build: {
+        outDir: build?.outDir ?? merged.build.outDir
+      }
+    };
+  }, DEFAULT_CONFIG);
+}
+function validateUserConfig(config) {
+  assertRecord(config, "Config");
+  if (config.entry !== undefined && typeof config.entry !== "string") {
+    throw new Error("Config entry must be a string");
+  }
+  if (config.pages !== undefined) {
+    validatePagesConfig(config.pages);
+  }
+  if (config.server !== undefined) {
+    validateServerConfig(config.server);
+  }
+  if (config.build !== undefined) {
+    validateBuildConfig(config.build);
+  }
+}
+function validatePagesConfig(pages) {
+  assertRecord(pages, "Config pages");
+  for (const [route, entry] of Object.entries(pages)) {
+    if (!route.startsWith("/")) {
+      throw new Error(`Page route must start with "/": ${route}`);
+    }
+    if (typeof entry !== "string") {
+      throw new Error(`Page entry for "${route}" must be a string`);
+    }
+  }
+}
+function validateServerConfig(server) {
+  assertRecord(server, "Config server");
+  if (server.host !== undefined && typeof server.host !== "string") {
+    throw new Error("Config server.host must be a string");
+  }
+  const port = server.port;
+  if (port !== undefined && (typeof port !== "number" || !Number.isInteger(port) || port < 0 || port > 65535)) {
+    throw new Error("Config server.port must be an integer between 0 and 65535");
+  }
+  if (server.proxy === undefined) {
+    return;
+  }
+  assertRecord(server.proxy, "Config server.proxy");
+  for (const [prefix, value] of Object.entries(server.proxy)) {
+    if (!prefix.startsWith("/")) {
+      throw new Error(`Proxy prefix must start with "/": ${prefix}`);
+    }
+    const target = getProxyTarget(value);
+    validateProxyTarget(target);
+  }
+}
+function validateBuildConfig(build) {
+  assertRecord(build, "Config build");
+  if (build.outDir !== undefined && typeof build.outDir !== "string") {
+    throw new Error("Config build.outDir must be a string");
+  }
+}
+function getProxyTarget(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  assertRecord(value, "Proxy options");
+  if (typeof value.target !== "string") {
+    throw new Error("Proxy target must be a string");
+  }
+  if (value.changeOrigin !== undefined && typeof value.changeOrigin !== "boolean") {
+    throw new Error("Proxy changeOrigin must be a boolean");
+  }
+  if (value.rewrite !== undefined && typeof value.rewrite !== "function") {
+    throw new Error("Proxy rewrite must be a function");
+  }
+  return value.target;
+}
+function validateProxyTarget(target) {
+  try {
+    const url = new URL(target);
+    if (url.protocol === "http:" || url.protocol === "https:") {
+      return;
+    }
+  } catch {}
+  throw new Error(`Proxy target must use http or https: ${target}`);
+}
+function assertRecord(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    throw new Error(`${name} must be an object`);
+  }
+}
+
+// src/build.ts
+import { mkdir, rm, writeFile } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+
+// src/build-output.ts
+function isEntryJavaScriptOutput(output) {
+  return output.kind === "entry-point" && isJavaScriptPath(output.path);
+}
+function isStylesheetOutput(output) {
+  return /\.css$/i.test(output.path);
+}
+function isJavaScriptPath(path) {
+  return /\.(?:[cm]?js)$/i.test(path);
+}
+
+// ../tsone/dist/dom/index.js
+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 K extends Error {
+  code;
+  constructor(e, t = "Error") {
+    super(e);
+    this.name = t, this.code = 0;
+  }
+}
+
+class A {
+  listenerMap = new Map;
+  addEventListener(e, t, n) {
+    if (!t)
+      return;
+    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;
+    l.push({ listener: t, capture: i, once: r, passive: s });
+  }
+  removeEventListener(e, t, n) {
+    if (!t)
+      return;
+    let i = typeof n === "boolean" ? n : n?.capture ?? false, r = this.listenerMap.get(e);
+    if (!r)
+      return;
+    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(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(e) {
+    return this.listenerMap.get(e) ?? [];
+  }
+}
+
+class c {
+  static NONE = 0;
+  static CAPTURING_PHASE = 1;
+  static AT_TARGET = 2;
+  static BUBBLING_PHASE = 3;
+  type;
+  bubbles;
+  cancelable;
+  composed;
+  target = null;
+  currentTarget = null;
+  eventPhase = c.NONE;
+  defaultPrevented = false;
+  isTrusted = false;
+  timeStamp;
+  cancelBubble = false;
+  dispatched = false;
+  propagationStopped = false;
+  immediateStopped = false;
+  canceled = false;
+  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)
+      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 I extends c {
+  detail;
+  constructor(e, t) {
+    super(e, t);
+    this.detail = t?.detail;
+  }
+}
+
+class O extends c {
+  clientX;
+  clientY;
+  button;
+  buttons;
+  relatedTarget;
+  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 H extends c {
+  key;
+  code;
+  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;
+    t.currentTarget = l, x(l, t, true);
+  }
+  if (!t.propagationPrevented()) {
+    if (t.eventPhase = c.AT_TARGET, t.currentTarget = e, x(e, t, true), !t.immediatePrevented())
+      x(e, t, false);
+  }
+  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;
+      t.currentTarget = l, x(l, t, false);
+    }
+  }
+  return t.eventPhase = c.NONE, t.currentTarget = null, !t.wasCanceled();
+}
+function x(e, t, n) {
+  let i = e.getListeners(t.type);
+  for (let r of [...i]) {
+    if (r.capture !== n)
+      continue;
+    if (t.immediatePrevented())
+      break;
+    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;
+    }
+    let r = i.parentNode;
+    if (r) {
+      n = r;
+      continue;
+    }
+    break;
+  }
+  return t;
+}
+
+class X {
+  element;
+  attributeName;
+  constructor(e, t = "class") {
+    this.element = e, this.attributeName = t;
+  }
+  get length() {
+    return this.tokens().length;
+  }
+  get value() {
+    return this.element.getAttribute(this.attributeName) ?? "";
+  }
+  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;
+    return n[i] = t, this.setTokens(n), true;
+  }
+  [Symbol.iterator]() {
+    return this.tokens()[Symbol.iterator]();
+  }
+  forEach(e) {
+    this.tokens().forEach((t, n) => e(t, n, this));
+  }
+  toString() {
+    return this.value;
+  }
+  tokens() {
+    return q(this.element.getAttribute(this.attributeName) ?? "");
+  }
+  setTokens(e) {
+    let t = e.filter(Boolean).join(" ");
+    if (t)
+      this.element.setAttribute(this.attributeName, t);
+    else
+      this.element.removeAttribute(this.attributeName);
+  }
+}
+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;
+    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 be(e) {
+  return e.replace(/-([a-z])/g, (t, n) => n.toUpperCase());
+}
+
+class f {
+  items;
+  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(e) {
+    return this.items[e] ?? null;
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  forEach(e) {
+    this.items.forEach((t, n) => e(t, n, this));
+  }
+  entries() {
+    return this.items.entries();
+  }
+  keys() {
+    return this.items.keys();
+  }
+  values() {
+    return this.items.values();
+  }
+  toArray() {
+    return [...this.items];
+  }
+}
+
+class b extends A {
+  static ELEMENT_NODE = 1;
+  static TEXT_NODE = 3;
+  static COMMENT_NODE = 8;
+  static DOCUMENT_NODE = 9;
+  static DOCUMENT_FRAGMENT_NODE = 11;
+  nodeType;
+  nodeName;
+  parentNode = null;
+  ownerDocument = null;
+  childList = [];
+  constructor(e, t) {
+    super();
+    this.nodeType = e, this.nodeName = t;
+  }
+  get parentElement() {
+    let e = this.parentNode;
+    return e instanceof M ? e : null;
+  }
+  get childNodes() {
+    return new f([...this.childList]);
+  }
+  get firstChild() {
+    return this.childList[0] ?? null;
+  }
+  get lastChild() {
+    return this.childList[this.childList.length - 1] ?? null;
+  }
+  get nextSibling() {
+    let e = this.parentNode;
+    if (!e)
+      return null;
+    let t = e.childList.indexOf(this);
+    return t >= 0 ? e.childList[t + 1] ?? null : null;
+  }
+  get previousSibling() {
+    let e = this.parentNode;
+    if (!e)
+      return null;
+    let t = e.childList.indexOf(this);
+    return t > 0 ? e.childList[t - 1] : null;
+  }
+  get textContent() {
+    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(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(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 t = e;
+    while (t) {
+      if (t === this)
+        return true;
+      t = t.parentNode;
+    }
+    return false;
+  }
+  remove() {
+    this.parentNode?.removeChild(this);
+  }
+  cloneNode(e = false) {
+    let t = this.createClone();
+    if (e)
+      for (let n of this.childList)
+        t.appendChild(n.cloneNode(true));
+    return t;
+  }
+  createClone() {
+    let e = new b(this.nodeType, this.nodeName);
+    return e.ownerDocument = this.ownerDocument, e;
+  }
+  getRootNode() {
+    if (!this.parentNode)
+      return this;
+    let e = this.parentNode;
+    while (e.parentNode)
+      e = e.parentNode;
+    return e;
+  }
+  isConnected() {
+    return this.getRootNode().nodeType === 9;
+  }
+}
+
+class M extends b {
+  namespaceURI;
+  attributeList = [];
+  styleValue;
+  classListValue;
+  datasetProxy;
+  constructor(e, t = null) {
+    super(1, e.toUpperCase());
+    this.namespaceURI = t;
+  }
+  get tagName() {
+    return this.nodeName;
+  }
+  get localName() {
+    return this.nodeName.toLowerCase();
+  }
+  get id() {
+    return this.getAttribute("id") ?? "";
+  }
+  set id(e) {
+    this.setAttribute("id", e);
+  }
+  get className() {
+    return this.getAttribute("class") ?? "";
+  }
+  set className(e) {
+    this.setAttribute("class", e);
+  }
+  get classList() {
+    if (!this.classListValue)
+      this.classListValue = new X(this, "class");
+    return this.classListValue;
+  }
+  get style() {
+    if (!this.styleValue)
+      this.styleValue = R();
+    return this.styleValue;
+  }
+  get dataset() {
+    if (!this.datasetProxy)
+      this.datasetProxy = Ce(this);
+    return this.datasetProxy;
+  }
+  get children() {
+    return new f(this.childList.filter((e) => e.nodeType === 1));
+  }
+  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 Z(this);
+  }
+  getAttribute(e) {
+    let t = this.findAttribute(e);
+    return t ? t.value : null;
+  }
+  getAttributeNames() {
+    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 oe(this);
+  }
+  set innerHTML(e) {
+    this.replaceChildren(...ye(e, this.ownerDocument));
+  }
+  get outerHTML() {
+    return le(this);
+  }
+  get value() {
+    return this.getAttribute("value") ?? "";
+  }
+  set value(e) {
+    this.setAttribute("value", e);
+  }
+  querySelector(e) {
+    return C(this, e).item(0);
+  }
+  querySelectorAll(e) {
+    return C(this, e);
+  }
+  getElementsByTagName(e) {
+    let t = e.toLowerCase(), n = [];
+    return N(this, (i) => {
+      if (i.localName === t)
+        n.push(i);
+    }), new f(n);
+  }
+  matches(e) {
+    return ue(this, e);
+  }
+  closest(e) {
+    if (this.matches(e))
+      return this;
+    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 };
+    } };
+  }
+  scrollIntoView() {}
+  focus() {}
+  blur() {}
+  click() {
+    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 (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;
+    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;
+    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(e, t, n) {
+    this.setAttribute(t, n);
+  }
+  removeAttributeNS(e, t) {
+    this.removeAttribute(t);
+  }
+  hasAttributeNS(e, t) {
+    return this.hasAttribute(t);
+  }
+  getAttributeNS(e, t) {
+    return this.getAttribute(t);
+  }
+  findAttribute(e) {
+    return this.attributeList.find((t) => t.name === e);
+  }
+  attributeEntries() {
+    return [...this.attributeList];
+  }
+  inlineStyleText() {
+    return this.styleValue?.cssText ?? "";
+  }
+  createClone() {
+    let e = m(this.localName, this.ownerDocument);
+    for (let t of this.attributeList)
+      e.setAttribute(t.name, t.value);
+    return e;
+  }
+}
+
+class p extends M {
+  constructor(e) {
+    super(e);
+  }
+}
+
+class Z {
+  element;
+  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(e) {
+    return this.element.attributeEntries()[e] ?? null;
+  }
+  getNamedItem(e) {
+    return this.element.findAttribute(e) ?? null;
+  }
+  setNamedItem(e) {
+    this.element.setAttribute(e.name, e.value);
+  }
+  removeNamedItem(e) {
+    this.element.removeAttribute(e);
+  }
+  [Symbol.iterator]() {
+    return this.element.attributeEntries()[Symbol.iterator]();
+  }
+}
+
+class k extends p {
+  selectedValue;
+  constructor(e = "option") {
+    super(e);
+  }
+  get value() {
+    return this.getAttribute("value") ?? this.textContent;
+  }
+  set value(e) {
+    this.setAttribute("value", e);
+  }
+  get text() {
+    return this.textContent;
+  }
+  get label() {
+    return this.getAttribute("label") ?? this.textContent;
+  }
+  get selected() {
+    return this.hasSelectedValue();
+  }
+  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(e) {
+    if (this.selectedValue = e, e)
+      this.setAttribute("selected", "");
+    else
+      this.removeAttribute("selected");
+  }
+  hasSelectedValue() {
+    if (this.selectedValue !== undefined)
+      return this.selectedValue;
+    return this.hasAttribute("selected");
+  }
+}
+
+class P extends p {
+  constructor(e = "select") {
+    super(e);
+  }
+  get multiple() {
+    return this.hasAttribute("multiple");
+  }
+  set multiple(e) {
+    if (e)
+      this.setAttribute("multiple", "");
+    else
+      this.removeAttribute("multiple");
+  }
+  get options() {
+    let e = [];
+    return N(this, (t) => {
+      if (t instanceof k)
+        e.push(t);
+    }), new Q(e);
+  }
+  get selectedOptions() {
+    return new f(this.options.toArray().filter((e) => e.hasSelectedValue()));
+  }
+  get selectedIndex() {
+    return this.options.toArray().findIndex((e) => e.hasSelectedValue());
+  }
+  set selectedIndex(e) {
+    this.options.toArray().forEach((n, i) => n.setSelectedRaw(i === e));
+  }
+  get 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(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(e) {
+    this.appendChild(e);
+  }
+  removeOption(e) {
+    let n = this.options.toArray()[e];
+    if (n)
+      n.remove();
+  }
+}
+
+class Q {
+  items;
+  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(e) {
+    return this.items[e] ?? null;
+  }
+  get value() {
+    return this.items.find((e) => e.hasSelectedValue())?.value ?? "";
+  }
+  get selectedIndex() {
+    return this.items.findIndex((e) => e.hasSelectedValue());
+  }
+  toArray() {
+    return [...this.items];
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+}
+
+class U extends p {
+  inputValue;
+  checkedValue;
+  constructor(e = "input") {
+    super(e);
+  }
+  get type() {
+    return this.getAttribute("type") ?? "text";
+  }
+  set type(e) {
+    this.setAttribute("type", e);
+  }
+  get name() {
+    return this.getAttribute("name") ?? "";
+  }
+  set name(e) {
+    this.setAttribute("name", e);
+  }
+  get value() {
+    return this.inputValue ?? this.getAttribute("value") ?? "";
+  }
+  set value(e) {
+    this.inputValue = e;
+  }
+  get defaultValue() {
+    return this.getAttribute("value") ?? "";
+  }
+  get checked() {
+    return this.checkedValue ?? this.hasAttribute("checked");
+  }
+  set checked(e) {
+    this.checkedValue = e;
+  }
+  get disabled() {
+    return this.hasAttribute("disabled");
+  }
+  set disabled(e) {
+    if (e)
+      this.setAttribute("disabled", "");
+    else
+      this.removeAttribute("disabled");
+  }
+  createClone() {
+    let e = super.createClone();
+    return e.inputValue = this.inputValue, e.checkedValue = this.checkedValue, e;
+  }
+}
+
+class B extends p {
+  textareaValue;
+  constructor(e = "textarea") {
+    super(e);
+  }
+  get value() {
+    return this.textareaValue ?? this.textContent;
+  }
+  set value(e) {
+    this.textareaValue = e;
+  }
+}
+
+class W extends p {
+  constructor(e = "button") {
+    super(e);
+  }
+  get type() {
+    return this.getAttribute("type") ?? "submit";
+  }
+}
+
+class z extends p {
+  constructor(e = "style") {
+    super(e);
+  }
+}
+
+class G extends p {
+  constructor(e = "a") {
+    super(e);
+  }
+  get href() {
+    return this.getAttribute("href") ?? "";
+  }
+  set href(e) {
+    this.setAttribute("href", e);
+  }
+}
+
+class u extends b {
+  data;
+  constructor(e = "") {
+    super(3, "#text");
+    this.data = e;
+  }
+  get nodeValue() {
+    return this.data;
+  }
+  set nodeValue(e) {
+    this.data = e;
+  }
+  get textContent() {
+    return this.data;
+  }
+  set textContent(e) {
+    this.data = e;
+  }
+  get wholeText() {
+    return this.data;
+  }
+  createClone() {
+    let e = new u(this.data);
+    return e.ownerDocument = this.ownerDocument, e;
+  }
+}
+
+class w extends b {
+  data;
+  constructor(e = "") {
+    super(8, "#comment");
+    this.data = e;
+  }
+  get nodeValue() {
+    return this.data;
+  }
+  set nodeValue(e) {
+    this.data = e;
+  }
+  createClone() {
+    let e = new w(this.data);
+    return e.ownerDocument = this.ownerDocument, e;
+  }
+}
+
+class _ extends b {
+  constructor() {
+    super(11, "#document-fragment");
+  }
+}
+
+class S extends b {
+  defaultView = null;
+  constructor() {
+    super(9, "#document");
+  }
+  createElement(e) {
+    return m(e, this);
+  }
+  createElementNS(e, t) {
+    let n = m(t, this);
+    return n.namespaceURI = e, n;
+  }
+  createTextNode(e) {
+    let t = new u(e);
+    return t.ownerDocument = this, t;
+  }
+  createComment(e) {
+    let t = new w(e);
+    return t.ownerDocument = this, t;
+  }
+  createDocumentFragment() {
+    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() {
+    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");
+  }
+  get body() {
+    return this.ensureDocumentChild("body");
+  }
+  get title() {
+    return this.querySelector("title")?.textContent ?? "";
+  }
+  set title(e) {
+    let t = this.querySelector("title");
+    if (!t)
+      t = m("title", this), this.head.appendChild(t);
+    t.textContent = e;
+  }
+  querySelector(e) {
+    return C(this, e).item(0);
+  }
+  querySelectorAll(e) {
+    return C(this, e);
+  }
+  getElementById(e) {
+    let t = null;
+    return N(this, (n) => {
+      if (!t && n.id === e)
+        t = n;
+    }), t;
+  }
+  getElementsByTagName(e) {
+    return this.documentElement.getElementsByTagName(e);
+  }
+  createClone() {
+    return new S;
+  }
+  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 Y {
+  url;
+  constructor(e) {
+    this.url = new URL(e);
+  }
+  get href() {
+    return this.url.href;
+  }
+  set href(e) {
+    this.url = new URL(e, 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(e) {
+    let t = this.url, n = new URL(e, t.href);
+    t.pathname = n.pathname;
+  }
+  get search() {
+    return this.url.search;
+  }
+  set search(e) {
+    this.url.search = e.startsWith("?") ? e : `?${e}`;
+  }
+  get hash() {
+    return this.url.hash;
+  }
+  set hash(e) {
+    let t = e.startsWith("#") ? e : `#${e}`;
+    this.url.hash = t;
+  }
+  get username() {
+    return this.url.username;
+  }
+  get password() {
+    return this.url.password;
+  }
+  assign(e) {
+    this.url = new URL(e, this.url.href);
+  }
+  replace(e) {
+    this.url = new URL(e, this.url.href);
+  }
+  reload() {}
+  toString() {
+    return this.url.href;
+  }
+  getHashPath() {
+    return this.url.hash.slice(1);
+  }
+  getHrefWithoutHash() {
+    let e = this.url;
+    return `${e.origin}${e.pathname}${e.search}`;
+  }
+}
+
+class J {
+  windowRef;
+  entries = [];
+  index = 0;
+  scrollRestoration = "auto";
+  constructor(e) {
+    this.windowRef = e, this.entries = [{ state: null, url: e.location.href }];
+  }
+  get length() {
+    return this.entries.length;
+  }
+  get state() {
+    return this.entries[this.index]?.state ?? null;
+  }
+  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(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);
+  }
+  forward() {
+    this.go(1);
+  }
+  go(e = 0) {
+    let t = this.index + e;
+    if (t < 0 || t >= this.entries.length)
+      return;
+    this.index = t, this.windowRef.setLocationUrl(this.entries[t].url), this.windowRef.dispatchEvent(new c("popstate", { bubbles: false, cancelable: false }));
+  }
+}
+
+class ee {
+  store = new Map;
+  get length() {
+    return this.store.size;
+  }
+  key(e) {
+    return [...this.store.keys()][e] ?? null;
+  }
+  getItem(e) {
+    return this.store.has(e) ? this.store.get(e) : null;
+  }
+  setItem(e, t) {
+    this.store.set(e, String(t));
+  }
+  removeItem(e) {
+    this.store.delete(e);
+  }
+  clear() {
+    this.store.clear();
+  }
+}
+
+class te {
+  userAgent = "TSone/0.2.1";
+  platform = "TSone";
+  language = "zh-CN";
+  languages = ["zh-CN"];
+  onLine = true;
+  maxTouchPoints = 0;
+}
+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 ne extends A {
+  window = this;
+  document;
+  location;
+  history;
+  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();
+    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(e) {
+    return ge(this, e);
+  }
+  getComputedStyle(e) {
+    return e.style;
+  }
+  requestAnimationFrame(e) {
+    return setTimeout(() => e(Date.now()), 0);
+  }
+  cancelAnimationFrame(e) {
+    clearTimeout(e);
+  }
+  setLocationUrl(e) {
+    this.location.href = e;
+  }
+  installKeys() {
+    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 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 (s < l) {
+    let o = t.indexOf("<", s);
+    if (o < 0) {
+      a(new u(t.slice(s)));
+      break;
+    }
+    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;
+    }
+    let h = ve(t, o);
+    if (h < 0) {
+      a(new u(t.slice(o)));
+      break;
+    }
+    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;
+    }
+    let ae = T.endsWith("/"), y = we(T.replace(/\/$/, "").trim());
+    if (!y) {
+      s = h + 1;
+      continue;
+    }
+    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 (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;
+    }
+    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 (r === '"' || r === "'") {
+      n = r;
+      continue;
+    }
+    if (r === ">")
+      return i;
+  }
+  return -1;
+}
+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) });
+  }
+  return { name: n, attributes: i };
+}
+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 se(e) {
+  return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function F(e) {
+  return se(e).replace(/"/g, "&quot;");
+}
+function le(e) {
+  switch (e.nodeType) {
+    case 3:
+      return se(e.data);
+    case 8:
+      return `<!--${e.data}-->`;
+    case 1:
+      return Te(e);
+    default:
+      return "";
+  }
+}
+function Te(e) {
+  let t = e.localName, n = [];
+  for (let s of e.attributeEntries()) {
+    if (s.name === "style")
+      continue;
+    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 (t[i] === ">") {
+        n.push({ type: "child" }), i += 1;
+        continue;
+      }
+      let r = i;
+      while (i < t.length && t[i] !== " " && t[i] !== ">")
+        i += 1;
+      n.push(Le(t.slice(r, i)));
+    }
+    return n;
+  });
+}
+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 (!D(e, t[n]))
+    return false;
+  if (n === 0)
+    return true;
+  let i = e.parentElement;
+  n -= 1;
+  while (i) {
+    let r = t[n];
+    if (!r)
+      return true;
+    if (r.type === "child") {
+      let s = t[n - 1];
+      if (!s || !D(i, s))
+        return false;
+      if (n -= 2, n < 0)
+        return true;
+      i = i.parentElement;
+      continue;
+    }
+    if (D(i, r)) {
+      if (n -= 1, n < 0)
+        return true;
+    }
+    i = i.parentElement;
+  }
+  return false;
+}
+function D(e, t) {
+  switch (t.type) {
+    case "universal":
+      return true;
+    case "tag":
+      return e.localName === t.name;
+    case "id":
+      return e.id === t.id;
+    case "class":
+      return e.classList.contains(t.className);
+    case "attribute":
+      return Ae(e, t);
+    case "compound":
+      return t.parts.every((n) => D(e, n));
+    case "child":
+      return false;
+    default:
+      return false;
+  }
+}
+function Ae(e, t) {
+  let n = e.getAttribute(t.name);
+  if (!t.operator)
+    return n !== null;
+  if (n === null)
+    return false;
+  let i = t.value ?? "";
+  switch (t.operator) {
+    case "=":
+      return n === i;
+    case "~=":
+      return n.split(/\s+/).includes(i);
+    case "|=":
+      return n === i || n.startsWith(`${i}-`);
+    case "^=":
+      return n.startsWith(i);
+    case "$=":
+      return n.endsWith(i);
+    case "*=":
+      return n.includes(i);
+    default:
+      return false;
+  }
+}
+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;
+    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;
+    if (e.hasAttribute(`data-${g(i)}`))
+      return { configurable: true, enumerable: true, writable: true, value: e.getAttribute(`data-${g(i)}`) };
+    return;
+  } });
+}
+function g(e) {
+  return e.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`);
+}
+function Oe(e) {
+  return e.replace(/-([a-z])/g, (t, n) => n.toUpperCase());
+}
+
+// src/project.ts
+var PROJECT_GLOBAL_KEYS = [...fe, "__APP__"];
+var projectDomQueue = Promise.resolve();
+async function renderProjectHtml(config, options, entry = config.entry) {
+  return withProjectDom(async () => {
+    const module = await importProjectEntry(entry);
+    const app = module.app;
+    if (!app || typeof app.renderHtmlDocument !== "function") {
+      throw new Error(`TSone entry ${entry} must export an app with renderHtmlDocument()`);
+    }
+    return app.renderHtmlDocument(options);
+  });
+}
+async function withProjectDom(callback) {
+  const task = projectDomQueue.then(() => runWithProjectDom(callback));
+  projectDomQueue = task.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return task;
+}
+async function runWithProjectDom(callback) {
+  const windowRef = ke({ url: "http://127.0.0.1/" });
+  Object.assign(windowRef, {
+    Error,
+    EvalError,
+    RangeError,
+    ReferenceError,
+    SyntaxError,
+    TypeError,
+    URIError
+  });
+  const descriptors = captureGlobalDescriptors();
+  try {
+    Pe(windowRef);
+    return await callback();
+  } finally {
+    restoreGlobalDescriptors(descriptors);
+  }
+}
+var projectEntrySequence = 0;
+async function importProjectEntry(entry) {
+  projectEntrySequence += 1;
+  return await import(`${entry}?tsone_entry=${projectEntrySequence}`);
+}
+function captureGlobalDescriptors() {
+  return new Map(PROJECT_GLOBAL_KEYS.map((key) => [
+    key,
+    Object.getOwnPropertyDescriptor(globalThis, key)
+  ]));
+}
+function restoreGlobalDescriptors(descriptors) {
+  PROJECT_GLOBAL_KEYS.forEach((key) => {
+    const descriptor = descriptors.get(key);
+    if (descriptor) {
+      Object.defineProperty(globalThis, key, descriptor);
+      return;
+    }
+    delete globalThis[key];
+  });
+}
+
+// src/safe-path.ts
+import { lstat, realpath } from "fs/promises";
+import { dirname, isAbsolute, relative, resolve as resolve2, sep } from "path";
+async function assertSafeSubdirectory(root, path, errorMessage) {
+  try {
+    const canonicalRoot = await realpath(root);
+    const canonicalPath = await canonicalizePotentialPath(path);
+    if (!isStrictSubdirectory(canonicalRoot, canonicalPath)) {
+      throw new Error(errorMessage);
+    }
+  } catch {
+    throw new Error(errorMessage);
+  }
+}
+async function assertSafeSubdirectoryDoesNotContain(root, path, protectedPath, errorMessage) {
+  try {
+    const lexicalPath = resolve2(path);
+    const lexicalProtectedPath = resolve2(protectedPath);
+    const canonicalRoot = await realpath(root);
+    const canonicalPath = await canonicalizePotentialPath(path);
+    const canonicalProtectedPath = await realpath(protectedPath);
+    if (!isStrictSubdirectory(canonicalRoot, canonicalPath) || isPathWithinOrEqual(lexicalPath, lexicalProtectedPath) || isPathWithinOrEqual(canonicalPath, canonicalProtectedPath)) {
+      throw new Error(errorMessage);
+    }
+  } catch {
+    throw new Error(errorMessage);
+  }
+}
+async function canonicalizePotentialPath(path) {
+  const ancestor = await findExistingAncestor(path);
+  const canonicalAncestor = await realpath(ancestor);
+  return resolve2(canonicalAncestor, relative(ancestor, path));
+}
+async function findExistingAncestor(path) {
+  let candidate = path;
+  while (candidate !== dirname(candidate)) {
+    try {
+      await lstat(candidate);
+      return candidate;
+    } catch (error) {
+      if (!isMissingPathError(error)) {
+        throw error;
+      }
+    }
+    candidate = dirname(candidate);
+  }
+  await lstat(candidate);
+  return candidate;
+}
+function isMissingPathError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isStrictSubdirectory(root, path) {
+  const pathFromRoot = relative(root, path);
+  return pathFromRoot !== "" && pathFromRoot !== ".." && !pathFromRoot.startsWith(`..${sep}`) && !isAbsolute(pathFromRoot);
+}
+function isPathWithinOrEqual(parent, candidate) {
+  const pathFromParent = relative(parent, candidate);
+  return pathFromParent === "" || pathFromParent !== ".." && !pathFromParent.startsWith(`..${sep}`) && !isAbsolute(pathFromParent);
+}
+
+// src/build.ts
+var INVALID_OUTPUT_DIRECTORY_MESSAGE = "Build output must be a subdirectory of the project root";
+async function build(options = {}) {
+  const config = await resolveConfig(options);
+  for (const entry of Object.values(config.pages)) {
+    await assertSafeSubdirectoryDoesNotContain(config.root, config.build.outDir, entry, INVALID_OUTPUT_DIRECTORY_MESSAGE);
+  }
+  for (const entry of Object.values(config.pages)) {
+    await renderProjectHtml(config, {}, entry);
+  }
+  await rm(config.build.outDir, { recursive: true, force: true });
+  await mkdir(config.build.outDir, { recursive: true });
+  const pages = [];
+  const failures = [];
+  for (const [route, entry] of Object.entries(config.pages)) {
+    const built = await buildPage(config, route, entry);
+    if (typeof built === "string") {
+      failures.push(built);
+      continue;
+    }
+    pages.push(built);
+  }
+  if (failures.length > 0) {
+    throw buildFailure(failures);
+  }
+  const assetsBuilt = [];
+  for (const page of pages) {
+    const html = await renderProjectHtml(config, {
+      head: page.stylesheetAssets.map((asset) => ({
+        tag: "link",
+        attributes: {
+          rel: "stylesheet",
+          href: toAssetUrl(config.build.outDir, htmlPath(config, page.route), asset)
+        }
+      })),
+      scripts: page.javascriptAssets.map((asset) => ({
+        type: "module",
+        src: toAssetUrl(config.build.outDir, htmlPath(config, page.route), asset)
+      }))
+    }, page.entry);
+    const pageHtmlPath = htmlPath(config, page.route);
+    await mkdir(dirname2(pageHtmlPath), { recursive: true });
+    await writeFile(pageHtmlPath, html);
+    assetsBuilt.push(...page.assets, pageHtmlPath);
+  }
+  return {
+    root: config.root,
+    outDir: config.build.outDir,
+    assetsBuilt
+  };
+}
+async function buildPage(config, route, entry) {
+  let result;
+  try {
+    result = await Bun.build({
+      entrypoints: [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
+    });
+  } catch (error) {
+    return pageFailureReason(route, [errorMessage(error)]);
+  }
+  const assets = result.outputs.map((output) => resolve3(output.path));
+  const javascriptAssets = result.outputs.filter(isEntryJavaScriptOutput).map((output) => resolve3(output.path));
+  const stylesheetAssets = result.outputs.filter(isStylesheetOutput).map((output) => resolve3(output.path));
+  if (!result.success || assets.length === 0 || javascriptAssets.length === 0) {
+    return pageFailureReason(route, result.logs.map((log) => log.message), {
+      success: result.success,
+      hasOutput: assets.length > 0,
+      hasJavaScript: javascriptAssets.length > 0
+    });
+  }
+  return {
+    route,
+    entry,
+    assets,
+    javascriptAssets,
+    stylesheetAssets
+  };
+}
+function pageFailureReason(route, logs, state) {
+  const pageContext = route === "/" ? "" : `Page ${route}: `;
+  const reasons = [
+    state && !state.success ? "Bun build reported failure" : "",
+    state && !state.hasOutput ? "Bun emitted no output files" : "",
+    state && !state.hasJavaScript ? "Bun emitted no JavaScript output" : "",
+    ...logs
+  ].filter((reason) => reason !== "");
+  return `${pageContext}${reasons.join(`
+`)}`;
+}
+function buildFailure(failures) {
+  if (failures.length === 1) {
+    return new Error(`Failed to build TSone application: ${failures[0]}`);
+  }
+  return new Error(`Failed to build TSone application:
+${failures.map((failure) => `- ${failure}`).join(`
+`)}`);
+}
+function htmlPath(config, route) {
+  if (route === "/") {
+    return resolve3(config.build.outDir, "index.html");
+  }
+  return resolve3(config.build.outDir, `${route.replace(/^\/+/, "")}.html`);
+}
+function toAssetUrl(outDir, fromHtmlFile, asset) {
+  const fromOutDir = relative2(outDir, asset).split(sep2).join("/");
+  if (fromOutDir === "" || fromOutDir === ".." || fromOutDir.startsWith("../") || isAbsolute2(fromOutDir)) {
+    throw new Error(`Build asset must be inside the output directory: ${asset}`);
+  }
+  const fromHtmlDir = dirname2(fromHtmlFile);
+  const assetPath = relative2(fromHtmlDir, asset).split(sep2).join("/");
+  return `./${assetPath}`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/create.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+var TSONE_FRAMEWORK_VERSION = "0.2.1";
+var TSONE_CLI_VERSION = "0.2.2";
+var GITHUB_URL = "https://github.com/geektech-team/tsone";
+function createProject(options = {}) {
+  const root = options.root ?? process.cwd();
+  const name = options.name ?? basename(root);
+  const files = scaffoldFiles(name);
+  const existing = files.filter((file) => existsSync2(join(root, file.path)));
+  if (existing.length > 0) {
+    throw new Error(`Refusing to overwrite existing TSone project files: ${existing.map((file) => file.path).join(", ")}`);
+  }
+  mkdirSync(join(root, "src"), { recursive: true });
+  const created = [];
+  for (const file of files) {
+    writeFileSync(join(root, file.path), file.content, "utf8");
+    created.push(file.path);
+  }
+  return { root, files: created };
+}
+function scaffoldFiles(name) {
+  return [
+    {
+      path: "package.json",
+      content: `${JSON.stringify({
+        name,
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "tsone dev",
+          build: "tsone build",
+          typecheck: "bunx tsc --noEmit"
+        },
+        dependencies: {
+          "@geektech/tsone": `^${TSONE_FRAMEWORK_VERSION}`
+        },
+        devDependencies: {
+          "@geektech/tsone-cli": `^${TSONE_CLI_VERSION}`
+        }
+      }, null, 2)}
+`
+    },
+    {
+      path: "tsone.config.ts",
+      content: `import { defineConfig } from '@geektech/tsone-cli';
+
+export default defineConfig({
+  entry: 'src/main.ts',
+});
+`
+    },
+    {
+      path: "tsconfig.json",
+      content: `${JSON.stringify({
+        compilerOptions: {
+          target: "ESNext",
+          module: "ESNext",
+          moduleResolution: "Bundler",
+          lib: ["ESNext", "DOM", "DOM.Iterable"],
+          strict: true,
+          noEmit: true,
+          skipLibCheck: true,
+          verbatimModuleSyntax: true
+        },
+        include: ["src/**/*", "tsone.config.ts"]
+      }, null, 2)}
+`
+    },
+    {
+      path: ".gitignore",
+      content: `node_modules/
+dist/
+.tsone/
+`
+    },
+    {
+      path: "src/main.ts",
+      content: `import { Component, createApp, h, type VNode } from '@geektech/tsone';
+
+class App extends Component<object, object> {
+  protected initState(): object {
+    return {};
+  }
+
+  protected initStyles(): void {
+    this.styleManager.addStyle('app-body', {
+      selector: 'body',
+      properties: {
+        margin: 0,
+        background: '#f7fbf6',
+        color: '#142216',
+        fontFamily:
+          "ui-sans-serif, system-ui, -apple-system, 'Segoe UI', sans-serif",
+      },
+    });
+    this.styleManager.addStyle('app-shell', {
+      selector: '.app-shell',
+      properties: {
+        alignItems: 'center',
+        display: 'flex',
+        flexDirection: 'column',
+        gap: '14px',
+        justifyContent: 'center',
+        minHeight: '100vh',
+      },
+    });
+    this.styleManager.addStyle('app-title', {
+      selector: '.app-title',
+      properties: {
+        fontSize: '64px',
+        letterSpacing: 0,
+        lineHeight: 1.05,
+        margin: 0,
+      },
+    });
+    this.styleManager.addStyle('app-link', {
+      selector: '.app-link',
+      properties: {
+        color: '#2f7c39',
+        fontSize: '16px',
+        textDecoration: 'none',
+      },
+      hover: {
+        textDecoration: 'underline',
+      },
+    });
+  }
+
+  protected render(): VNode {
+    return h('main', { className: 'app-shell' }, [
+      h('h1', { className: 'app-title' }, ['TSone']),
+      h(
+        'a',
+        { className: 'app-link', href: '${GITHUB_URL}' },
+        ['GitHub']
+      ),
+    ]);
+  }
+}
+
+export const app = createApp({
+  root: App,
+  document: {
+    lang: 'zh-CN',
+    title: 'TSone',
+    description: '\u8F7B\u91CF\u7EA7\u7EAF TypeScript \u524D\u7AEF\u6846\u67B6',
+  },
+});
+
+app.mount();
+`
+    }
+  ];
+}
+
+// src/server.ts
+import { randomUUID } from "crypto";
+import {
+  basename as basename2,
+  extname,
+  isAbsolute as isAbsolute4,
+  relative as relative4,
+  resolve as resolve4,
+  sep as sep3
+} from "path";
+
+// src/proxy.ts
+var HOP_BY_HOP_HEADERS = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+function createProxyHandler(proxy) {
+  const rules = Object.entries(proxy ?? {}).map(([prefix, options]) => toProxyRule(prefix, options)).sort((first, second) => second.prefix.length - first.prefix.length);
+  return async (request) => {
+    const sourceUrl = new URL(request.url);
+    const rule = rules.find(({ prefix }) => sourceUrl.pathname.startsWith(prefix));
+    if (!rule) {
+      return;
+    }
+    const target = createTargetUrl(rule, sourceUrl);
+    const headers = createRequestHeaders(request, sourceUrl, rule, target);
+    const body = request.method === "GET" || request.method === "HEAD" ? undefined : request.body;
+    try {
+      const upstream = await fetch(target, {
+        method: request.method,
+        headers,
+        body,
+        signal: request.signal,
+        redirect: "manual"
+      });
+      return new Response(upstream.body, {
+        status: upstream.status,
+        statusText: upstream.statusText,
+        headers: filterHeaders(upstream.headers)
+      });
+    } catch {
+      return new Response("Bad Gateway", { status: 502 });
+    }
+  };
+}
+function toProxyRule(prefix, value) {
+  const options = typeof value === "string" ? { target: value } : value;
+  return {
+    prefix,
+    target: new URL(options.target),
+    changeOrigin: options.changeOrigin ?? false,
+    ...options.rewrite === undefined ? {} : { rewrite: options.rewrite }
+  };
+}
+function createTargetUrl(rule, sourceUrl) {
+  const target = new URL(rule.target);
+  const pathname = rule.rewrite?.(sourceUrl.pathname) ?? sourceUrl.pathname;
+  target.pathname = joinPathnames(target.pathname, pathname);
+  target.search = sourceUrl.search;
+  return target;
+}
+function joinPathnames(basePathname, pathname) {
+  const base = basePathname === "/" ? "" : basePathname.replace(/\/+$/, "");
+  const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${base}${path}` || "/";
+}
+function createRequestHeaders(request, sourceUrl, rule, target) {
+  const headers = filterHeaders(request.headers);
+  const incomingHost = request.headers.get("host") ?? sourceUrl.host;
+  headers.set("host", rule.changeOrigin ? target.host : incomingHost);
+  return headers;
+}
+function filterHeaders(source) {
+  const headers = new Headers(source);
+  const connection = headers.get("connection");
+  if (connection) {
+    connection.split(",").forEach((header) => {
+      const name = header.trim();
+      if (name) {
+        headers.delete(name);
+      }
+    });
+  }
+  HOP_BY_HOP_HEADERS.forEach((header) => headers.delete(header));
+  return headers;
+}
+
+// src/watch.ts
+import { watch } from "fs";
+import { readdir, stat } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join2, relative as relative3 } from "path";
+var RECURSIVE_WATCH_UNSUPPORTED_ERROR = "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+var DEFAULT_DEBOUNCE_MS = 100;
+var DEFAULT_POLL_INTERVAL_MS = 300;
+function createFileWatcher(options) {
+  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  let timer;
+  const disposers = [];
+  const scheduleChange = (relativePath) => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = undefined;
+      options.onChange(relativePath);
+    }, debounceMs);
+  };
+  disposers.push(() => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  });
+  const nativeWatcher = tryCreateNativeWatcher(options.root, options.isRelevant, scheduleChange);
+  if (nativeWatcher) {
+    disposers.push(nativeWatcher);
+  } else {
+    disposers.push(createPollingWatcher(options.root, options.isRelevant, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS, scheduleChange));
+  }
+  return {
+    dispose: () => {
+      disposers.splice(0).reverse().forEach((dispose) => dispose());
+    }
+  };
+}
+function tryCreateNativeWatcher(root, isRelevant, onRelevantChange) {
+  let watcher;
+  try {
+    watcher = watch(root, { recursive: true }, (_event, filename) => {
+      if (typeof filename !== "string") {
+        return;
+      }
+      const relativePath = toRelativePath(root, filename);
+      if (relativePath === undefined || !isRelevant(relativePath)) {
+        return;
+      }
+      onRelevantChange(relativePath);
+    });
+  } catch (error) {
+    if (isRecursiveWatchUnsupported(error)) {
+      return;
+    }
+    throw error;
+  }
+  return () => watcher.close();
+}
+function createPollingWatcher(root, isRelevant, intervalMs, onRelevantChange) {
+  let running = true;
+  let snapshot = new Map;
+  let timer;
+  const scan = async () => {
+    if (!running) {
+      return;
+    }
+    const next = new Map;
+    try {
+      await collectRelevantFiles(root, isRelevant, next);
+    } catch {
+      return;
+    }
+    let changedPath;
+    for (const [relativePath, snapshotEntry] of next) {
+      const previous = snapshot.get(relativePath);
+      if (!previous || previous.mtimeMs !== snapshotEntry.mtimeMs || previous.size !== snapshotEntry.size) {
+        changedPath = relativePath;
+        break;
+      }
+    }
+    if (changedPath === undefined) {
+      for (const relativePath of snapshot.keys()) {
+        if (!next.has(relativePath)) {
+          changedPath = relativePath;
+          break;
+        }
+      }
+    }
+    snapshot = next;
+    if (changedPath !== undefined) {
+      onRelevantChange(changedPath);
+    }
+  };
+  scan();
+  timer = setInterval(() => {
+    scan();
+  }, intervalMs);
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+  return () => {
+    running = false;
+    if (timer) {
+      clearInterval(timer);
+    }
+  };
+}
+async function collectRelevantFiles(root, isRelevant, output) {
+  const pendingDirectories = [""];
+  while (pendingDirectories.length > 0) {
+    const relativeDirectory = pendingDirectories.pop();
+    if (relativeDirectory === undefined) {
+      break;
+    }
+    const absoluteDirectory = join2(root, relativeDirectory);
+    let entries;
+    try {
+      entries = await readdir(absoluteDirectory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const relativePath = relativeDirectory === "" ? entry.name : `${relativeDirectory}/${entry.name}`;
+      if (entry.isDirectory()) {
+        pendingDirectories.push(relativePath);
+        continue;
+      }
+      if (!entry.isFile() || !isRelevant(relativePath)) {
+        continue;
+      }
+      try {
+        const info = await stat(join2(root, relativePath));
+        output.set(relativePath, { mtimeMs: info.mtimeMs, size: info.size });
+      } catch {}
+    }
+  }
+}
+function toRelativePath(root, filename) {
+  const relativePath = isAbsolute3(filename) ? relative3(root, filename) : filename.split("\\").join("/");
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith("../")) {
+    return;
+  }
+  return relativePath.split("\\").join("/");
+}
+function isRecursiveWatchUnsupported(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === RECURSIVE_WATCH_UNSUPPORTED_ERROR;
+}
+
+// src/server.ts
+var DEVELOPMENT_URL_PREFIX = "/dev";
+var INVALID_DEVELOPMENT_DIRECTORY_MESSAGE = "Development output must be a subdirectory of the project root";
+var LIVE_RELOAD_PATH = "/__tsone/reload";
+var WATCHED_EXTENSIONS = new Set([
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".css",
+  ".html"
+]);
+var IGNORED_WATCH_SEGMENTS = new Set([
+  ".tsone",
+  "node_modules",
+  ".git",
+  ".worktrees"
+]);
+var LIVE_RELOAD_CLIENT_SCRIPT = [
+  '<script type="module">',
+  "const tsoneReloadSource=new EventSource(",
+  JSON.stringify(LIVE_RELOAD_PATH),
+  ");",
+  'tsoneReloadSource.addEventListener("reload",()=>location.reload());',
+  "</script>"
+].join("");
+async function startDevServer(options = {}) {
+  if (options.watch) {
+    return startWatchingDevServer(options);
+  }
+  const instance = await createServerInstance(options, false);
+  return instance.server;
+}
+async function startWatchingDevServer(options) {
+  let instance = await createServerInstance(options, true);
+  let watcher = createProjectWatcher(instance, onChange);
+  async function onChange(changedPath) {
+    const configFile = instance.config.configFile;
+    const configRelativePath = configFile === undefined ? undefined : toRelativePath2(instance.config.root, configFile);
+    if (configRelativePath === changedPath) {
+      await restart();
+      return;
+    }
+    await rebuildAndReload();
+  }
+  async function rebuildAndReload() {
+    const routes = Object.keys(instance.config.pages);
+    instance.markDirty(routes);
+    for (const route of routes) {
+      const bundle = await instance.getBundle(route);
+      if (bundle instanceof Response) {
+        console.error("TSone rebuild failed; keeping the last working page.");
+        return;
+      }
+    }
+    instance.liveReload?.broadcast();
+  }
+  async function restart() {
+    watcher.dispose();
+    instance.server.stop(true);
+    instance = await createServerInstance(options, true);
+    watcher = createProjectWatcher(instance, onChange);
+    console.log(`TSone dev server restarted at http://${instance.server.hostname}:${instance.server.port}`);
+  }
+  return createServerHandle(() => instance, () => watcher.dispose());
+}
+function createProjectWatcher(instance, onChange) {
+  return createFileWatcher({
+    root: instance.config.root,
+    isRelevant: (relativePath) => isWatchedFile(instance, relativePath),
+    onChange: (changedPath) => {
+      onChange(changedPath);
+    }
+  });
+}
+async function createServerInstance(options, watch2) {
+  const config = await resolveConfig(options);
+  for (const entry of Object.values(config.pages)) {
+    await renderProjectHtml(config, {}, entry);
+  }
+  const developmentOutDir = resolve4(config.root, ".tsone", "dev");
+  await assertSafeSubdirectory(config.root, developmentOutDir, INVALID_DEVELOPMENT_DIRECTORY_MESSAGE);
+  const proxy = createProxyHandler(config.server.proxy);
+  const sessionId = createGenerationId();
+  const sessionOutDir = resolve4(developmentOutDir, sessionId);
+  const artifacts = new Map;
+  const buildProject = createDevelopmentBuilder(config, sessionId, sessionOutDir);
+  const liveReload = watch2 ? createLiveReloadHub() : undefined;
+  const bundles = new Map;
+  const dirtyRoutes = new Set;
+  const getBundle = async (route) => {
+    const cached = bundles.get(route);
+    if (watch2 && cached !== undefined && !dirtyRoutes.has(route)) {
+      return cached;
+    }
+    const bundle = await buildProject(route);
+    if (bundle instanceof Response) {
+      if (watch2) {
+        dirtyRoutes.add(route);
+      }
+      return bundle;
+    }
+    if (watch2) {
+      bundles.set(route, bundle);
+      dirtyRoutes.delete(route);
+    }
+    return bundle;
+  };
+  const server = Bun.serve({
+    hostname: config.server.host,
+    port: config.server.port,
+    fetch: async (request) => {
+      const reloadResponse = liveReload?.handleRequest(request);
+      if (reloadResponse) {
+        return reloadResponse;
+      }
+      return await proxy(request) ?? serveProjectRequest(request, config, config.pages, getBundle, artifacts, liveReload);
+    }
+  });
+  return {
+    server,
+    config,
+    getBundle,
+    markDirty: (routes) => {
+      routes.forEach((route) => dirtyRoutes.add(route));
+    },
+    liveReload
+  };
+}
+function createServerHandle(getInstance, disposeWatcher) {
+  return new Proxy({}, {
+    get(_target, property) {
+      if (property === "stop") {
+        return (closeActiveConnections) => {
+          disposeWatcher();
+          getInstance().server.stop(closeActiveConnections);
+        };
+      }
+      const server = getInstance().server;
+      const value = server[property];
+      return typeof value === "function" ? value.bind(server) : value;
+    }
+  });
+}
+async function serveProjectRequest(request, config, pages, getBundle, artifacts, liveReload) {
+  const pathname = new URL(request.url).pathname;
+  const route = pageRouteForPathname(pages, pathname);
+  if (route !== undefined) {
+    const bundle = await getBundle(route);
+    if (bundle instanceof Response) {
+      return bundle;
+    }
+    try {
+      const html = await renderProjectHtml(config, {
+        head: bundle.stylesheets.map(({ pathname: href }) => ({
+          tag: "link",
+          attributes: { rel: "stylesheet", href }
+        })),
+        scripts: [{ type: "module", src: bundle.entry.pathname }]
+      }, pages[route]);
+      publishDevelopmentBundle(bundle, artifacts);
+      return new Response(liveReload ? injectLiveReloadScript(html) : html, {
+        headers: {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": "no-store"
+        }
+      });
+    } catch (error) {
+      console.error(error);
+      return buildFailureResponse();
+    }
+  }
+  if (pathname === "/bundle.js") {
+    const bundle = await getBundle("/");
+    if (bundle instanceof Response) {
+      return bundle;
+    }
+    try {
+      publishDevelopmentBundle(bundle, artifacts);
+      return new Response(null, {
+        status: 307,
+        headers: {
+          location: bundle.entry.pathname,
+          "cache-control": "no-store"
+        }
+      });
+    } catch (error) {
+      console.error(error);
+      return buildFailureResponse();
+    }
+  }
+  const artifact = artifacts.get(pathname);
+  if (artifact) {
+    return new Response(Bun.file(artifact.filePath), {
+      headers: {
+        "content-type": artifact.type,
+        "cache-control": "no-store"
+      }
+    });
+  }
+  return new Response("Not found", {
+    status: 404,
+    headers: { "cache-control": "no-store" }
+  });
+}
+function pageRouteForPathname(pages, pathname) {
+  if (pages[pathname] !== undefined) {
+    return pathname;
+  }
+  if (pathname === "/index.html") {
+    return "/";
+  }
+  const candidate = pathname.length > 1 && pathname.endsWith("/") ? pathname.replace(/\/+$/, "") : pathname;
+  if (pages[candidate] !== undefined) {
+    return candidate;
+  }
+  if (candidate.endsWith("/index.html")) {
+    const base = candidate.slice(0, candidate.length - "/index.html".length);
+    if (base === "") {
+      return "/";
+    }
+    if (pages[base] !== undefined) {
+      return base;
+    }
+  }
+  return;
+}
+function injectLiveReloadScript(html) {
+  if (html.includes(LIVE_RELOAD_PATH)) {
+    return html;
+  }
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${LIVE_RELOAD_CLIENT_SCRIPT}</body>`);
+  }
+  return html + LIVE_RELOAD_CLIENT_SCRIPT;
+}
+var reloadEncoder = new TextEncoder;
+function createLiveReloadHub() {
+  const controllers = new Set;
+  function handleRequest(request) {
+    if (new URL(request.url).pathname !== LIVE_RELOAD_PATH) {
+      return;
+    }
+    let streamController;
+    const stream = new ReadableStream({
+      start: (controller) => {
+        streamController = controller;
+        controllers.add(controller);
+        try {
+          controller.enqueue(reloadEncoder.encode(`: connected
+
+`));
+        } catch {
+          controllers.delete(controller);
+        }
+      },
+      cancel: () => {
+        if (streamController) {
+          controllers.delete(streamController);
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "content-type": "text/event-stream",
+        "cache-control": "no-store"
+      }
+    });
+  }
+  function broadcast() {
+    const message = reloadEncoder.encode(`event: reload
+data: {}
+
+`);
+    for (const controller of [...controllers]) {
+      try {
+        controller.enqueue(message);
+      } catch {
+        controllers.delete(controller);
+      }
+    }
+  }
+  return { handleRequest, broadcast };
+}
+function isWatchedFile(instance, relativePath) {
+  if (relativePath === "" || relativePath.startsWith("..")) {
+    return false;
+  }
+  const segments = relativePath.split("/");
+  if (segments.some((segment) => IGNORED_WATCH_SEGMENTS.has(segment))) {
+    return false;
+  }
+  const absolutePath = resolve4(instance.config.root, relativePath);
+  if (isWithinOrEqual(instance.config.build.outDir, absolutePath)) {
+    return false;
+  }
+  const base = basename2(absolutePath);
+  if (base.startsWith(".") && absolutePath !== instance.config.configFile) {
+    return false;
+  }
+  return WATCHED_EXTENSIONS.has(extname(base).toLowerCase());
+}
+function toRelativePath2(root, absolutePath) {
+  return relative4(root, absolutePath).split(sep3).join("/");
+}
+function isWithinOrEqual(parent, candidate) {
+  const pathFromParent = relative4(parent, candidate);
+  return pathFromParent === "" || pathFromParent !== ".." && !pathFromParent.startsWith(`..${sep3}`) && !isAbsolute4(pathFromParent);
+}
+function createDevelopmentBuilder(config, sessionId, sessionOutDir) {
+  let queue = Promise.resolve();
+  return (route) => {
+    const entry = config.pages[route];
+    const result = queue.then(() => buildProjectBundle(entry, sessionId, sessionOutDir));
+    queue = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  };
+}
+async function buildProjectBundle(entry, sessionId, sessionOutDir) {
+  const generationId = createGenerationId();
+  const generationOutDir = resolve4(sessionOutDir, generationId);
+  const generationUrl = `${DEVELOPMENT_URL_PREFIX}/${sessionId}/${generationId}`;
+  const buildOptions = {
+    entrypoints: [entry],
+    outdir: generationOutDir,
+    target: "browser",
+    format: "esm",
+    sourcemap: "inline",
+    write: true,
+    throw: false,
+    publicPath: `${generationUrl}/`,
+    naming: {
+      entry: "[name]-[hash].[ext]",
+      chunk: "[name]-[hash].[ext]",
+      asset: "assets/[name]-[hash].[ext]"
+    }
+  };
+  try {
+    const result = await Bun.build(buildOptions);
+    const entryArtifact = result.outputs.find(isEntryJavaScriptOutput);
+    if (!result.success || !entryArtifact) {
+      result.logs.forEach((log) => console.error(log));
+      if (!entryArtifact) {
+        console.error("Failed to build project bundle: no JavaScript output");
+      }
+      return buildFailureResponse();
+    }
+    const pendingArtifacts = new Map;
+    const outputs = new Map;
+    for (const output of result.outputs) {
+      const developmentOutput = createDevelopmentOutput(generationOutDir, generationUrl, output);
+      if (pendingArtifacts.has(developmentOutput.pathname)) {
+        throw new Error(`Development output URL collision: ${developmentOutput.pathname}`);
+      }
+      pendingArtifacts.set(developmentOutput.pathname, developmentOutput);
+      outputs.set(output, developmentOutput);
+    }
+    const entry2 = outputs.get(entryArtifact);
+    if (!entry2) {
+      throw new Error("Development entry output was not indexed");
+    }
+    return {
+      entry: entry2,
+      stylesheets: result.outputs.filter(isStylesheetOutput).map((output) => outputs.get(output)).filter((output) => output !== undefined),
+      artifacts: pendingArtifacts
+    };
+  } catch (error) {
+    console.error(error);
+    return buildFailureResponse();
+  }
+}
+function publishDevelopmentBundle(bundle, artifacts) {
+  for (const [pathname, output] of bundle.artifacts) {
+    const existing = artifacts.get(pathname);
+    if (existing) {
+      if (existing.filePath === output.filePath) {
+        continue;
+      }
+      throw new Error(`Development output URL collision: ${pathname}`);
+    }
+    artifacts.set(pathname, output);
+  }
+}
+function createDevelopmentOutput(generationOutDir, generationUrl, output) {
+  const filePath = resolve4(output.path);
+  const pathFromGeneration = relative4(generationOutDir, filePath);
+  if (pathFromGeneration === "" || pathFromGeneration === ".." || pathFromGeneration.startsWith(`..${sep3}`) || isAbsolute4(pathFromGeneration)) {
+    throw new Error(`Development output must not escape outside its generation directory: ${output.path}`);
+  }
+  const urlPath = pathFromGeneration.split(sep3).map((segment) => encodeURIComponent(segment)).join("/");
+  return {
+    filePath,
+    pathname: `${generationUrl}/${urlPath}`,
+    type: output.type
+  };
+}
+function createGenerationId() {
+  return randomUUID().replace(/-/g, "");
+}
+function buildFailureResponse() {
+  return new Response("Failed to build project bundle", {
+    status: 500,
+    headers: { "cache-control": "no-store" }
+  });
+}
+
+export { defineConfig, resolveConfig, build, createProject, startDevServer };
+
+//# debugId=948B20A93B1A828264756E2164756E21
+//# sourceMappingURL=index-r68229k4.js.map