speexjs 0.2.0

package/dist/client/index.js

@@ -0,0 +1,927 @@
+// src/client/signals/index.ts
+var activeTracker = null;
+var activeSources = null;
+var batchDepth = 0;
+var pendingUpdates = /* @__PURE__ */ new Set();
+function flushPending() {
+  const fns = [...pendingUpdates];
+  pendingUpdates.clear();
+  for (const fn of fns) fn();
+}
+function trackSource(node) {
+  if (activeSources) activeSources.add(node);
+  if (activeTracker) node._subs.add(activeTracker);
+}
+var Signal = class {
+  _tag = "signal";
+  _subs = /* @__PURE__ */ new Set();
+  _value;
+  constructor(value) {
+    this._value = value;
+  }
+  get value() {
+    trackSource(this);
+    return this._value;
+  }
+  set value(val) {
+    if (val !== this._value) {
+      this._value = val;
+      this._notify();
+    }
+  }
+  peek() {
+    return this._value;
+  }
+  set(v) {
+    this.value = v;
+  }
+  update(fn) {
+    this.value = fn(this._value);
+  }
+  subscribe(fn) {
+    const cb = () => fn(this._value);
+    this._subs.add(cb);
+    return () => this._subs.delete(cb);
+  }
+  toJSON() {
+    return this._value;
+  }
+  toString() {
+    return String(this._value);
+  }
+  valueOf() {
+    return this._value;
+  }
+  *[Symbol.iterator]() {
+    yield this._value;
+  }
+  _notify() {
+    if (batchDepth > 0) {
+      for (const s of this._subs) pendingUpdates.add(s);
+    } else {
+      const subs = [...this._subs];
+      for (const s of subs) s();
+    }
+  }
+};
+var Computed = class {
+  _tag = "computed";
+  _subs = /* @__PURE__ */ new Set();
+  _fn;
+  _value;
+  _dirty = true;
+  _sources = /* @__PURE__ */ new Set();
+  _onDepChange = () => {
+    if (!this._dirty) {
+      this._dirty = true;
+      for (const s of [...this._subs]) s();
+    }
+  };
+  constructor(fn) {
+    this._fn = fn;
+  }
+  get value() {
+    trackSource(this);
+    if (this._dirty) this._eval();
+    return this._value;
+  }
+  peek() {
+    if (this._dirty) this._eval();
+    return this._value;
+  }
+  subscribe(fn) {
+    this.value;
+    const cb = () => fn(this._value);
+    this._subs.add(cb);
+    return () => this._subs.delete(cb);
+  }
+  toJSON() {
+    return this.value;
+  }
+  toString() {
+    return String(this.value);
+  }
+  valueOf() {
+    return this.value;
+  }
+  _eval() {
+    for (const src of this._sources) {
+      src._subs.delete(this._onDepChange);
+    }
+    this._sources.clear();
+    this._dirty = false;
+    const prevSources = activeSources;
+    const prevTracker = activeTracker;
+    activeSources = /* @__PURE__ */ new Set();
+    activeTracker = null;
+    try {
+      this._value = this._fn();
+      this._sources = activeSources;
+    } finally {
+      activeSources = prevSources;
+      activeTracker = prevTracker;
+    }
+    for (const src of this._sources) {
+      src._subs.add(this._onDepChange);
+    }
+  }
+};
+var Effect = class {
+  _fn;
+  _sources = /* @__PURE__ */ new Set();
+  _cleanup;
+  _alive = true;
+  constructor(fn) {
+    this._fn = fn;
+    this._run();
+  }
+  get alive() {
+    return this._alive;
+  }
+  stop() {
+    if (!this._alive) return;
+    this._alive = false;
+    this._removeSubscriptions();
+    if (this._cleanup) {
+      this._cleanup();
+      this._cleanup = void 0;
+    }
+  }
+  start() {
+    if (this._alive) return;
+    this._alive = true;
+    this._run();
+  }
+  _removeSubscriptions() {
+    for (const src of this._sources) {
+      src._subs.delete(this._run);
+    }
+    this._sources.clear();
+  }
+  _run = () => {
+    if (!this._alive) return;
+    this._removeSubscriptions();
+    if (this._cleanup) {
+      this._cleanup();
+      this._cleanup = void 0;
+    }
+    const prevTracker = activeTracker;
+    const prevSources = activeSources;
+    activeTracker = this._run;
+    activeSources = this._sources;
+    try {
+      const result = this._fn();
+      if (typeof result === "function") {
+        this._cleanup = result;
+      }
+    } finally {
+      activeTracker = prevTracker;
+      activeSources = prevSources;
+    }
+  };
+};
+function signal(initial) {
+  return new Signal(initial);
+}
+function computed(fn) {
+  return new Computed(fn);
+}
+function effect(fn) {
+  return new Effect(fn);
+}
+function untracked(fn) {
+  const prevTracker = activeTracker;
+  const prevSources = activeSources;
+  activeTracker = null;
+  activeSources = null;
+  try {
+    return fn();
+  } finally {
+    activeTracker = prevTracker;
+    activeSources = prevSources;
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushPending();
+    }
+  }
+}
+function isSignal(val) {
+  return val instanceof Signal;
+}
+function isComputed(val) {
+  return val instanceof Computed;
+}
+function toSignal(value) {
+  if (value instanceof Signal) return value;
+  return signal(value);
+}
+function mergeSignals(signals) {
+  return computed(() => {
+    const result = {};
+    for (const key of Object.keys(signals)) {
+      result[key] = signals[key].value;
+    }
+    return result;
+  });
+}
+
+// src/client/vdom/index.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var SVG_ELEMENTS = /* @__PURE__ */ new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "g",
+  "text",
+  "line",
+  "polyline",
+  "polygon",
+  "ellipse",
+  "use",
+  "defs",
+  "clipPath",
+  "mask",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "tspan",
+  "textPath",
+  "image",
+  "foreignObject",
+  "marker",
+  "pattern",
+  "symbol",
+  "filter",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feDropShadow",
+  "feFlood",
+  "feGaussianBlur",
+  "feMerge",
+  "feOffset",
+  "feImage",
+  "feTile",
+  "feTurbulence"
+]);
+function isSignal2(val) {
+  return val instanceof Signal;
+}
+function isComputed2(val) {
+  return val instanceof Computed;
+}
+function normalizeChild(child) {
+  if (child == null || typeof child === "boolean") return null;
+  if (isSignal2(child) || isComputed2(child)) {
+    return { type: "signal", signal: child };
+  }
+  if (typeof child === "string" || typeof child === "number") {
+    return { type: "text", text: String(child) };
+  }
+  if (Array.isArray(child)) {
+    const children = child.flat(Infinity).map(normalizeChild).filter(Boolean);
+    if (children.length === 0) return null;
+    if (children.length === 1) return children[0];
+    return { type: "fragment", children };
+  }
+  if (typeof child === "object" && child !== null && "type" in child) {
+    return child;
+  }
+  if (typeof child === "function") {
+    return { type: "component", component: child, props: {} };
+  }
+  return { type: "text", text: String(child) };
+}
+function h(tag, props, ...children) {
+  if (typeof tag === "function") {
+    const c = children.flat(Infinity).map(normalizeChild).filter(Boolean);
+    return {
+      type: "component",
+      component: tag,
+      props: { ...props || {}, children: c.length > 0 ? c : void 0 }
+    };
+  }
+  return {
+    type: "element",
+    tag,
+    props: props || {},
+    children: children.flat(Infinity).map(normalizeChild).filter(Boolean),
+    key: props?.key
+  };
+}
+function fragment(...children) {
+  const flat = children.flat(Infinity);
+  const normalized = flat.map(normalizeChild).filter(Boolean);
+  if (normalized.length === 0) return { type: "text", text: "" };
+  if (normalized.length === 1) return normalized[0];
+  return { type: "fragment", children: normalized };
+}
+function text(content) {
+  return { type: "text", text: content };
+}
+function createComponent(type, props, ...children) {
+  const c = children.flat(Infinity).map(normalizeChild).filter(Boolean);
+  return {
+    type: "component",
+    component: type,
+    props: { ...props || {}, children: c.length > 0 ? c : void 0 }
+  };
+}
+function setProp(el, key, value, oldValue) {
+  if (key === "key" || key === "children" || key === "ref") return;
+  if (isComputed2(value)) {
+    setProp(el, key, value.peek(), oldValue);
+    value.subscribe((v) => setProp(el, key, v));
+    return;
+  }
+  if (key.startsWith("on") && typeof value === "function") {
+    const event = key.slice(2).toLowerCase();
+    if (oldValue) el.removeEventListener(event, oldValue);
+    el.addEventListener(event, value);
+    return;
+  }
+  if (key === "style") {
+    if (typeof value === "string") {
+      el.setAttribute("style", value);
+    } else if (typeof value === "object" && value !== null) {
+      Object.assign(el.style, value);
+    }
+    return;
+  }
+  if (key === "class" || key === "className") {
+    if (typeof value === "string") {
+      el.setAttribute("class", value);
+    } else if (Array.isArray(value)) {
+      el.setAttribute("class", value.filter(Boolean).join(" "));
+    }
+    return;
+  }
+  if (key === "dangerouslySetInnerHTML" && typeof value === "object" && value?.__html) {
+    el.innerHTML = value.__html;
+    return;
+  }
+  if (key === "value" || key === "checked" || key === "disabled" || key === "selected") {
+    el[key] = value;
+    return;
+  }
+  if (key === "htmlFor") {
+    el.setAttribute("for", value);
+    return;
+  }
+  if (value === false || value === null || value === void 0) {
+    el.removeAttribute(key);
+  } else if (value === true) {
+    el.setAttribute(key, "");
+  } else {
+    el.setAttribute(key, String(value));
+  }
+}
+function removeProp(el, key, value) {
+  if (key === "key" || key === "children" || key === "ref") return;
+  if (key.startsWith("on") && typeof value === "function") {
+    el.removeEventListener(key.slice(2).toLowerCase(), value);
+    return;
+  }
+  if (key === "style") {
+    el.removeAttribute("style");
+    return;
+  }
+  if (key === "class" || key === "className") {
+    el.removeAttribute("class");
+    return;
+  }
+  if (key === "value" || key === "checked" || key === "disabled") {
+    delete el[key];
+    return;
+  }
+  el.removeAttribute(key);
+}
+function createDOM(vnode) {
+  switch (vnode.type) {
+    case "element": {
+      const isSVG = SVG_ELEMENTS.has(vnode.tag);
+      const el = isSVG ? document.createElementNS("http://www.w3.org/2000/svg", vnode.tag) : document.createElement(vnode.tag);
+      for (const [key, value] of Object.entries(vnode.props)) {
+        if (key !== "key") setProp(el, key, value);
+      }
+      for (const child of vnode.children) {
+        el.appendChild(createDOM(child));
+      }
+      return el;
+    }
+    case "text":
+      return document.createTextNode(vnode.text);
+    case "fragment": {
+      const frag = document.createDocumentFragment();
+      for (const child of vnode.children) frag.appendChild(createDOM(child));
+      return frag;
+    }
+    case "component": {
+      const result = vnode.component(vnode.props);
+      if (result instanceof Promise) {
+        const placeholder = document.createComment(" async ");
+        result.then((resolved) => {
+          const node = createDOM(resolved);
+          placeholder.parentNode?.replaceChild(node, placeholder);
+        });
+        return placeholder;
+      }
+      return createDOM(result);
+    }
+    case "signal": {
+      const val = vnode.signal.value;
+      const v = normalizeChild(val);
+      const node = createDOM(v ?? text(""));
+      vnode.signal.subscribe((newVal) => {
+        const newV = normalizeChild(newVal);
+        if (newV && node.parentNode) {
+          const newNode = createDOM(newV);
+          node.parentNode.replaceChild(newNode, node);
+        }
+      });
+      return node;
+    }
+  }
+}
+function render(vnode, container) {
+  container.innerHTML = "";
+  container.appendChild(createDOM(vnode));
+}
+function isSameVNodeType(a, b) {
+  if (a.type !== b.type) return false;
+  if (a.type === "element" && b.type === "element") {
+    return a.tag === b.tag && a.key === b.key;
+  }
+  return true;
+}
+function patchProps(el, oldProps, newProps) {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
+  for (const key of allKeys) {
+    if (key === "key" || key === "children") continue;
+    const oldVal = oldProps[key];
+    const newVal = newProps[key];
+    if (oldVal === newVal) continue;
+    if (newVal === void 0 || newVal === null) {
+      removeProp(el, key, oldVal);
+    } else {
+      setProp(el, key, newVal, oldVal);
+    }
+  }
+}
+function patchChildren(parent, oldChildren, newChildren) {
+  const maxLen = Math.max(oldChildren.length, newChildren.length);
+  for (let i = 0; i < maxLen; i++) {
+    const oldChild = oldChildren[i];
+    const newChild = newChildren[i];
+    const existingNode = parent.childNodes[i];
+    if (!oldChild && newChild) {
+      parent.appendChild(createDOM(newChild));
+    } else if (oldChild && !newChild) {
+      if (existingNode) parent.removeChild(existingNode);
+    } else if (oldChild && newChild) {
+      if (isSameVNodeType(oldChild, newChild)) {
+        patchVNode(existingNode ?? null, oldChild, newChild);
+      } else {
+        const newNode = createDOM(newChild);
+        parent.replaceChild(newNode, existingNode);
+      }
+    }
+  }
+}
+function patchVNode(dom, oldVNode, newVNode) {
+  if (!dom) return;
+  if (oldVNode.type === "element" && newVNode.type === "element") {
+    patchProps(dom, oldVNode.props, newVNode.props);
+    patchChildren(dom, oldVNode.children, newVNode.children);
+  } else if (oldVNode.type === "text" && newVNode.type === "text") {
+    if (oldVNode.text !== newVNode.text) {
+      dom.textContent = newVNode.text;
+    }
+  } else if (oldVNode.type === "fragment" && newVNode.type === "fragment") {
+    patchChildren(dom.parentNode || dom, oldVNode.children, newVNode.children);
+  }
+}
+function patch(dom, oldVNode, newVNode) {
+  if (isSameVNodeType(oldVNode, newVNode)) {
+    patchVNode(dom, oldVNode, newVNode);
+  } else {
+    const parent = dom.parentNode;
+    if (parent) {
+      parent.replaceChild(createDOM(newVNode), dom);
+    }
+  }
+}
+function hydrate(vnode, container) {
+  function hydrateNode(vn, node) {
+    if (vn.type === "element") {
+      const el = node;
+      for (const [key, value] of Object.entries(vn.props)) {
+        if (key.startsWith("on") && typeof value === "function") {
+          el.addEventListener(key.slice(2).toLowerCase(), value);
+        }
+      }
+      for (let i = 0; i < Math.min(vn.children.length, el.childNodes.length); i++) {
+        hydrateNode(vn.children[i], el.childNodes[i]);
+      }
+    } else if (vn.type === "component") {
+      const result = vn.component(vn.props);
+      if (!(result instanceof Promise)) hydrateNode(result, node);
+    } else if (vn.type === "signal") {
+      vn.signal.subscribe((newVal) => {
+        const newChild = normalizeChild(newVal);
+        if (newChild && node.parentNode) {
+          node.parentNode.replaceChild(createDOM(newChild), node);
+        }
+      });
+    }
+  }
+  if (container.firstChild) {
+    hydrateNode(vnode, container.firstChild);
+  } else {
+    render(vnode, container);
+  }
+}
+var ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(str) {
+  return str.replace(/[&<>"']/g, (c) => ESCAPE_MAP[c] || c);
+}
+function renderProps(props) {
+  let out = "";
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "key" || key === "children" || key === "ref") continue;
+    if (key.startsWith("on")) continue;
+    if (value === false || value === null || value === void 0) continue;
+    if (key === "style" && typeof value === "object") {
+      const styleStr = Object.entries(value).map(([k, v]) => `${k.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase())}:${v}`).join(";");
+      out += ' style="' + escapeHtml(styleStr) + '"';
+      continue;
+    }
+    if (key === "class" || key === "className") {
+      const cls = Array.isArray(value) ? value.filter(Boolean).join(" ") : value;
+      out += ' class="' + escapeHtml(String(cls)) + '"';
+      continue;
+    }
+    if (key === "htmlFor") {
+      out += ' for="' + escapeHtml(String(value)) + '"';
+      continue;
+    }
+    if (value === true) {
+      out += " " + key;
+    } else {
+      out += " " + key + '="' + escapeHtml(String(value)) + '"';
+    }
+  }
+  return out;
+}
+function renderVNodeToString(vnode) {
+  switch (vnode.type) {
+    case "element": {
+      const children = vnode.children.map(renderVNodeToString).join("");
+      if (VOID_ELEMENTS.has(vnode.tag)) return "<" + vnode.tag + renderProps(vnode.props) + ">";
+      return "<" + vnode.tag + renderProps(vnode.props) + ">" + children + "</" + vnode.tag + ">";
+    }
+    case "text":
+      return escapeHtml(vnode.text);
+    case "fragment":
+      return vnode.children.map(renderVNodeToString).join("");
+    case "component": {
+      const result = vnode.component(vnode.props);
+      if (result instanceof Promise) throw new Error("Async components must use renderToStream or ServerRenderer");
+      return renderVNodeToString(result);
+    }
+    case "signal":
+      return renderVNodeToString(normalizeChild(vnode.signal.value) ?? text(""));
+  }
+}
+function renderToString(vnode) {
+  return renderVNodeToString(vnode);
+}
+function renderToStream(vnode) {
+  return new ReadableStream({
+    start(controller) {
+      const html = renderToString(vnode);
+      controller.enqueue(html);
+      controller.close();
+    }
+  });
+}
+
+// src/client/vdom/jsx.ts
+var emptyText = () => ({ type: "text", text: "" });
+function createElement(tag, props, ...children) {
+  const { isSVG, ...rest } = props || {};
+  if (typeof tag === "function") {
+    const childArr = children.flat(Infinity);
+    const result2 = {
+      type: "component",
+      component: tag,
+      props: { ...rest, children: childArr.length > 0 ? childArr : void 0 }
+    };
+    return result2;
+  }
+  const childNodes = children.flat(Infinity).map((c) => {
+    if (c == null || typeof c === "boolean") return emptyText();
+    if (typeof c === "object" && c !== null && "type" in c) return c;
+    return { type: "text", text: String(c) };
+  });
+  const result = {
+    type: "element",
+    tag,
+    props: rest || {},
+    children: childNodes
+  };
+  return result;
+}
+function Fragment(props) {
+  const children = props?.children;
+  if (!children) return emptyText();
+  const arr = Array.isArray(children) ? children : [children];
+  const flat = arr.flat(Infinity).map((c) => {
+    if (c == null || typeof c === "boolean") return emptyText();
+    if (typeof c === "object" && c !== null && "type" in c) return c;
+    return { type: "text", text: String(c) };
+  });
+  if (flat.length === 1) return flat[0];
+  const result = { type: "fragment", children: flat };
+  return result;
+}
+
+// src/client/render/index.ts
+var ServerRenderer = class {
+  render(component, props) {
+    const vnode = {
+      type: "component",
+      component,
+      props: props || {}
+    };
+    return Promise.resolve(renderToString(vnode));
+  }
+  renderToStream(component, props) {
+    const vnode = {
+      type: "component",
+      component,
+      props: props || {}
+    };
+    return renderToStream(vnode);
+  }
+  renderStatic(component, props) {
+    const vnode = {
+      type: "component",
+      component,
+      props: props || {}
+    };
+    return renderToString(vnode);
+  }
+  async renderServerComponent(path, props) {
+    const mod = await import(path);
+    const compKey = Object.keys(mod).find((k) => typeof mod[k] === "function");
+    if (!compKey) throw new Error(`No component export found in ${path}`);
+    const component = mod[compKey];
+    const result = component(props || {});
+    const resolved = result instanceof Promise ? await result : result;
+    return renderToString(resolved);
+  }
+};
+function generateHydrationScript() {
+  return '<script>(function(){var d=document.createElement("div");d.setAttribute("data-speedx-hydrated","");document.body.appendChild(d)})();</script>';
+}
+
+// src/client/adapters/index.ts
+function defineAdapter(adapter) {
+  return adapter;
+}
+
+// src/client/router.ts
+function parseQuery(search) {
+  const params = {};
+  const qs = search.startsWith("?") ? search.slice(1) : search;
+  if (!qs) return params;
+  for (const part of qs.split("&")) {
+    const [key, val] = part.split("=");
+    if (key) params[decodeURIComponent(key)] = val ? decodeURIComponent(val) : "";
+  }
+  return params;
+}
+function matchPath(routePath, urlPath) {
+  const routeParts = routePath.split("/");
+  const urlParts = urlPath.split("/");
+  if (routeParts.length !== urlParts.length) return null;
+  const params = {};
+  for (let i = 0; i < routeParts.length; i++) {
+    const rp = routeParts[i];
+    const up = urlParts[i];
+    if (rp.startsWith(":")) {
+      params[rp.slice(1)] = decodeURIComponent(up);
+    } else if (rp !== up) {
+      return null;
+    }
+  }
+  return params;
+}
+var ClientRouter = class {
+  _current;
+  _params;
+  _query;
+  _history = [];
+  _historyIndex = -1;
+  _routes;
+  _options;
+  constructor(routes, options) {
+    this._routes = routes;
+    this._options = {
+      basePath: options?.basePath ?? "",
+      mode: options?.mode ?? "history",
+      scrollRestoration: options?.scrollRestoration ?? true
+    };
+    const initialMatch = this._resolveRoute(this._getCurrentPath());
+    this._current = signal(initialMatch);
+    this._params = signal(initialMatch?.params ?? {});
+    this._query = signal(parseQuery(window.location.search));
+    if (this._options.scrollRestoration) {
+      history.scrollRestoration = "auto";
+    }
+    window.addEventListener("popstate", () => {
+      const path = this._getCurrentPath();
+      const match = this._resolveRoute(path);
+      this._current.value = match;
+      this._params.value = match?.params ?? {};
+      this._query.value = parseQuery(window.location.search);
+    });
+  }
+  get current() {
+    return this._current;
+  }
+  get params() {
+    return this._params;
+  }
+  get query() {
+    return this._query;
+  }
+  _getCurrentPath() {
+    if (this._options.mode === "hash") {
+      const hash = window.location.hash.slice(1) || "/";
+      return hash;
+    }
+    let path = window.location.pathname;
+    if (this._options.basePath && path.startsWith(this._options.basePath)) {
+      path = path.slice(this._options.basePath.length) || "/";
+    }
+    return path;
+  }
+  _resolveRoute(path) {
+    for (const route of this._routes) {
+      const params = matchPath(route.path, path);
+      if (params !== null) {
+        return {
+          path,
+          pattern: route.path,
+          component: route.component,
+          layout: route.layout,
+          loading: route.loading,
+          error: route.error,
+          params,
+          query: parseQuery(window.location.search)
+        };
+      }
+    }
+    return null;
+  }
+  async navigate(path) {
+    const from = this._getCurrentPath();
+    const to = path;
+    const route = this._routes.find((r) => matchPath(r.path, to) !== null);
+    if (route?.guards) {
+      for (const guard of route.guards) {
+        const allowed = await guard(to, from);
+        if (!allowed) throw new Error(`Navigation guard blocked: ${from} -> ${to}`);
+      }
+    }
+    const resolvedPath = this._options.basePath ? this._options.basePath + to : to;
+    if (this._options.mode === "hash") {
+      window.location.hash = to;
+    } else {
+      history.pushState(null, "", resolvedPath);
+    }
+    if (this._historyIndex < this._history.length - 1) {
+      this._history = this._history.slice(0, this._historyIndex + 1);
+    }
+    this._history.push(to);
+    this._historyIndex++;
+    const match = this._resolveRoute(to);
+    this._current.value = match;
+    this._params.value = match?.params ?? {};
+    this._query.value = parseQuery(window.location.search);
+  }
+  back() {
+    if (this._historyIndex > 0) {
+      this._historyIndex--;
+      const path = this._history[this._historyIndex];
+      if (this._options.mode === "hash") {
+        window.location.hash = path;
+      } else {
+        history.back();
+      }
+    }
+  }
+  forward() {
+    if (this._historyIndex < this._history.length - 1) {
+      this._historyIndex++;
+      const path = this._history[this._historyIndex];
+      if (this._options.mode === "hash") {
+        window.location.hash = path;
+      } else {
+        history.forward();
+      }
+    }
+  }
+  link(props) {
+    const isActive = computed(() => {
+      const current = this._current.value;
+      return current?.path === props.to;
+    });
+    const handleClick = (e) => {
+      if (e.metaKey || e.ctrlKey || e.shiftKey || e.button === 1) return;
+      e.preventDefault();
+      props.onClick?.(e);
+      this.navigate(props.to);
+    };
+    const { children, to, activeClass, ...rest } = props;
+    const cls = computed(() => {
+      const base = rest.class || "";
+      const active = activeClass && isActive.value ? ` ${activeClass}` : "";
+      return `${base}${active}`;
+    });
+    const childNodes = (Array.isArray(children) ? children : [children]).flat(Infinity).map((c) => {
+      if (c == null || typeof c === "boolean") return { type: "text", text: "" };
+      if (typeof c === "object" && "type" in c) return c;
+      return { type: "text", text: String(c) };
+    });
+    return {
+      type: "element",
+      tag: "a",
+      props: { href: this._options.basePath + to, onClick: handleClick, class: cls },
+      children: childNodes
+    };
+  }
+};
+export {
+  ClientRouter,
+  Computed,
+  Effect,
+  Fragment,
+  ServerRenderer,
+  Signal,
+  batch,
+  computed,
+  createComponent,
+  createElement,
+  defineAdapter,
+  effect,
+  fragment,
+  generateHydrationScript,
+  h,
+  hydrate,
+  isComputed,
+  isSignal,
+  mergeSignals,
+  normalizeChild,
+  patch,
+  render,
+  renderToStream,
+  renderToString,
+  signal,
+  text,
+  toSignal,
+  untracked
+};
+//# sourceMappingURL=index.js.map