@epoch32/visage 0.0.0-stage → 0.0.0

package/dist/src/router/index.js

@@ -0,0 +1,1856 @@
+// src/signals/types.ts
+var SubscriberState;
+((SubscriberState) => {
+  SubscriberState[SubscriberState["CLEAN"] = 0] = "CLEAN";
+  SubscriberState[SubscriberState["CHECK_DIRTY"] = 1] = "CHECK_DIRTY";
+  SubscriberState[SubscriberState["DIRTY"] = 2] = "DIRTY";
+  SubscriberState[SubscriberState["DISPOSED"] = 3] = "DISPOSED";
+})(SubscriberState ||= {});
+var SIGNAL_BRAND = Symbol("visage.signal");
+var COMPUTED_BRAND = Symbol("visage.computed");
+function isSignal(value) {
+  return typeof value === "function" && ((SIGNAL_BRAND in value) || (COMPUTED_BRAND in value));
+}
+
+// src/signals/system.ts
+var currentSubscriber = null;
+var currentScope = null;
+var batchDepth = 0;
+var pendingEffects = new Set;
+var warnedCyclicSubscribers = new WeakSet;
+var isFlushing = false;
+function setCurrentSubscriber(sub) {
+  currentSubscriber = sub;
+}
+function setCurrentScope(scope) {
+  currentScope = scope;
+}
+function getCurrentScope() {
+  return currentScope;
+}
+function addPendingEffect(eff) {
+  pendingEffects.add(eff);
+}
+function removePendingEffect(eff) {
+  pendingEffects.delete(eff);
+}
+var MAX_FLUSH_COUNT = 100;
+function flushEffects() {
+  if (isFlushing || batchDepth > 0)
+    return;
+  isFlushing = true;
+  let iterations = 0;
+  try {
+    while (pendingEffects.size > 0) {
+      if (++iterations > MAX_FLUSH_COUNT) {
+        pendingEffects.clear();
+        throw new Error(`[Visage Reactivity] Maximum update depth exceeded (${MAX_FLUSH_COUNT} cycles). ` + `An effect continuously triggered state mutations (infinite loop detected). ` + `Ensure effects that modify signals do not unconditionally depend on them, or use untrack() to read state.`);
+      }
+      const effectsToRun = Array.from(pendingEffects);
+      pendingEffects.clear();
+      for (const eff of effectsToRun) {
+        if (eff.state === 2 /* DIRTY */ || eff.state === 1 /* CHECK_DIRTY */) {
+          eff.run();
+        }
+      }
+    }
+  } finally {
+    isFlushing = false;
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushEffects();
+    }
+  }
+}
+function untrack(fn) {
+  const prev = currentSubscriber;
+  currentSubscriber = null;
+  try {
+    return fn();
+  } finally {
+    currentSubscriber = prev;
+  }
+}
+
+// src/signals/computed.ts
+class Computed {
+  [COMPUTED_BRAND] = true;
+  _fn;
+  _value;
+  _subscribers = new Set;
+  sources = new Set;
+  sourceVersions = new Map;
+  state = 2 /* DIRTY */;
+  scope;
+  version = 0;
+  constructor(fn) {
+    this._fn = fn;
+    this.scope = currentScope;
+    if (currentScope) {
+      currentScope.addSubscriber(this);
+    }
+  }
+  get() {
+    if (this.state === 3 /* DISPOSED */) {
+      return this._fn();
+    }
+    if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
+      this._subscribers.add(currentSubscriber);
+      currentSubscriber.sources.add(this);
+      currentSubscriber.sourceVersions.set(this, this.version);
+    }
+    if (this.state === 2 /* DIRTY */ || this.state === 1 /* CHECK_DIRTY */) {
+      this.updateIfNecessary();
+    }
+    return this._value;
+  }
+  get value() {
+    return this.get();
+  }
+  removeSubscriber(sub) {
+    this._subscribers.delete(sub);
+  }
+  markDirty(targetState = 1 /* CHECK_DIRTY */) {
+    if (this.state >= targetState || this.state === 3 /* DISPOSED */) {
+      return;
+    }
+    this.state = targetState;
+    for (const sub of this._subscribers) {
+      sub.markDirty(1 /* CHECK_DIRTY */);
+    }
+  }
+  updateIfNecessary() {
+    if (this.state === 2 /* DIRTY */) {
+      const prev = this._value;
+      this.recompute();
+      return !Object.is(prev, this._value);
+    }
+    if (this.state === 1 /* CHECK_DIRTY */) {
+      let anyChanged = false;
+      for (const source of this.sources) {
+        if (source instanceof Computed) {
+          source.updateIfNecessary();
+        }
+        const lastVersion = this.sourceVersions.get(source);
+        if (lastVersion !== undefined && lastVersion !== source.version) {
+          anyChanged = true;
+        }
+      }
+      if (anyChanged) {
+        const prev = this._value;
+        this.recompute();
+        return !Object.is(prev, this._value);
+      }
+      this.state = 0 /* CLEAN */;
+      return false;
+    }
+    return false;
+  }
+  recompute() {
+    this.cleanupSources();
+    const prevSubscriber = currentSubscriber;
+    setCurrentSubscriber(this);
+    const prevScope = currentScope;
+    setCurrentScope(this.scope);
+    try {
+      const next = this._fn();
+      if (!Object.is(this._value, next)) {
+        this._value = next;
+        this.version++;
+      }
+      this.state = 0 /* CLEAN */;
+    } finally {
+      setCurrentSubscriber(prevSubscriber);
+      setCurrentScope(prevScope);
+    }
+  }
+  cleanupSources() {
+    for (const source of this.sources) {
+      source.removeSubscriber(this);
+    }
+    this.sources.clear();
+    this.sourceVersions.clear();
+  }
+  dispose() {
+    if (this.state === 3 /* DISPOSED */)
+      return;
+    this.state = 3 /* DISPOSED */;
+    this.cleanupSources();
+    this._subscribers.clear();
+  }
+}
+function computed(fn, options) {
+  const isInternal = options?.internal ?? false;
+  const customName = options?.name;
+  const c = new Computed(fn);
+  const accessor = () => c.get();
+  Object.defineProperties(accessor, {
+    [COMPUTED_BRAND]: { value: true },
+    get: { value: () => c.get() },
+    value: { get: () => c.get() }
+  });
+  if (!isInternal && typeof window !== "undefined" && window.__VISAGE_DEVTOOLS__) {
+    const devtools = window.__VISAGE_DEVTOOLS__;
+    const sigId = devtools.registerSignal({
+      name: customName,
+      type: "computed",
+      getValue: () => c.get(),
+      version: () => c.version,
+      subscribersCount: () => c._subscribers?.size ?? 0,
+      dependencies: () => Array.from(c.sources ?? []).map((src) => src._devId).filter(Boolean),
+      dependents: () => Array.from(c._subscribers ?? []).map((sub) => sub._devId).filter(Boolean)
+    });
+    c._devId = sigId;
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        devtools.unregisterSignal(sigId);
+      });
+    }
+  }
+  return accessor;
+}
+var createMemo = computed;
+// src/style/cx.ts
+function hasReactiveClass(val) {
+  if (typeof val === "function")
+    return true;
+  if (Array.isArray(val)) {
+    for (let i = 0;i < val.length; i++) {
+      if (hasReactiveClass(val[i]))
+        return true;
+    }
+    return false;
+  }
+  if (typeof val === "object" && val !== null) {
+    for (const k in val) {
+      if (typeof val[k] === "function")
+        return true;
+    }
+  }
+  return false;
+}
+function normalizeClass(val) {
+  if (!val)
+    return "";
+  if (typeof val === "function")
+    return normalizeClass(val());
+  if (typeof val === "string")
+    return val.trim();
+  if (typeof val === "number")
+    return String(val);
+  if (Array.isArray(val)) {
+    let res = "";
+    for (let i = 0;i < val.length; i++) {
+      const item = typeof val[i] === "function" ? val[i]() : val[i];
+      const itemStr = normalizeClass(item);
+      if (itemStr) {
+        res = res ? `${res} ${itemStr}` : itemStr;
+      }
+    }
+    return res;
+  }
+  if (typeof val === "object") {
+    let res = "";
+    for (const key in val) {
+      const condition = typeof val[key] === "function" ? val[key]() : val[key];
+      if (condition) {
+        res = res ? `${res} ${key}` : key;
+      }
+    }
+    return res;
+  }
+  return "";
+}
+function cx(...args) {
+  return normalizeClass(args);
+}
+
+// src/style/scale.ts
+var UNITLESS_PROPERTIES = new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageSlice",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexShrink",
+  "flexOrder",
+  "fontWeight",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  "strokeOpacity"
+]);
+var DIMENSION_KEYWORDS = {
+  screen: "100dvh",
+  "screen-h": "100dvh",
+  "screen-w": "100dvw",
+  full: "100%",
+  half: "50%",
+  third: "33.333333%",
+  "two-thirds": "66.666667%",
+  quarter: "25%",
+  "three-quarters": "75%",
+  auto: "auto",
+  min: "min-content",
+  max: "max-content",
+  fit: "fit-content"
+};
+function space(val) {
+  if (val === undefined || val === null || val === "")
+    return "";
+  if (typeof val === "number") {
+    if (val === 0)
+      return "0px";
+    return `${val * 4}px`;
+  }
+  const str = String(val).trim();
+  if (str in DIMENSION_KEYWORDS) {
+    return DIMENSION_KEYWORDS[str];
+  }
+  return str;
+}
+function resolveDimension(val) {
+  if (val === undefined || val === null || val === "")
+    return "";
+  if (typeof val === "number") {
+    if (val === 0)
+      return "0px";
+    if (val > 48)
+      return `${val}px`;
+    return `${val * 4}px`;
+  }
+  const str = String(val).trim();
+  if (str in DIMENSION_KEYWORDS) {
+    return DIMENSION_KEYWORDS[str];
+  }
+  return str;
+}
+function px(val) {
+  return `${val}px`;
+}
+function rem(val) {
+  return `${val}rem`;
+}
+function em(val) {
+  return `${val}em`;
+}
+function fluid(minPx, maxPx, options) {
+  const minVw = options?.minVw ?? 375;
+  const maxVw = options?.maxVw ?? 1280;
+  const slope = (maxPx - minPx) / (maxVw - minVw);
+  const yIntercept = -minVw * slope + minPx;
+  const slopeVw = slope * 100;
+  const preferred = `${yIntercept.toFixed(2)}px + ${slopeVw.toFixed(2)}vw`;
+  const min = Math.min(minPx, maxPx);
+  const max = Math.max(minPx, maxPx);
+  return `clamp(${min}px, ${preferred}, ${max}px)`;
+}
+var SHADOW_PRESETS = {
+  none: "none",
+  sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
+  md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+  lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
+  xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1)",
+  soft: "0 8px 30px rgba(0, 0, 0, 0.06)",
+  glow: "0 0 24px rgba(168, 85, 247, 0.35)",
+  inner: "inset 0 2px 4px 0 rgba(0, 0, 0, 0.06)"
+};
+function shadow(variant) {
+  if (variant in SHADOW_PRESETS) {
+    return SHADOW_PRESETS[variant];
+  }
+  return variant;
+}
+var RADIUS_PRESETS = {
+  none: "0px",
+  sm: "4px",
+  md: "8px",
+  lg: "12px",
+  xl: "16px",
+  "2xl": "20px",
+  "3xl": "24px",
+  full: "9999px"
+};
+function radius(variant) {
+  if (typeof variant === "number") {
+    return `${variant}px`;
+  }
+  if (variant in RADIUS_PRESETS) {
+    return RADIUS_PRESETS[variant];
+  }
+  return String(variant);
+}
+function glass(options = {}) {
+  const blurVal = typeof options.blur === "number" ? `${options.blur}px` : options.blur ?? "20px";
+  const tintVal = options.tint ?? "rgba(255, 255, 255, 0.65)";
+  const borderVal = options.border ?? "1px solid rgba(255, 255, 255, 0.75)";
+  return {
+    backdropFilter: `blur(${blurVal})`,
+    WebkitBackdropFilter: `blur(${blurVal})`,
+    backgroundColor: tintVal,
+    border: borderVal
+  };
+}
+function formatStyleProp(prop, val) {
+  if (val === null || val === undefined || val === "")
+    return "";
+  if (typeof val === "number") {
+    if (val === 0 || UNITLESS_PROPERTIES.has(prop)) {
+      return String(val);
+    }
+    return `${val}px`;
+  }
+  const str = String(val).trim();
+  if (str in DIMENSION_KEYWORDS) {
+    const lowerProp = prop.toLowerCase();
+    if (str === "screen") {
+      if (lowerProp.includes("width"))
+        return "100dvw";
+      return "100dvh";
+    }
+    return DIMENSION_KEYWORDS[str];
+  }
+  return str;
+}
+
+// src/dom/render.ts
+function isReactive(value) {
+  return isSignal(value) || typeof value === "function";
+}
+function resolveValue(val) {
+  if (typeof val === "function") {
+    return val();
+  }
+  return val;
+}
+function render(fn, container) {
+  return createRoot((dispose) => {
+    container.textContent = "";
+    const node = insertChild(container, fn());
+    onCleanup(() => {
+      if (node && node instanceof Node && node.parentNode === container) {
+        container.removeChild(node);
+      }
+    });
+    return dispose;
+  });
+}
+function setAttribute(el, key, value) {
+  if (key.startsWith("on") && typeof value === "function") {
+    const eventName = key.startsWith("onCapture") ? key.slice(9).toLowerCase() : key.slice(2).toLowerCase();
+    const useCapture = key.startsWith("onCapture");
+    el.addEventListener(eventName, value, useCapture);
+    onCleanup(() => {
+      el.removeEventListener(eventName, value, useCapture);
+    });
+    return;
+  }
+  if (key === "ref" && typeof value === "function") {
+    value(el);
+    return;
+  }
+  if (key === "class" || key === "className") {
+    if (hasReactiveClass(value)) {
+      effect(() => {
+        const cls = normalizeClass(value);
+        if (cls)
+          el.setAttribute("class", cls);
+        else
+          el.removeAttribute("class");
+      });
+    } else {
+      const cls = normalizeClass(value);
+      if (cls)
+        el.setAttribute("class", cls);
+      else
+        el.removeAttribute("class");
+    }
+    return;
+  }
+  if (isReactive(value)) {
+    effect(() => {
+      const resolved = resolveValue(value);
+      applyProp(el, key, resolved);
+    });
+  } else {
+    applyProp(el, key, value);
+  }
+}
+function setStyleProperty(el, prop, val) {
+  const formatted = formatStyleProp(prop, val);
+  if (prop.startsWith("--") || prop.includes("-")) {
+    if (formatted === "") {
+      el.style.removeProperty(prop);
+    } else {
+      el.style.setProperty(prop, formatted);
+    }
+  } else {
+    el.style[prop] = formatted;
+  }
+}
+function applyProp(el, key, value) {
+  if (value === null || value === undefined || value === false && !key.startsWith("aria-") && !key.startsWith("data-")) {
+    if (key === "className" || key === "class") {
+      el.removeAttribute("class");
+    } else if (key === "style" && typeof value === "string") {
+      el.removeAttribute("style");
+    } else if (key in el && !(el instanceof SVGElement)) {
+      try {
+        el[key] = typeof el[key] === "boolean" ? false : "";
+      } catch {
+        el.removeAttribute(key);
+      }
+    } else {
+      el.removeAttribute(key);
+    }
+    return;
+  }
+  if (key === "className" || key === "class") {
+    const cls = normalizeClass(value);
+    if (cls) {
+      el.setAttribute("class", cls);
+    } else {
+      el.removeAttribute("class");
+    }
+  } else if (key === "style") {
+    if (typeof value === "string") {
+      el.setAttribute("style", value);
+    } else if (typeof value === "object" && value !== null) {
+      for (const styleKey in value) {
+        const styleVal = value[styleKey];
+        if (isReactive(styleVal)) {
+          effect(() => {
+            setStyleProperty(el, styleKey, resolveValue(styleVal));
+          });
+        } else {
+          setStyleProperty(el, styleKey, styleVal);
+        }
+      }
+    }
+  } else if (key === "dangerouslySetInnerHTML" && value && typeof value.__html === "string") {
+    el.innerHTML = value.__html;
+  } else if (key in el && !(el instanceof SVGElement) && key !== "list" && key !== "form") {
+    try {
+      el[key] = value;
+    } catch {
+      el.setAttribute(key, String(value));
+    }
+  } else {
+    if (key.startsWith("aria-") || key.startsWith("data-")) {
+      el.setAttribute(key, String(value));
+    } else if (value === true) {
+      el.setAttribute(key, "");
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  }
+}
+function insertChild(parent, child, before = null) {
+  if (child === null || child === undefined || child === false || child === true) {
+    return null;
+  }
+  if (child instanceof Node) {
+    parent.insertBefore(child, before);
+    return child;
+  }
+  if (Array.isArray(child)) {
+    const fragment = document.createDocumentFragment();
+    for (const item of child) {
+      insertChild(fragment, item);
+    }
+    parent.insertBefore(fragment, before);
+    return fragment;
+  }
+  if (isReactive(child)) {
+    const marker = document.createTextNode("");
+    parent.insertBefore(marker, before);
+    let childScope = null;
+    let currentNodes = [];
+    effect(() => {
+      const resolved = resolveValue(child);
+      if ((typeof resolved === "string" || typeof resolved === "number") && currentNodes.length === 1 && currentNodes[0].nodeType === Node.TEXT_NODE) {
+        currentNodes[0].data = String(resolved);
+        return;
+      }
+      if (childScope) {
+        childScope.dispose();
+      }
+      childScope = new Scope(getActiveScope());
+      runInScope(childScope, () => {
+        for (const node of currentNodes) {
+          if (node.parentNode) {
+            node.parentNode.removeChild(node);
+          }
+        }
+        currentNodes = [];
+        if (resolved === null || resolved === undefined || resolved === false) {
+          return;
+        }
+        const frag = document.createDocumentFragment();
+        if (typeof resolved === "string" || typeof resolved === "number" || typeof resolved === "boolean") {
+          frag.appendChild(document.createTextNode(String(resolved)));
+        } else {
+          insertChild(frag, resolved);
+        }
+        currentNodes = Array.from(frag.childNodes);
+        if (marker.parentNode) {
+          marker.parentNode.insertBefore(frag, marker);
+        }
+      });
+    });
+    onCleanup(() => {
+      if (childScope) {
+        childScope.dispose();
+      }
+      for (const node of currentNodes) {
+        if (node.parentNode) {
+          node.parentNode.removeChild(node);
+        }
+      }
+      if (marker.parentNode) {
+        marker.parentNode.removeChild(marker);
+      }
+    });
+    return marker;
+  }
+  const textNode = document.createTextNode(String(child));
+  parent.insertBefore(textNode, before);
+  return textNode;
+}
+
+// src/signals/scope.ts
+class Scope {
+  subscribers = new Set;
+  cleanups = [];
+  parent = null;
+  isDisposed = false;
+  context;
+  constructor(parent = currentScope) {
+    this.parent = parent;
+    if (parent && !parent.isDisposed) {
+      parent.cleanups.push(() => this.dispose());
+      if (parent.context) {
+        this.context = new Map(parent.context);
+      }
+    }
+  }
+  addSubscriber(sub) {
+    if (this.isDisposed)
+      return;
+    this.subscribers.add(sub);
+  }
+  addCleanup(fn) {
+    if (this.isDisposed) {
+      fn();
+      return;
+    }
+    this.cleanups.push(fn);
+  }
+  dispose() {
+    if (this.isDisposed)
+      return;
+    this.isDisposed = true;
+    for (const sub of this.subscribers) {
+      sub.dispose();
+    }
+    this.subscribers.clear();
+    for (let i = this.cleanups.length - 1;i >= 0; i--) {
+      try {
+        this.cleanups[i]();
+      } catch (err) {
+        console.error("Error during cleanup:", err);
+      }
+    }
+    this.cleanups = [];
+  }
+}
+function onCleanup(fn) {
+  if (currentSubscriber && "addCleanup" in currentSubscriber) {
+    currentSubscriber.addCleanup(fn);
+  } else if (currentScope) {
+    currentScope.addCleanup(fn);
+  }
+}
+function createRoot(fn) {
+  const prevScope = currentScope;
+  const scope = new Scope(null);
+  setCurrentScope(scope);
+  try {
+    return fn(() => scope.dispose());
+  } finally {
+    setCurrentScope(prevScope);
+  }
+}
+function runInScope(scope, fn) {
+  const prevScope = currentScope;
+  setCurrentScope(scope);
+  try {
+    return fn();
+  } finally {
+    setCurrentScope(prevScope);
+  }
+}
+function getActiveScope() {
+  return getCurrentScope();
+}
+
+// src/signals/context.ts
+function createContext(defaultValue) {
+  const id = Symbol("visage.context");
+  const context = {
+    id,
+    defaultValue,
+    Provider: (props) => {
+      const parentScope = getActiveScope();
+      const scope = new Scope(parentScope);
+      if (!scope.context) {
+        scope.context = new Map(parentScope?.context);
+      }
+      scope.context.set(id, props.value);
+      return runInScope(scope, () => {
+        const content = typeof props.children === "function" ? untrack(() => props.children()) : props.children;
+        if (typeof document !== "undefined") {
+          const frag = document.createDocumentFragment();
+          insertChild(frag, content);
+          return frag;
+        }
+        return content;
+      });
+    }
+  };
+  return context;
+}
+function useContext(context) {
+  let scope = getActiveScope();
+  while (scope) {
+    if (scope.context?.has(context.id)) {
+      return scope.context.get(context.id);
+    }
+    scope = scope.parent;
+  }
+  return context.defaultValue;
+}
+// src/signals/effect.ts
+class Effect {
+  _fn;
+  sources = new Set;
+  sourceVersions = new Map;
+  cleanups = [];
+  state = 2 /* DIRTY */;
+  scope;
+  constructor(fn) {
+    this._fn = fn;
+    this.scope = currentScope;
+    if (currentScope) {
+      currentScope.addSubscriber(this);
+    }
+    this.run();
+  }
+  addCleanup(fn) {
+    this.cleanups.push(fn);
+  }
+  runCleanups() {
+    for (let i = this.cleanups.length - 1;i >= 0; i--) {
+      try {
+        this.cleanups[i]();
+      } catch (e) {
+        console.error("Error in effect cleanup:", e);
+      }
+    }
+    this.cleanups = [];
+  }
+  markDirty(targetState = 2 /* DIRTY */) {
+    if (this.state >= targetState || this.state === 3 /* DISPOSED */) {
+      return;
+    }
+    this.state = targetState;
+    addPendingEffect(this);
+    if (batchDepth === 0) {
+      flushEffects();
+    }
+  }
+  run() {
+    if (this.state === 3 /* DISPOSED */)
+      return;
+    if (this.state === 1 /* CHECK_DIRTY */) {
+      let isDirty = false;
+      for (const source of this.sources) {
+        if (source instanceof Computed) {
+          source.updateIfNecessary();
+        }
+        const lastVersion = this.sourceVersions.get(source);
+        if (lastVersion !== undefined && lastVersion !== source.version) {
+          isDirty = true;
+        }
+      }
+      if (!isDirty) {
+        this.state = 0 /* CLEAN */;
+        return;
+      }
+    }
+    this.runCleanups();
+    this.cleanupSources();
+    const prevSubscriber = currentSubscriber;
+    setCurrentSubscriber(this);
+    const prevScope = currentScope;
+    setCurrentScope(this.scope);
+    try {
+      this.state = 0 /* CLEAN */;
+      const res = this._fn();
+      if (typeof res === "function") {
+        this.cleanups.push(res);
+      }
+    } finally {
+      setCurrentSubscriber(prevSubscriber);
+      setCurrentScope(prevScope);
+    }
+  }
+  cleanupSources() {
+    for (const source of this.sources) {
+      source.removeSubscriber(this);
+    }
+    this.sources.clear();
+    this.sourceVersions.clear();
+  }
+  dispose() {
+    if (this.state === 3 /* DISPOSED */)
+      return;
+    this.state = 3 /* DISPOSED */;
+    this.runCleanups();
+    this.cleanupSources();
+    removePendingEffect(this);
+  }
+}
+function effect(fn) {
+  const eff = new Effect(fn);
+  return () => eff.dispose();
+}
+var createEffect = effect;
+// src/signals/signal.ts
+class Signal {
+  [SIGNAL_BRAND] = true;
+  _value;
+  _subscribers = new Set;
+  _equals;
+  version = 0;
+  constructor(initialValue, equals) {
+    this._value = initialValue;
+    this._equals = equals ?? Object.is;
+  }
+  get() {
+    if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
+      this._subscribers.add(currentSubscriber);
+      currentSubscriber.sources.add(this);
+      currentSubscriber.sourceVersions.set(this, this.version);
+    }
+    return this._value;
+  }
+  set(newValue) {
+    if (this._equals(this._value, newValue)) {
+      return;
+    }
+    if (currentSubscriber !== null && this._subscribers.has(currentSubscriber)) {
+      if (!warnedCyclicSubscribers.has(currentSubscriber)) {
+        warnedCyclicSubscribers.add(currentSubscriber);
+        if (typeof console !== "undefined" && typeof console.warn === "function") {
+          console.warn(`[Visage Reactivity] Cyclic update detected: An active subscriber modified a signal that it depends on. ` + `To read a signal inside an effect/computed without creating a circular dependency, wrap the read in untrack():
+` + `  untrack(() => signal())`);
+        }
+      }
+    }
+    this._value = newValue;
+    this.version++;
+    batch(() => {
+      this.notify();
+    });
+  }
+  update(fn) {
+    this.set(fn(this._value));
+  }
+  get value() {
+    return this.get();
+  }
+  set value(val) {
+    this.set(val);
+  }
+  removeSubscriber(sub) {
+    this._subscribers.delete(sub);
+  }
+  notify() {
+    if (this._subscribers.size === 0)
+      return;
+    const subs = Array.from(this._subscribers);
+    for (const sub of subs) {
+      sub.markDirty(2 /* DIRTY */);
+    }
+  }
+}
+function signal(initialValue, optionsOrEquals) {
+  const equals = typeof optionsOrEquals === "function" ? optionsOrEquals : optionsOrEquals?.equals;
+  const isInternal = typeof optionsOrEquals === "object" ? optionsOrEquals?.internal : false;
+  const customName = typeof optionsOrEquals === "object" ? optionsOrEquals?.name : undefined;
+  const s = new Signal(initialValue, equals);
+  const accessor = (...args) => {
+    if (args.length === 0) {
+      return s.get();
+    }
+    s.set(args[0]);
+    return args[0];
+  };
+  Object.defineProperties(accessor, {
+    [SIGNAL_BRAND]: { value: true },
+    get: { value: () => s.get() },
+    set: { value: (v) => s.set(v) },
+    update: { value: (fn) => s.update(fn) },
+    value: {
+      get: () => s.get(),
+      set: (v) => s.set(v)
+    }
+  });
+  if (!isInternal && typeof window !== "undefined" && window.__VISAGE_DEVTOOLS__) {
+    const devtools = window.__VISAGE_DEVTOOLS__;
+    const sigId = devtools.registerSignal({
+      name: customName,
+      type: "signal",
+      getValue: () => s.get(),
+      version: () => s.version,
+      subscribersCount: () => s._subscribers?.size ?? 0,
+      dependents: () => Array.from(s._subscribers ?? []).map((sub) => sub._devId).filter(Boolean)
+    });
+    s._devId = sigId;
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        devtools.unregisterSignal(sigId);
+      });
+    }
+  }
+  return accessor;
+}
+function createSignal(initialValue, optionsOrEquals) {
+  const s = signal(initialValue, optionsOrEquals);
+  const setter = (value) => {
+    if (typeof value === "function") {
+      s.update(value);
+    } else {
+      s.set(value);
+    }
+  };
+  return [s, setter];
+}
+// src/signals/store.ts
+var STORE_RAW = Symbol("visage.store.raw");
+var STORE_SIGNALS = Symbol("visage.store.signals");
+var STORE_PROXY = Symbol("visage.store.proxy");
+function isObject(val) {
+  return typeof val === "object" && val !== null && (typeof Node === "undefined" || !(val instanceof Node)) && !isSignal(val);
+}
+function getOrCreatePropertySignal(target, prop) {
+  let signalsMap = target[STORE_SIGNALS];
+  if (!signalsMap) {
+    signalsMap = new Map;
+    Object.defineProperty(target, STORE_SIGNALS, {
+      value: signalsMap,
+      enumerable: false,
+      writable: true
+    });
+  }
+  let sig = signalsMap.get(prop);
+  if (!sig) {
+    sig = new Signal(target[prop]);
+    signalsMap.set(prop, sig);
+  }
+  return sig;
+}
+function createStoreProxy(target) {
+  if (!isObject(target))
+    return target;
+  if (target[STORE_PROXY])
+    return target[STORE_PROXY];
+  const proxy = new Proxy(target, {
+    get(target, prop, receiver) {
+      if (prop === STORE_RAW)
+        return target;
+      if (prop === STORE_PROXY)
+        return proxy;
+      if (typeof prop === "string" || typeof prop === "symbol") {
+        const sig = getOrCreatePropertySignal(target, prop);
+        sig.get();
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (isObject(value)) {
+        return createStoreProxy(value);
+      }
+      return value;
+    },
+    set(target, prop, value, receiver) {
+      const prevValue = Reflect.get(target, prop, receiver);
+      if (Object.is(prevValue, value)) {
+        return true;
+      }
+      const success = Reflect.set(target, prop, value, receiver);
+      if (success) {
+        const sig = getOrCreatePropertySignal(target, prop);
+        sig.set(value);
+        if (Array.isArray(target) && prop !== "length") {
+          const lenSig = getOrCreatePropertySignal(target, "length");
+          lenSig.set(target.length);
+        }
+      }
+      return success;
+    },
+    deleteProperty(target, prop) {
+      const hadProp = Reflect.has(target, prop);
+      const success = Reflect.deleteProperty(target, prop);
+      if (hadProp && success) {
+        const sig = getOrCreatePropertySignal(target, prop);
+        sig.set(undefined);
+      }
+      return success;
+    }
+  });
+  Object.defineProperty(target, STORE_PROXY, {
+    value: proxy,
+    enumerable: false,
+    writable: true
+  });
+  return proxy;
+}
+function createStore(initialState) {
+  if (!isObject(initialState)) {
+    throw new Error("createStore requires an object or array as initial state");
+  }
+  return createStoreProxy(initialState);
+}
+function mutateStore(store, mutator) {
+  batch(() => {
+    mutator(store);
+  });
+}
+function unwrapStore(store) {
+  if (isObject(store) && store[STORE_RAW]) {
+    return store[STORE_RAW];
+  }
+  return store;
+}
+// src/dom/resource.ts
+var SuspenseContext = createContext(null);
+function createResource(sourceOrFetcher, maybeFetcher) {
+  const isDirect = typeof maybeFetcher !== "function";
+  const fetcher = isDirect ? sourceOrFetcher : maybeFetcher;
+  const source = isDirect ? null : sourceOrFetcher;
+  const data = signal(undefined);
+  const loading = signal(true);
+  const error = signal(null);
+  let currentPromise = null;
+  let requestId = 0;
+  const load = async (arg) => {
+    const currentReq = ++requestId;
+    loading.set(true);
+    error.set(null);
+    const promise = isDirect ? fetcher() : fetcher(arg);
+    currentPromise = promise;
+    const suspense = useContext(SuspenseContext);
+    if (suspense) {
+      suspense.registerPromise(promise);
+    }
+    try {
+      const res = await promise;
+      if (currentReq === requestId) {
+        data.set(res);
+        loading.set(false);
+        currentPromise = null;
+      }
+      return res;
+    } catch (err) {
+      if (currentReq === requestId) {
+        error.set(err);
+        loading.set(false);
+        currentPromise = null;
+      }
+      throw err;
+    }
+  };
+  if (source) {
+    effect(() => {
+      const sourceVal = resolveValue(source);
+      if (sourceVal !== false && sourceVal !== null && sourceVal !== undefined) {
+        load(sourceVal).catch(() => {});
+      }
+    });
+  } else {
+    load().catch(() => {});
+  }
+  const accessor = () => {
+    if (loading() && currentPromise) {
+      const suspense = useContext(SuspenseContext);
+      if (suspense) {
+        suspense.registerPromise(currentPromise);
+      }
+    }
+    return data();
+  };
+  Object.defineProperties(accessor, {
+    loading: { get: () => loading },
+    error: { get: () => error },
+    mutate: { value: (val) => data.set(val) },
+    refetch: { value: () => source ? load(resolveValue(source)) : load() }
+  });
+  return accessor;
+}
+
+// src/dom/lazy.ts
+function lazy(importer) {
+  let loadedComponent = null;
+  let loadingPromise = null;
+  const preload = () => {
+    if (loadedComponent) {
+      return Promise.resolve(loadedComponent);
+    }
+    if (!loadingPromise) {
+      loadingPromise = importer().then((mod) => {
+        const comp = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+        loadedComponent = comp;
+        return comp;
+      }).catch((err) => {
+        loadingPromise = null;
+        throw err;
+      });
+    }
+    return loadingPromise;
+  };
+  const LazyWrapper = (props) => {
+    if (loadedComponent) {
+      return loadedComponent(props);
+    }
+    const promise = preload();
+    const suspense = useContext(SuspenseContext);
+    if (suspense) {
+      suspense.registerPromise(promise);
+    }
+    const res = createResource(() => promise);
+    return () => {
+      const Comp = res();
+      return Comp ? Comp(props) : null;
+    };
+  };
+  LazyWrapper.preload = preload;
+  return LazyWrapper;
+}
+// src/dom/async.ts
+function Suspense(props) {
+  if (typeof document === "undefined") {
+    return typeof props.children === "function" ? props.children() : props.children;
+  }
+  const marker = document.createTextNode("");
+  const initialFrag = document.createDocumentFragment();
+  const pendingCount = signal(0);
+  let currentScope = null;
+  let currentNodes = [];
+  let isMounted = false;
+  const suspenseValue = {
+    registerPromise(p) {
+      pendingCount.update((c) => c + 1);
+      p.finally(() => {
+        pendingCount.update((c) => Math.max(0, c - 1));
+      });
+    }
+  };
+  const renderContent = (content) => {
+    const parent = marker.parentNode ?? (!isMounted ? initialFrag : null);
+    if (!parent)
+      return;
+    for (const n of currentNodes) {
+      if (n.parentNode)
+        n.parentNode.removeChild(n);
+    }
+    currentNodes = [];
+    const frag = document.createDocumentFragment();
+    insertChild(frag, content);
+    currentNodes = Array.from(frag.childNodes);
+    if (marker.parentNode) {
+      marker.parentNode.insertBefore(frag, marker);
+    } else if (!isMounted) {
+      initialFrag.appendChild(frag);
+    }
+  };
+  effect(() => {
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    currentScope = new Scope(getActiveScope());
+    runInScope(currentScope, () => {
+      let threwPromise = null;
+      let rendered = null;
+      try {
+        const SuspenseProvider = SuspenseContext.Provider;
+        rendered = SuspenseProvider({
+          value: suspenseValue,
+          children: props.children
+        });
+      } catch (err) {
+        if (err && typeof err.then === "function") {
+          threwPromise = err;
+          suspenseValue.registerPromise(err);
+        } else {
+          throw err;
+        }
+      }
+      if (pendingCount() > 0 || threwPromise) {
+        renderContent(props.fallback);
+      } else {
+        renderContent(rendered);
+      }
+    });
+  });
+  isMounted = true;
+  initialFrag.appendChild(marker);
+  onCleanup(() => {
+    if (currentScope)
+      currentScope.dispose();
+  });
+  return initialFrag;
+}
+function ErrorBoundary(props) {
+  if (typeof document === "undefined") {
+    try {
+      return typeof props.children === "function" ? props.children() : props.children;
+    } catch (err) {
+      return typeof props.fallback === "function" ? props.fallback(err, () => {}) : props.fallback;
+    }
+  }
+  const marker = document.createTextNode("");
+  const initialFrag = document.createDocumentFragment();
+  const currentError = signal(null);
+  let currentScope = null;
+  let currentNodes = [];
+  let isMounted = false;
+  const reset = () => {
+    currentError.set(null);
+  };
+  const renderNodes = (child) => {
+    const parent = marker.parentNode ?? (!isMounted ? initialFrag : null);
+    if (!parent)
+      return;
+    for (const n of currentNodes) {
+      if (n.parentNode)
+        n.parentNode.removeChild(n);
+    }
+    currentNodes = [];
+    const frag = document.createDocumentFragment();
+    insertChild(frag, child);
+    currentNodes = Array.from(frag.childNodes);
+    if (marker.parentNode) {
+      marker.parentNode.insertBefore(frag, marker);
+    } else if (!isMounted) {
+      initialFrag.appendChild(frag);
+    }
+  };
+  effect(() => {
+    const err = currentError();
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    currentScope = new Scope(getActiveScope());
+    runInScope(currentScope, () => {
+      if (err !== null) {
+        const fallbackNode = typeof props.fallback === "function" ? props.fallback(err, reset) : props.fallback;
+        renderNodes(fallbackNode);
+      } else {
+        try {
+          const content = typeof props.children === "function" ? props.children() : props.children;
+          renderNodes(content);
+        } catch (catchedErr) {
+          currentError.set(catchedErr);
+        }
+      }
+    });
+  });
+  isMounted = true;
+  initialFrag.appendChild(marker);
+  onCleanup(() => {
+    if (currentScope)
+      currentScope.dispose();
+  });
+  return initialFrag;
+}
+// src/dom/control-flow.ts
+function Show(props) {
+  if (typeof document === "undefined") {
+    const condition = resolveValue(props.when);
+    if (condition) {
+      return typeof props.children === "function" && props.children.length > 0 ? props.children(() => resolveValue(props.when)) : typeof props.children === "function" ? props.children() : props.children;
+    }
+    return props.fallback ?? null;
+  }
+  const marker = document.createTextNode("");
+  const initialFrag = document.createDocumentFragment();
+  let currentScope = null;
+  let currentContent = [];
+  let isMounted = false;
+  effect(() => {
+    const condition = resolveValue(props.when);
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    for (const node of currentContent) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    currentContent = [];
+    const frag = document.createDocumentFragment();
+    if (condition) {
+      currentScope = new Scope(getActiveScope());
+      untrack(() => {
+        runInScope(currentScope, () => {
+          const childRes = typeof props.children === "function" && props.children.length > 0 ? props.children(() => resolveValue(props.when)) : typeof props.children === "function" ? props.children() : props.children;
+          insertChild(frag, childRes);
+        });
+      });
+    } else if (props.fallback !== undefined) {
+      currentScope = new Scope(getActiveScope());
+      untrack(() => {
+        runInScope(currentScope, () => {
+          insertChild(frag, props.fallback);
+        });
+      });
+    }
+    currentContent = Array.from(frag.childNodes);
+    if (marker.parentNode) {
+      marker.parentNode.insertBefore(frag, marker);
+    } else if (!isMounted) {
+      initialFrag.appendChild(frag);
+    }
+  });
+  isMounted = true;
+  initialFrag.appendChild(marker);
+  onCleanup(() => {
+    if (currentScope) {
+      currentScope.dispose();
+    }
+  });
+  return initialFrag;
+}
+function For(props) {
+  if (typeof document === "undefined") {
+    const list = resolveValue(props.each) ?? [];
+    if (list.length === 0) {
+      return props.fallback ?? null;
+    }
+    return list.map((item, idx) => props.children(item, () => idx));
+  }
+  const marker = document.createTextNode("");
+  const initialFrag = document.createDocumentFragment();
+  let items = [];
+  let fallbackScope = null;
+  let fallbackNodes = [];
+  let isMounted = false;
+  effect(() => {
+    const list = resolveValue(props.each) ?? [];
+    const parent = marker.parentNode ?? (!isMounted ? initialFrag : null);
+    if (list.length === 0) {
+      for (const rec of items) {
+        rec.scope.dispose();
+        for (const node of rec.nodes) {
+          if (node.parentNode)
+            node.parentNode.removeChild(node);
+        }
+      }
+      items = [];
+      if (props.fallback !== undefined && fallbackNodes.length === 0 && parent) {
+        fallbackScope = new Scope(getActiveScope());
+        untrack(() => {
+          runInScope(fallbackScope, () => {
+            const frag = document.createDocumentFragment();
+            insertChild(frag, props.fallback);
+            fallbackNodes = Array.from(frag.childNodes);
+            if (marker.parentNode) {
+              marker.parentNode.insertBefore(frag, marker);
+            } else if (!isMounted) {
+              initialFrag.appendChild(frag);
+            }
+          });
+        });
+      }
+      return;
+    }
+    if (fallbackNodes.length > 0) {
+      if (fallbackScope) {
+        fallbackScope.dispose();
+        fallbackScope = null;
+      }
+      for (const node of fallbackNodes) {
+        if (node.parentNode)
+          node.parentNode.removeChild(node);
+      }
+      fallbackNodes = [];
+    }
+    if (!parent)
+      return;
+    const newItems = [];
+    const prevMap = new Map;
+    for (const rec of items) {
+      prevMap.set(rec.item, rec);
+    }
+    for (let i = 0;i < list.length; i++) {
+      const item = list[i];
+      const existing = prevMap.get(item);
+      if (existing) {
+        existing.indexSignal(i);
+        newItems.push(existing);
+        prevMap.delete(item);
+      } else {
+        let indexVal = i;
+        const indexSubscribers = new Set;
+        const indexSignal = (...args) => {
+          if (args.length > 0 && args[0] !== undefined && args[0] !== indexVal) {
+            indexVal = args[0];
+            for (const sub of Array.from(indexSubscribers))
+              sub();
+          }
+          return indexVal;
+        };
+        const itemScope = new Scope(getActiveScope());
+        let itemNodes = [];
+        untrack(() => {
+          runInScope(itemScope, () => {
+            const frag = document.createDocumentFragment();
+            const child = props.children(item, indexSignal);
+            insertChild(frag, child);
+            itemNodes = Array.from(frag.childNodes);
+          });
+        });
+        newItems.push({
+          item,
+          scope: itemScope,
+          nodes: itemNodes,
+          indexSignal
+        });
+      }
+    }
+    for (const [, removed] of prevMap) {
+      removed.scope.dispose();
+      for (const node of removed.nodes) {
+        if (node.parentNode)
+          node.parentNode.removeChild(node);
+      }
+    }
+    if (marker.parentNode) {
+      let currentMarker = marker;
+      for (let i = newItems.length - 1;i >= 0; i--) {
+        const rec = newItems[i];
+        for (let j = rec.nodes.length - 1;j >= 0; j--) {
+          const node = rec.nodes[j];
+          if (node.nextSibling !== currentMarker) {
+            marker.parentNode.insertBefore(node, currentMarker);
+          }
+          currentMarker = node;
+        }
+      }
+    } else if (!isMounted) {
+      for (const rec of newItems) {
+        for (const node of rec.nodes) {
+          initialFrag.appendChild(node);
+        }
+      }
+    }
+    items = newItems;
+  });
+  isMounted = true;
+  initialFrag.appendChild(marker);
+  onCleanup(() => {
+    for (const rec of items) {
+      rec.scope.dispose();
+    }
+    if (fallbackScope) {
+      fallbackScope.dispose();
+    }
+  });
+  return initialFrag;
+}
+function Portal(props) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const marker = document.createTextNode("");
+  let currentScope = null;
+  let nodes = [];
+  effect(() => {
+    const target = props.mount ?? (typeof document !== "undefined" ? document.body : null);
+    if (!target)
+      return;
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    for (const node of nodes) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    nodes = [];
+    currentScope = new Scope(getActiveScope());
+    untrack(() => {
+      runInScope(currentScope, () => {
+        const childRes = typeof props.children === "function" ? props.children() : props.children;
+        const frag = document.createDocumentFragment();
+        insertChild(frag, childRes);
+        nodes = Array.from(frag.childNodes);
+        target.appendChild(frag);
+      });
+    });
+  });
+  onCleanup(() => {
+    if (currentScope) {
+      currentScope.dispose();
+      currentScope = null;
+    }
+    for (const node of nodes) {
+      if (node.parentNode) {
+        node.parentNode.removeChild(node);
+      }
+    }
+    nodes = [];
+  });
+  return marker;
+}
+// src/jsx-runtime/index.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var SVG_TAGS = new Set([
+  "svg",
+  "path",
+  "circle",
+  "rect",
+  "g",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "defs",
+  "clipPath",
+  "linearGradient",
+  "radialGradient",
+  "stop"
+]);
+function Fragment(props) {
+  if (typeof document === "undefined") {
+    return props.children !== undefined ? props.children : [];
+  }
+  const fragment = document.createDocumentFragment();
+  if (props.children !== undefined) {
+    insertChild(fragment, props.children);
+  }
+  return fragment;
+}
+function jsx(type, props = {}, key) {
+  if (typeof type === "function") {
+    return type(props, key);
+  }
+  if (typeof type === "string") {
+    const { children, ...restProps } = props;
+    if (typeof document === "undefined") {
+      const attributes = new Map;
+      for (const propName in restProps) {
+        const val = restProps[propName];
+        if (propName === "className" || propName === "class") {
+          const resolved = typeof val === "function" ? val() : val;
+          if (resolved)
+            attributes.set("class", resolved);
+        } else if (propName === "style") {
+          const val = restProps[propName];
+          const resolved = resolveValue(val);
+          if (typeof resolved === "string") {
+            attributes.set("style", resolved);
+          } else if (typeof resolved === "object" && resolved !== null) {
+            const styleStr = Object.entries(resolved).map(([k, v]) => {
+              const finalVal = resolveValue(v);
+              const formatted = formatStyleProp(k, finalVal);
+              if (!formatted)
+                return "";
+              const kebab = k.startsWith("--") ? k : k.replace(/([A-Z])/g, "-$1").toLowerCase();
+              return `${kebab}: ${formatted}`;
+            }).filter(Boolean).join("; ");
+            if (styleStr)
+              attributes.set("style", styleStr);
+          }
+        } else if (!propName.startsWith("on")) {
+          const resolved = typeof val === "function" ? val() : val;
+          if (resolved === true) {
+            attributes.set(propName, propName);
+          } else if (resolved !== false && resolved !== null && resolved !== undefined) {
+            attributes.set(propName, resolved);
+          }
+        }
+      }
+      const childNodes = children !== undefined ? Array.isArray(children) ? children : [children] : [];
+      return {
+        tagName: type,
+        attributes,
+        childNodes
+      };
+    }
+    const isSvg = SVG_TAGS.has(type);
+    const element = isSvg ? document.createElementNS(SVG_NS, type) : document.createElement(type);
+    for (const propName in restProps) {
+      setAttribute(element, propName, restProps[propName]);
+    }
+    if (children !== undefined) {
+      insertChild(element, children);
+    }
+    return element;
+  }
+  return type;
+}
+var jsxs = jsx;
+var jsxDEV = jsx;
+
+// src/router/router.tsx
+var RouterContext = createContext(null);
+function compilePath(path) {
+  const paramNames = [];
+  const normalized = path.replace(/\/+$/, "") || "/";
+  const regexStr = normalized.replace(/:([a-zA-Z0-9_]+)/g, (_, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  }).replace(/\*/g, "(.*)");
+  const matcher = new RegExp(`^${regexStr}(?:/)?$`);
+  return { matcher, paramNames };
+}
+function matchRoute(routes, pathname, base = "") {
+  const cleanPath = base && pathname.startsWith(base) ? pathname.slice(base.length) || "/" : pathname;
+  for (const route of routes) {
+    const match = cleanPath.match(route.matcher);
+    if (match) {
+      const params = {};
+      const captures = match.slice(1);
+      route.paramNames.forEach((name, i) => {
+        params[name] = decodeURIComponent(captures[i] ?? "");
+      });
+      return {
+        path: route.path,
+        params,
+        component: route.component,
+        children: route.children
+      };
+    }
+  }
+  return null;
+}
+function Router(props) {
+  const base = props.base ?? "";
+  const mode = props.mode ?? "history";
+  const getPathname = () => {
+    if (typeof window === "undefined" || !window.location)
+      return "/";
+    if (mode === "hash") {
+      const hash = window.location.hash.slice(1) || "/";
+      return hash.split("?")[0] || "/";
+    }
+    return window.location.pathname || "/";
+  };
+  const getSearch = () => {
+    if (typeof window === "undefined" || !window.location)
+      return "";
+    if (mode === "hash") {
+      const hash = window.location.hash.slice(1);
+      const queryIdx = hash.indexOf("?");
+      return queryIdx !== -1 ? hash.slice(queryIdx) : "";
+    }
+    return window.location.search || "";
+  };
+  const getHash = () => {
+    if (typeof window === "undefined" || !window.location)
+      return "";
+    return window.location.hash || "";
+  };
+  const pathname = signal(getPathname());
+  const search = signal(getSearch());
+  const hash = signal(getHash());
+  const routes = [];
+  const registeredRoutes = signal([]);
+  const registerRoute = (route) => {
+    routes.push(route);
+    registeredRoutes.set([...routes]);
+  };
+  const syncLocation = () => {
+    pathname.set(getPathname());
+    search.set(getSearch());
+    hash.set(getHash());
+  };
+  if (typeof window !== "undefined") {
+    const eventName = mode === "hash" ? "hashchange" : "popstate";
+    window.addEventListener(eventName, syncLocation);
+    onCleanup(() => window.removeEventListener(eventName, syncLocation));
+  }
+  const navigate = (to, options) => {
+    if (typeof window === "undefined" || !window.history) {
+      pathname.set(to);
+      return;
+    }
+    const target = base ? `${base.replace(/\/$/, "")}/${to.replace(/^\//, "")}` : to;
+    if (mode === "hash") {
+      if (options?.replace) {
+        window.location.replace(`#${to}`);
+      } else {
+        window.location.hash = `#${to}`;
+      }
+    } else {
+      if (options?.replace) {
+        window.history.replaceState(null, "", target);
+      } else {
+        window.history.pushState(null, "", target);
+      }
+    }
+    syncLocation();
+  };
+  const matchedRoute = computed(() => {
+    const currentPath = pathname();
+    const routeList = registeredRoutes();
+    return matchRoute(routeList, currentPath, base);
+  });
+  const params = computed(() => matchedRoute()?.params ?? {});
+  const routerValue = {
+    location: { pathname, search, hash },
+    navigate,
+    params,
+    base,
+    matchedRoute,
+    routes,
+    registerRoute
+  };
+  return RouterContext.Provider({
+    value: routerValue,
+    children: props.children
+  });
+}
+function Route(props) {
+  const router = useContext(RouterContext);
+  if (!router) {
+    throw new Error("<Route> must be rendered inside a <Router>");
+  }
+  const { matcher, paramNames } = compilePath(props.path);
+  router.registerRoute({
+    path: props.path,
+    component: props.component,
+    children: props.children,
+    matcher,
+    paramNames
+  });
+  return null;
+}
+function Routes(props) {
+  const router = useContext(RouterContext);
+  if (!router) {
+    throw new Error("<Routes> must be rendered inside a <Router>");
+  }
+  const _ = typeof props.children === "function" ? props.children() : props.children;
+  return Show({
+    when: () => router.matchedRoute() !== null,
+    fallback: props.fallback ?? (() => document.createTextNode("404 Not Found")),
+    children: () => {
+      const match = router.matchedRoute();
+      if (!match)
+        return null;
+      if (match.component) {
+        return match.component({ params: match.params });
+      }
+      return match.children ?? null;
+    }
+  });
+}
+function Link(props) {
+  const router = useContext(RouterContext);
+  const { href, class: className, activeClass = "active", replace, children, ...rest } = props;
+  const handleClick = (e) => {
+    if (e.ctrlKey || e.metaKey || e.altKey || e.shiftKey || e.button !== 0) {
+      return;
+    }
+    e.preventDefault();
+    if (router) {
+      router.navigate(href, { replace });
+    } else if (typeof window !== "undefined") {
+      window.location.href = href;
+    }
+  };
+  const isActive = computed(() => {
+    if (!router)
+      return false;
+    const current = router.location.pathname();
+    return current === href || href !== "/" && current.startsWith(href);
+  });
+  const computedClass = computed(() => {
+    const baseCls = typeof className === "function" ? className() : className ?? "";
+    if (activeClass && isActive()) {
+      return baseCls ? `${baseCls} ${activeClass}` : activeClass;
+    }
+    return baseCls;
+  });
+  return /* @__PURE__ */ jsx("a", {
+    href,
+    class: computedClass,
+    onClick: handleClick,
+    ...rest,
+    children
+  });
+}
+function useLocation() {
+  const router = useContext(RouterContext);
+  if (!router)
+    throw new Error("useLocation must be used within a <Router>");
+  return router.location;
+}
+function useNavigate() {
+  const router = useContext(RouterContext);
+  if (!router)
+    throw new Error("useNavigate must be used within a <Router>");
+  return router.navigate;
+}
+function useParams() {
+  const router = useContext(RouterContext);
+  if (!router)
+    throw new Error("useParams must be used within a <Router>");
+  return () => router.params();
+}
+function useSearchParams() {
+  const router = useContext(RouterContext);
+  if (!router)
+    throw new Error("useSearchParams must be used within a <Router>");
+  const params = computed(() => new URLSearchParams(router.location.search()));
+  const setSearchParams = (next) => {
+    const sp = next instanceof URLSearchParams ? next : new URLSearchParams(next);
+    const queryString = sp.toString();
+    const newUrl = `${router.location.pathname()}${queryString ? `?${queryString}` : ""}${router.location.hash()}`;
+    router.navigate(newUrl);
+  };
+  return [params, setSearchParams];
+}
+export {
+  Link,
+  Route,
+  Router,
+  Routes,
+  lazy,
+  useLocation,
+  useNavigate,
+  useParams,
+  useSearchParams
+};