@vobs/router 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -0,0 +1,1700 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+var signalNames = /* @__PURE__ */ new WeakMap();
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function setSignalDebugName(signal, name) {
+  signalNames.set(signal, name);
+  invokeDebug("signalNamed", signal, name);
+}
+__name(setSignalDebugName, "setSignalDebugName");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var currentOwner = null;
+var nextOwnerId = 1;
+var ownerNames = /* @__PURE__ */ new WeakMap();
+function createOwner() {
+  const parent = currentOwner;
+  let disposed = parent?.disposed ?? false;
+  const children = [];
+  const cleanups = [];
+  const errorHandlers = /* @__PURE__ */ new Set();
+  const owner = {
+    id: `owner-${nextOwnerId++}`,
+    parent,
+    children,
+    depth: (parent?.depth ?? -1) + 1,
+    get disposed() {
+      return disposed;
+    },
+    run(fn) {
+      if (disposed) throw new Error("Vobs: \u5DF2\u9500\u6BC1\u7684 Owner \u4E0D\u80FD\u7EE7\u7EED\u8FD0\u884C");
+      const previous = currentOwner;
+      currentOwner = owner;
+      try {
+        return fn();
+      } finally {
+        currentOwner = previous;
+      }
+    },
+    addCleanup(cleanup) {
+      if (disposed) {
+        cleanup();
+        return;
+      }
+      cleanups.push(cleanup);
+    },
+    onDispose(cleanup) {
+      owner.addCleanup(cleanup);
+    },
+    onError(handler) {
+      errorHandlers.add(handler);
+      const remove = /* @__PURE__ */ __name(() => errorHandlers.delete(handler), "remove");
+      owner.addCleanup(remove);
+      return remove;
+    },
+    handleError(error) {
+      for (const handler of [...errorHandlers].reverse()) {
+        try {
+          handler(error);
+          return true;
+        } catch (handlerError) {
+          return parent?.handleError(handlerError) ?? false;
+        }
+      }
+      return parent?.handleError(error) ?? false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const child of [...children]) child.dispose();
+      children.length = 0;
+      let firstError;
+      for (let index = cleanups.length - 1; index >= 0; index--) {
+        try {
+          cleanups[index]();
+        } catch (error) {
+          firstError ?? (firstError = error);
+        }
+      }
+      cleanups.length = 0;
+      if (parent) {
+        const index = parent.children.indexOf(owner);
+        if (index >= 0) parent.children.splice(index, 1);
+      }
+      if (firstError) throw firstError;
+    }
+  };
+  if (parent && !parent.disposed) parent.children.push(owner);
+  return owner;
+}
+__name(createOwner, "createOwner");
+function setOwnerDebugName(owner, name) {
+  ownerNames.set(owner, name);
+}
+__name(setOwnerDebugName, "setOwnerDebugName");
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+
+// packages/reactivity/src/signal.ts
+var currentSubscriber = null;
+function getCurrentSubscriber() {
+  return currentSubscriber;
+}
+__name(getCurrentSubscriber, "getCurrentSubscriber");
+function setCurrentSubscriber(subscriber) {
+  currentSubscriber = subscriber;
+}
+__name(setCurrentSubscriber, "setCurrentSubscriber");
+function trackDependency(dependency) {
+  if (!currentSubscriber || currentSubscriber.disposed) return;
+  !currentSubscriber.dependencies.has(dependency);
+  currentSubscriber.dependencies.add(dependency);
+}
+__name(trackDependency, "trackDependency");
+function state(initialValue, debugName) {
+  let value = initialValue;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const signalInstance = {
+    get value() {
+      const subscriber = getCurrentSubscriber();
+      if (subscriber && !subscriber.disposed) {
+        subscribers.add(subscriber);
+        trackDependency(signalInstance);
+      }
+      return value;
+    },
+    set value(nextValue) {
+      if (disposed || Object.is(value, nextValue)) return;
+      value = nextValue;
+      for (const subscriber of [...subscribers]) subscriber.notify();
+    },
+    unsubscribe(subscriber) {
+      subscribers.delete(subscriber);
+    },
+    // 与 `.value =` 赋值同一条路径：判等短路、debug hook、notify 全部一致。
+    // 以闭包实现，可安全地作为回调直接传递（无 this 绑定问题）。
+    set(next) {
+      signalInstance.value = next;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.clear();
+    }
+  };
+  const owner = getCurrentOwner();
+  owner?.addCleanup(signalInstance.dispose);
+  if (debugName?.trim()) setSignalDebugName(signalInstance, debugName.trim());
+  return signalInstance;
+}
+__name(state, "state");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+var Scheduler = _Scheduler;
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+var scheduler = new Scheduler();
+
+// packages/reactivity/src/effect.ts
+var nextEffectOrder = 1;
+function cleanupDependencies(subscriber) {
+  for (const dependency of subscriber.dependencies) {
+    dependency.unsubscribe(subscriber);
+  }
+  subscriber.dependencies.clear();
+}
+__name(cleanupDependencies, "cleanupDependencies");
+function effect(callback) {
+  const owner = getCurrentOwner();
+  let cleanup;
+  let dirty = true;
+  let disposed = false;
+  const eff = {
+    order: nextEffectOrder++,
+    depth: owner?.depth ?? 0,
+    dependencies: /* @__PURE__ */ new Set(),
+    get disposed() {
+      return disposed;
+    },
+    notify() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.schedule(eff);
+    },
+    run() {
+      if (disposed || !dirty) return;
+      dirty = false;
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled2 = owner?.handleError(error) ?? false;
+          if (!handled2) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      const previous = getCurrentSubscriber();
+      setCurrentSubscriber(eff);
+      let thrown;
+      let handled = false;
+      try {
+        const result = owner ? owner.run(callback) : callback();
+        cleanup = typeof result === "function" ? result : void 0;
+      } catch (error) {
+        thrown = error;
+        handled = owner?.handleError(error) ?? false;
+        if (!handled) throw error;
+      } finally {
+        setCurrentSubscriber(previous);
+      }
+      if (cleanupError && !thrown) throw cleanupError;
+    },
+    scheduleLow() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.scheduleLow(eff);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      dirty = false;
+      scheduler.remove(eff);
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled = owner?.handleError(error) ?? false;
+          if (!handled) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      if (cleanupError) throw cleanupError;
+    }
+  };
+  owner?.addCleanup(eff.dispose);
+  eff.run();
+  return eff;
+}
+__name(effect, "effect");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+var activeRuntimeDebugContext = null;
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function getRuntimeDebugContext() {
+  return activeRuntimeDebugContext;
+}
+__name(getRuntimeDebugContext, "getRuntimeDebugContext");
+function runWithRuntimeDebugContext(context, task) {
+  const previous = activeRuntimeDebugContext;
+  const next = { ...previous, ...context };
+  activeRuntimeDebugContext = next;
+  let result;
+  try {
+    result = task();
+  } catch (error) {
+    activeRuntimeDebugContext = previous;
+    throw error;
+  }
+  if (isPromiseLike(result)) {
+    return Promise.resolve(result).finally(() => {
+      if (activeRuntimeDebugContext === next) activeRuntimeDebugContext = previous;
+    });
+  }
+  activeRuntimeDebugContext = previous;
+  return result;
+}
+__name(runWithRuntimeDebugContext, "runWithRuntimeDebugContext");
+function invokeRuntimeDebug(name, ...args) {
+  return;
+}
+__name(invokeRuntimeDebug, "invokeRuntimeDebug");
+function isPromiseLike(value) {
+  return Boolean(value) && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+__name(isPromiseLike, "isPromiseLike");
+function describeDebugNode(node) {
+  if (!node || typeof node !== "object") return "node";
+  const value = node;
+  const name = typeof value.tagName === "string" ? value.tagName.toLowerCase() : typeof value.nodeName === "string" ? value.nodeName.toLowerCase() : "node";
+  const id = typeof value.id === "string" && value.id ? `#${value.id}` : "";
+  const className = typeof value.className === "string" && value.className ? `.${value.className.trim().split(/\s+/).filter(Boolean).join(".")}` : "";
+  return `${name}${id}${className}`;
+}
+__name(describeDebugNode, "describeDebugNode");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+function registerHmrInstance(moduleId, instance) {
+  const instances = getModule(moduleId).instances;
+  instances.add(instance);
+  return () => instances.delete(instance);
+}
+__name(registerHmrInstance, "registerHmrInstance");
+function markHmrInstanceMounted(node, parent) {
+  const instance = hmrInstances.get(node);
+  if (instance) instance.parent = parent;
+}
+__name(markHmrInstanceMounted, "markHmrInstanceMounted");
+function getModule(moduleId) {
+  let module = hmrGlobal.modules.get(moduleId);
+  if (!module) {
+    module = { components: /* @__PURE__ */ new Map(), state: /* @__PURE__ */ new Map(), instances: /* @__PURE__ */ new Set() };
+    hmrGlobal.modules.set(moduleId, module);
+  }
+  return module;
+}
+__name(getModule, "getModule");
+var hmrInstances = /* @__PURE__ */ new WeakMap();
+function associateHmrInstance(node, instance) {
+  hmrInstances.set(node, instance);
+}
+__name(associateHmrInstance, "associateHmrInstance");
+var nodeOwners = /* @__PURE__ */ new WeakMap();
+function getRenderer() {
+  {
+    throw new Error("\u6E32\u67D3\u5668\u672A\u521D\u59CB\u5316");
+  }
+}
+__name(getRenderer, "getRenderer");
+function createComment(content) {
+  return getRenderer().createComment(content);
+}
+__name(createComment, "createComment");
+function insertBefore(parent, child, anchor) {
+  if (isVobsFragment(child)) {
+    child.mount(parent, isVobsFragment(anchor) ? anchor.start : anchor);
+    return;
+  }
+  getRenderer().insertBefore(parent, child, isVobsFragment(anchor) ? anchor.start : anchor);
+  markHmrInstanceMounted(child, parent);
+}
+__name(insertBefore, "insertBefore");
+function removeChild(parent, child) {
+  disposeNodeOwner(child);
+  if (isVobsFragment(child)) {
+    child.unmount(parent);
+    return;
+  }
+  getRenderer().removeChild(parent, child);
+}
+__name(removeChild, "removeChild");
+function createComponent(component, props, source) {
+  const owner = createOwner();
+  const componentName = component.displayName || component.name || "anonymous";
+  setOwnerDebugName(owner, source ? `${componentName} (${source.file}:${source.line}:${source.column})` : componentName);
+  owner.onError((reason) => {
+    attachSourceLocation(reason, source);
+    attachComponentContext(reason, componentName, owner.id);
+    throw reason;
+  });
+  let node;
+  try {
+    node = owner.run(() => component(props));
+  } catch (error) {
+    owner.dispose();
+    attachSourceLocation(error, source);
+    attachComponentContext(error, componentName, owner.id);
+    throw error;
+  }
+  associateNodeOwner(node, owner);
+  const hmrKey = component.hmrKey;
+  if (hmrKey) {
+    const instance = {
+      node,
+      parent: null,
+      refresh() {
+        const previous = instance.node;
+        const next = owner.run(() => component(props));
+        if (instance.parent && !isVobsFragment(previous) && !isVobsFragment(next)) {
+          getRenderer().insertBefore(instance.parent, next, previous);
+          getRenderer().removeChild(instance.parent, previous);
+        }
+        nodeOwners.delete(previous);
+        nodeOwners.set(next, owner);
+        associateHmrInstance(next, instance);
+        instance.node = next;
+      }
+    };
+    associateHmrInstance(node, instance);
+    const separator = hmrKey.lastIndexOf(":");
+    const moduleId = separator < 0 ? hmrKey : hmrKey.slice(0, separator);
+    const cleanup = registerHmrInstance(moduleId, instance);
+    owner.onDispose(cleanup);
+  }
+  return node;
+}
+__name(createComponent, "createComponent");
+function attachSourceLocation(reason, source) {
+  if (!source || (!reason || typeof reason !== "object" && typeof reason !== "function")) return;
+  const error = reason;
+  if (error.vobsSource) return;
+  try {
+    Object.defineProperty(error, "vobsSource", {
+      configurable: true,
+      enumerable: false,
+      value: source,
+      writable: false
+    });
+  } catch {
+  }
+}
+__name(attachSourceLocation, "attachSourceLocation");
+function attachComponentContext(reason, component, ownerId) {
+  if (!reason || typeof reason !== "object" && typeof reason !== "function") return;
+  const error = reason;
+  try {
+    if (!error.vobsComponent) Object.defineProperty(error, "vobsComponent", { configurable: true, enumerable: false, value: component, writable: false });
+    if (!error.vobsOwnerId) Object.defineProperty(error, "vobsOwnerId", { configurable: true, enumerable: false, value: ownerId, writable: false });
+  } catch {
+  }
+}
+__name(attachComponentContext, "attachComponentContext");
+function createBlock(factory) {
+  const owner = createOwner();
+  setOwnerDebugName(owner, "dynamic");
+  let node;
+  try {
+    node = owner.run(factory);
+  } catch (error) {
+    owner.dispose();
+    throw error;
+  }
+  if (!node) {
+    owner.dispose();
+    return null;
+  }
+  associateNodeOwner(node, owner);
+  return node;
+}
+__name(createBlock, "createBlock");
+function associateNodeOwner(node, owner) {
+  nodeOwners.set(node, owner);
+}
+__name(associateNodeOwner, "associateNodeOwner");
+function disposeNodeOwner(node) {
+  const owner = nodeOwners.get(node);
+  if (!owner) return;
+  nodeOwners.delete(node);
+  owner.dispose();
+}
+__name(disposeNodeOwner, "disposeNodeOwner");
+
+// packages/runtime/src/fragment.ts
+function createFragment(factory) {
+  const start = createComment("vobs:fragment:start");
+  const end = createComment("vobs:fragment:end");
+  let parent = null;
+  let initialized = false;
+  const owner = getCurrentOwner();
+  const fragment = {
+    kind: "vobs-fragment",
+    start,
+    end,
+    mount(nextParent, anchor) {
+      if (parent && parent !== nextParent) {
+        throw new Error("Vobs Fragment: \u4E0D\u80FD\u8DE8\u7236\u8282\u70B9\u79FB\u52A8 Fragment");
+      }
+      if (initialized) {
+        moveRange(nextParent, start, end, anchor);
+        return;
+      }
+      const renderer = getRenderer();
+      renderer.insertBefore(nextParent, start, anchor);
+      renderer.insertBefore(nextParent, end, anchor);
+      parent = nextParent;
+      initialized = true;
+      if (owner) owner.run(() => factory(nextParent, end));
+      else factory(nextParent, end);
+    },
+    unmount(nextParent) {
+      if (!initialized || parent !== nextParent) {
+        throw new Error("Vobs Fragment: Fragment \u4E0D\u5C5E\u4E8E\u6307\u5B9A\u7236\u8282\u70B9");
+      }
+      const renderer = getRenderer();
+      let current = renderer.nextSibling(start);
+      while (current && current !== end) {
+        const next = renderer.nextSibling(current);
+        renderer.removeChild(nextParent, current);
+        current = next;
+      }
+      renderer.removeChild(nextParent, start);
+      renderer.removeChild(nextParent, end);
+      parent = null;
+      initialized = false;
+    }
+  };
+  return fragment;
+}
+__name(createFragment, "createFragment");
+function isVobsFragment(value) {
+  return Boolean(value) && typeof value === "object" && value.kind === "vobs-fragment";
+}
+__name(isVobsFragment, "isVobsFragment");
+function moveRange(parent, start, end, anchor) {
+  const renderer = getRenderer();
+  const nodes = [start];
+  let current = renderer.nextSibling(start);
+  while (current) {
+    nodes.push(current);
+    if (current === end) break;
+    current = renderer.nextSibling(current);
+  }
+  if (nodes[nodes.length - 1] !== end) {
+    throw new Error("Vobs Fragment: \u627E\u4E0D\u5230\u7ED3\u675F\u951A\u70B9");
+  }
+  for (const node of nodes) renderer.insertBefore(parent, node, anchor);
+}
+__name(moveRange, "moveRange");
+
+// packages/runtime/src/dynamic.ts
+function insertDynamic(parent, anchor, factory) {
+  const marker = createComment("vobs:dynamic");
+  insertBefore(parent, marker, anchor);
+  let current = null;
+  effect(() => {
+    const next = createBlock(factory);
+    if (next === current) return;
+    if (current) removeChild(parent, current);
+    current = next;
+    if (current) insertBefore(parent, current, marker);
+  });
+}
+__name(insertDynamic, "insertDynamic");
+
+// packages/runtime/src/error.ts
+var _VobsError = class _VobsError extends Error {
+  constructor(options) {
+    super(options.message);
+    this.name = "VobsError";
+    this.code = options.code;
+    this.severity = options.severity ?? "error";
+    this.layer = options.layer ?? "runtime";
+    this.cause = options.cause;
+    this.fix = options.fix;
+    this.location = options.location;
+    this.trace = options.trace;
+    this.example = options.example;
+    this.docs = options.docs;
+    this.codeFrame = options.codeFrame;
+  }
+};
+__name(_VobsError, "VobsError");
+var VobsError = _VobsError;
+function isVobsError(value) {
+  return value instanceof VobsError || Boolean(value && typeof value === "object" && typeof value.code === "string" && typeof value.message === "string" && typeof value.layer === "string");
+}
+__name(isVobsError, "isVobsError");
+function normalizeVobsError(value, defaults = {}) {
+  if (value instanceof VobsError) return value;
+  if (value instanceof Error) {
+    const metadata = value;
+    const code = defaults.code ?? (typeof metadata.vobsCode === "string" ? metadata.vobsCode : void 0);
+    if (code) defineErrorMetadata(value, "code", code);
+    defineErrorMetadata(value, "severity", defaults.severity ?? "error");
+    defineErrorMetadata(value, "layer", defaults.layer ?? "runtime");
+    const fix = defaults.fix ?? (typeof metadata.vobsHint === "string" ? metadata.vobsHint : void 0);
+    if (fix) defineErrorMetadata(value, "fix", fix);
+    const source = metadata.vobsSource;
+    if (source && typeof source === "object" && typeof source.file === "string" && typeof source.line === "number" && typeof source.column === "number") {
+      defineErrorMetadata(value, "location", source);
+    }
+    return value;
+  }
+  if (isVobsError(value)) {
+    const candidate = value;
+    return new VobsError({
+      code: candidate.code,
+      message: candidate.message,
+      severity: candidate.severity ?? defaults.severity,
+      layer: candidate.layer ?? defaults.layer,
+      cause: candidate.cause,
+      fix: candidate.fix ?? defaults.fix,
+      location: candidate.location,
+      trace: candidate.trace,
+      example: candidate.example,
+      docs: candidate.docs,
+      codeFrame: candidate.codeFrame
+    });
+  }
+  const message = String(value);
+  return new VobsError({
+    code: defaults.code ?? "VOBS_UNKNOWN",
+    message,
+    severity: defaults.severity ?? "error",
+    layer: defaults.layer ?? "runtime",
+    cause: void 0,
+    fix: defaults.fix
+  });
+}
+__name(normalizeVobsError, "normalizeVobsError");
+function defineErrorMetadata(target, key, value) {
+  if (key in target) return;
+  try {
+    Object.defineProperty(target, key, { configurable: true, enumerable: false, value, writable: true });
+  } catch {
+  }
+}
+__name(defineErrorMetadata, "defineErrorMetadata");
+
+// packages/runtime/src/boundary.ts
+function insertBoundary(parent, anchor, options) {
+  const boundary = createOwner();
+  boundary.run(() => {
+    const error = state(null);
+    let fallbackActive = false;
+    let lastError = null;
+    let initialized = false;
+    let previousKey;
+    boundary.onError((reason) => {
+      if (fallbackActive) throw reason;
+      const normalized = normalizeVobsError(reason, {
+        code: "VOBS_R001",
+        layer: "runtime",
+        fix: "\u68C0\u67E5\u7EC4\u4EF6\u6E32\u67D3\u903B\u8F91\uFF0C\u6216\u5728\u8FB9\u754C fallback \u4E2D\u63D0\u4F9B\u6062\u590D\u64CD\u4F5C\u3002"
+      });
+      lastError = normalized;
+      invokeRuntimeDebug("error", {
+        error: normalized,
+        owner: boundary,
+        phase: "boundary",
+        handled: true,
+        recovery: "fallback"
+      });
+      error.value = normalized;
+    });
+    const retry = /* @__PURE__ */ __name(() => {
+      if (error.value) {
+        invokeRuntimeDebug("error", {
+          error: error.value,
+          owner: boundary,
+          phase: "boundary",
+          handled: true,
+          recovery: "retrying"
+        });
+      }
+      error.value = null;
+      return options.onRetry?.();
+    }, "retry");
+    insertDynamic(parent, anchor, () => {
+      const nextKey = options.resetKey?.();
+      if (!initialized || !Object.is(previousKey, nextKey)) {
+        initialized = true;
+        previousKey = nextKey;
+        if (error.value) error.value = null;
+      }
+      const currentError = error.value;
+      if (!currentError) {
+        if (fallbackActive && lastError) {
+          invokeRuntimeDebug("error", {
+            error: lastError,
+            owner: boundary,
+            phase: "boundary",
+            handled: true,
+            recovery: "recovered"
+          });
+          lastError = null;
+        }
+        fallbackActive = false;
+        return options.children();
+      }
+      fallbackActive = true;
+      return options.fallback(currentError, retry);
+    });
+  });
+}
+__name(insertBoundary, "insertBoundary");
+
+// packages/vobs/src/context.ts
+var ownerProviders = /* @__PURE__ */ new WeakMap();
+function inject(key, fallback) {
+  const owner = getCurrentOwner();
+  const value = owner ? injectFromOwner(owner, key) : void 0;
+  return value === void 0 ? fallback : value;
+}
+__name(inject, "inject");
+function injectFromOwner(owner, key) {
+  let current = owner;
+  while (current) {
+    const providers = ownerProviders.get(current);
+    if (providers?.has(key)) return providers.get(key);
+    current = current.parent;
+  }
+  return void 0;
+}
+__name(injectFromOwner, "injectFromOwner");
+
+// packages/vobs/src/app.ts
+function createInjectionKey(description) {
+  return Symbol(description);
+}
+__name(createInjectionKey, "createInjectionKey");
+
+// packages/router/src/debug.ts
+var listeners = /* @__PURE__ */ new Set();
+var nextRouterId = 1;
+function createRouterDebugId() {
+  return `router-${nextRouterId++}`;
+}
+__name(createRouterDebugId, "createRouterDebugId");
+function subscribeRouterDebug(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+__name(subscribeRouterDebug, "subscribeRouterDebug");
+function emitRouterDebug(routerId, type, payload, context) {
+  const event = { routerId, type, payload, context };
+  for (const listener of [...listeners]) {
+    try {
+      listener(event);
+    } catch {
+    }
+  }
+}
+__name(emitRouterDebug, "emitRouterDebug");
+
+// packages/router/src/index.ts
+var _NavigationCancelledError = class _NavigationCancelledError extends Error {
+  constructor() {
+    super("Vobs Router: \u5BFC\u822A\u5DF2\u88AB\u66F4\u65B0\u7684\u5BFC\u822A\u53D6\u6D88");
+    this.code = "NAVIGATION_CANCELLED";
+    this.name = "NavigationCancelledError";
+  }
+};
+__name(_NavigationCancelledError, "NavigationCancelledError");
+var NavigationCancelledError = _NavigationCancelledError;
+var _NavigationRedirectError = class _NavigationRedirectError extends Error {
+  constructor() {
+    super("Vobs Router: \u5BFC\u822A\u91CD\u5B9A\u5411\u8D85\u8FC7\u6700\u5927\u6B21\u6570");
+    this.code = "NAVIGATION_REDIRECT_LIMIT";
+    this.name = "NavigationRedirectError";
+  }
+};
+__name(_NavigationRedirectError, "NavigationRedirectError");
+var NavigationRedirectError = _NavigationRedirectError;
+var ROUTER_KEY = createInjectionKey("vobs.router");
+function lazy(loader) {
+  return {
+    kind: "vobs-lazy-route",
+    load: loader
+  };
+}
+__name(lazy, "lazy");
+function createMemoryHistory(initial = "/") {
+  let entries = [{ path: normalizeHistoryPath(initial), state: void 0 }];
+  let index = 0;
+  const listeners2 = /* @__PURE__ */ new Set();
+  return {
+    get location() {
+      return entries[index].path;
+    },
+    get state() {
+      return entries[index].state;
+    },
+    push(path, state2) {
+      const next = normalizeHistoryPath(path);
+      entries = entries.slice(0, index + 1);
+      entries.push({ path: next, state: state2 });
+      index++;
+    },
+    replace(path, state2) {
+      entries[index] = { path: normalizeHistoryPath(path), state: state2 };
+    },
+    back() {
+      if (index === 0) return;
+      index--;
+      notifyListeners(listeners2, entries[index].path, entries[index].state);
+    },
+    listen(listener) {
+      listeners2.add(listener);
+      return () => listeners2.delete(listener);
+    }
+  };
+}
+__name(createMemoryHistory, "createMemoryHistory");
+function createBrowserHistory(base = "") {
+  if (typeof window === "undefined") {
+    throw new Error("Vobs Router: createBrowserHistory \u9700\u8981\u6D4F\u89C8\u5668\u73AF\u5883");
+  }
+  const normalizedBase = normalizeBase(base);
+  const listeners2 = /* @__PURE__ */ new Set();
+  const onPopState = /* @__PURE__ */ __name((event) => {
+    notifyListeners(listeners2, readBrowserLocation(normalizedBase), event.state);
+  }, "onPopState");
+  return {
+    get location() {
+      return readBrowserLocation(normalizedBase);
+    },
+    get state() {
+      return window.history.state;
+    },
+    push(path, state2) {
+      window.history.pushState(state2 ?? null, "", withBase(normalizeHistoryPath(path), normalizedBase));
+    },
+    replace(path, state2) {
+      window.history.replaceState(state2 ?? null, "", withBase(normalizeHistoryPath(path), normalizedBase));
+    },
+    back() {
+      window.history.back();
+    },
+    listen(listener) {
+      if (listeners2.size === 0) window.addEventListener("popstate", onPopState);
+      listeners2.add(listener);
+      return () => {
+        listeners2.delete(listener);
+        if (listeners2.size === 0) window.removeEventListener("popstate", onPopState);
+      };
+    }
+  };
+}
+__name(createBrowserHistory, "createBrowserHistory");
+function createRouter(options) {
+  const matchers = normalizeRoutes(options.routes);
+  const history = options.history ?? defaultHistory();
+  const routerDebugId = createRouterDebugId();
+  matchers.sort(compareMatchers);
+  const currentRoute = state(resolvePath(history.location));
+  const lazyStates = /* @__PURE__ */ new Map();
+  const guards = [];
+  const navigationHistory = [];
+  const dataRequests = [];
+  const errors = [];
+  const dataLoaders = /* @__PURE__ */ new Map();
+  const dataRequestContexts = /* @__PURE__ */ new Map();
+  const routerListeners = /* @__PURE__ */ new Map();
+  let navigationState = { status: "idle", from: currentRoute.value.fullPath, to: currentRoute.value.fullPath };
+  let navigationCount = 0;
+  let totalNavigationDuration = 0;
+  let slowNavigationCount = 0;
+  let nextDataRequestId = 1;
+  let nextErrorId = 1;
+  let navigationId = 0;
+  let destroyed = false;
+  const viewRevision = state(0);
+  function resolve(to) {
+    ensureActive();
+    const target = typeof to === "string" ? parseTargetString(to) : normalizeTarget(to, matchers);
+    return resolvePath(buildTargetPath(target.path, target.query, target.hash), target.state);
+  }
+  __name(resolve, "resolve");
+  function resolvePath(rawPath, state2) {
+    const parsed = parseTargetString(rawPath);
+    const matched = matchers.find((matcher) => matcher.regex.exec(parsed.path));
+    const params = matched ? extractParams(matched, parsed.path) : {};
+    const record = matched?.record ?? null;
+    const query = parsed.query;
+    const hash = parsed.hash;
+    return {
+      path: parsed.path,
+      fullPath: buildTargetPath(parsed.path, query, hash),
+      params,
+      query,
+      hash,
+      name: record?.name,
+      meta: matched?.meta ?? {},
+      record,
+      matched: matched?.chain ?? EMPTY_MATCHED,
+      state: state2
+    };
+  }
+  __name(resolvePath, "resolvePath");
+  async function navigate(to, replaceHistory, fromHistory, historyState) {
+    ensureActive();
+    const id = ++navigationId;
+    const from = currentRoute.value;
+    let target = resolve(to);
+    if (fromHistory && historyState !== void 0) target = { ...target, state: historyState };
+    const source = fromHistory ? "history" : replaceHistory ? "replace" : "push";
+    const startedAt = now();
+    const initialTarget = target.fullPath;
+    let terminalRecorded = false;
+    navigationState = { status: "loading", from: from.fullPath, to: target.fullPath, traceId: id };
+    emitRouter("navigation:start", navigationState);
+    if (target.fullPath === from.fullPath && !fromHistory) {
+      navigationState = { status: "idle", from: from.fullPath, to: target.fullPath };
+      return from;
+    }
+    try {
+      for (let redirectCount = 0; ; redirectCount++) {
+        ensureNavigationIsCurrent(id);
+        let redirect;
+        for (const guard of [...guards]) {
+          let result;
+          try {
+            result = await guard(target, from);
+          } catch (reason) {
+            if (reason instanceof NavigationCancelledError) throw reason;
+            const error = toError(reason);
+            reportError("navigation", error, target.fullPath);
+            recordNavigation({ id, from: from.fullPath, to: target.fullPath, status: "error", source, startedAt, endedAt: now(), duration: now() - startedAt, error: error.message });
+            terminalRecorded = true;
+            throw reason;
+          }
+          ensureNavigationIsCurrent(id);
+          if (result === false) {
+            recordNavigation({ id, from: from.fullPath, to: target.fullPath, status: "cancelled", source, startedAt, endedAt: now(), duration: now() - startedAt });
+            terminalRecorded = true;
+            return false;
+          }
+          if (typeof result === "string" || isRouteLocationRaw(result)) {
+            redirect = result;
+            break;
+          }
+        }
+        for (const record of target.matched) {
+          if (!record.loader) continue;
+          ensureNavigationIsCurrent(id);
+          await trackDataRequest(
+            "loader",
+            `${target.fullPath}#${record.path ?? record.name ?? "route"}`,
+            (context) => record.loader({ route: target, navigationId: id, dataRequestId: context.dataRequestId }),
+            { route: target.fullPath, navigationId: id, trigger: "navigation" }
+          );
+        }
+        ensureNavigationIsCurrent(id);
+        if (redirect !== void 0) {
+          if (redirectCount >= 10) {
+            const error = new NavigationRedirectError();
+            recordNavigation({ id, from: from.fullPath, to: target.fullPath, status: "error", source, startedAt, endedAt: now(), duration: now() - startedAt, error: error.message });
+            terminalRecorded = true;
+            throw error;
+          }
+          const redirected = resolve(redirect);
+          if (redirected.fullPath === target.fullPath) return false;
+          recordNavigation({ id, from: from.fullPath, to: target.fullPath, status: "redirected", source, startedAt, endedAt: now(), duration: now() - startedAt, redirect: redirected.fullPath });
+          target = redirected;
+          continue;
+        }
+        if (target.fullPath === from.fullPath) return from;
+        if (!fromHistory) {
+          if (replaceHistory) history.replace(target.fullPath, target.state);
+          else history.push(target.fullPath, target.state);
+        }
+        currentRoute.value = target;
+        recordNavigation({ id, from: from.fullPath, to: target.fullPath, status: "success", source, startedAt, endedAt: now(), duration: now() - startedAt, redirect: target.fullPath !== initialTarget ? target.fullPath : void 0 });
+        terminalRecorded = true;
+        return target;
+      }
+    } catch (reason) {
+      if (reason instanceof NavigationCancelledError) {
+        recordNavigation({ id, from: from.fullPath, to: target.fullPath, status: "cancelled", source, startedAt, endedAt: now(), duration: now() - startedAt });
+        terminalRecorded = true;
+      } else if (!terminalRecorded) {
+        const error = toError(reason);
+        reportError("navigation", error, target.fullPath);
+        recordNavigation({ id, from: from.fullPath, to: target.fullPath, status: "error", source, startedAt, endedAt: now(), duration: now() - startedAt, error: error.message });
+        terminalRecorded = true;
+      }
+      throw reason;
+    }
+  }
+  __name(navigate, "navigate");
+  function now() {
+    return typeof performance === "undefined" ? Date.now() : performance.now();
+  }
+  __name(now, "now");
+  function emitRouter(event, payload) {
+    for (const callback of routerListeners.get(event) ?? []) {
+      try {
+        callback(payload);
+      } catch {
+      }
+    }
+    emitRouterDebug(routerDebugId, event, payload, getRuntimeDebugContext() ?? void 0);
+  }
+  __name(emitRouter, "emitRouter");
+  function recordNavigation(trace) {
+    navigationHistory.push(Object.freeze(trace));
+    if (navigationHistory.length > 100) navigationHistory.shift();
+    navigationCount++;
+    totalNavigationDuration += trace.duration;
+    if (trace.duration >= 16) slowNavigationCount++;
+    if (trace.id === navigationId) {
+      navigationState = trace.status === "error" ? { status: "error", from: trace.from, to: trace.to, traceId: trace.id, error: trace.error } : { status: "idle", from: trace.from, to: trace.to, traceId: trace.id };
+    }
+    emitRouter("navigation:end", trace);
+    emitRouter("route:update", currentRoute.value);
+  }
+  __name(recordNavigation, "recordNavigation");
+  async function trackDataRequest(kind, key, task, optionsOrRoute = {}) {
+    ensureActive();
+    const options2 = typeof optionsOrRoute === "string" ? { route: optionsOrRoute } : optionsOrRoute;
+    const id = nextDataRequestId++;
+    const startedAt = now();
+    const context = getRuntimeDebugContext();
+    const route = options2.route ?? currentRoute.value.fullPath;
+    const requestContext = {
+      ...context,
+      environment: options2.environment ?? context?.environment,
+      route,
+      navigationId: options2.navigationId ?? context?.navigationId,
+      dataRequestId: id,
+      source: kind
+    };
+    const loading = {
+      id,
+      kind,
+      key,
+      route,
+      status: "loading",
+      startedAt,
+      navigationId: requestContext.navigationId,
+      trigger: options2.trigger,
+      environment: requestContext.environment
+    };
+    dataRequests.push(loading);
+    if (dataRequests.length > 100) dataRequests.shift();
+    dataRequestContexts.set(id, requestContext);
+    emitRouter("route:update", currentRoute.value);
+    emitRouter("data-request", loading);
+    emitRouterDebug(routerDebugId, "data-request", { phase: "start", trace: loading }, requestContext);
+    dataLoaders.set(key, { kind, route, task });
+    try {
+      const result = await runWithRuntimeDebugContext(requestContext, () => task({ dataRequestId: id }));
+      const endedAt = now();
+      replaceDataRequest(id, { ...loading, status: "success", endedAt, duration: endedAt - startedAt, result });
+      return result;
+    } catch (reason) {
+      const endedAt = now();
+      const error = toError(reason);
+      const status = isAbortError(reason) ? "cancelled" : "error";
+      if (status === "error") reportError(kind, error, route, { requestId: id, navigationId: requestContext.navigationId });
+      replaceDataRequest(id, { ...loading, status, endedAt, duration: endedAt - startedAt, error: status === "error" ? error.message : void 0 });
+      throw reason;
+    }
+  }
+  __name(trackDataRequest, "trackDataRequest");
+  function replaceDataRequest(id, trace) {
+    const index = dataRequests.findIndex((item) => item.id === id);
+    if (index >= 0) dataRequests[index] = Object.freeze(trace);
+    emitRouter("route:update", currentRoute.value);
+    emitRouter("data-request", trace);
+    emitRouterDebug(routerDebugId, "data-request", { phase: "end", trace }, dataRequestContexts.get(id));
+    dataRequestContexts.delete(id);
+  }
+  __name(replaceDataRequest, "replaceDataRequest");
+  function reportError(phase, reason, route = currentRoute.value.fullPath, context = {}) {
+    const error = toError(reason);
+    errors.push(Object.freeze({
+      id: nextErrorId++,
+      phase,
+      route,
+      message: error.message,
+      stack: error.stack,
+      timestamp: now(),
+      requestId: context.requestId,
+      navigationId: context.navigationId
+    }));
+    if (errors.length > 100) errors.shift();
+    emitRouter("error", errors[errors.length - 1]);
+    emitRouter("route:update", currentRoute.value);
+  }
+  __name(reportError, "reportError");
+  function routeTree() {
+    const statuses = /* @__PURE__ */ new Map();
+    for (const matcher of matchers) {
+      for (const record of matcher.chain) {
+        if (record.component && isLazyRouteComponent(record.component)) {
+          const debugId = routeDebugIds.get(record);
+          if (debugId) statuses.set(debugId, lazyStates.get(record)?.status ?? "loading");
+        }
+      }
+    }
+    return buildRouteDebugTree(options.routes, statuses);
+  }
+  __name(routeTree, "routeTree");
+  function handleHistoryNavigation(path, state2) {
+    void navigate(path, false, true, state2).then((result) => {
+      if (destroyed) return;
+      if (result === false) {
+        history.replace(currentRoute.value.fullPath, currentRoute.value.state);
+      } else if (result.fullPath !== normalizeHistoryPath(path)) {
+        history.replace(result.fullPath, result.state);
+      }
+    }).catch((error) => {
+      if (!(error instanceof NavigationCancelledError) && !destroyed) {
+        const current = currentRoute.value.fullPath;
+        const failed = toError(error);
+        reportError("navigation", failed, normalizeHistoryPath(path));
+        navigationState = { status: "error", from: current, to: normalizeHistoryPath(path), error: failed.message };
+        emitRouter("navigation:end", { status: "error", from: current, to: normalizeHistoryPath(path), error: failed.message });
+        history.replace(currentRoute.value.fullPath, currentRoute.value.state);
+      }
+    });
+  }
+  __name(handleHistoryNavigation, "handleHistoryNavigation");
+  const stopHistory = history.listen(handleHistoryNavigation);
+  const router = {
+    currentRoute,
+    history,
+    resolve,
+    push(to) {
+      return navigate(to, false, false);
+    },
+    replace(to) {
+      return navigate(to, true, false);
+    },
+    back() {
+      ensureActive();
+      history.back();
+    },
+    beforeEach(guard) {
+      ensureActive();
+      guards.push(guard);
+      return () => {
+        const index = guards.indexOf(guard);
+        if (index >= 0) guards.splice(index, 1);
+      };
+    },
+    getViewState(route) {
+      viewRevision.value;
+      const records = route.matched.length > 0 ? route.matched : route.record ? [route.record] : [];
+      const entries = records.map((record) => ({ record, definition: record.component })).filter((entry) => isRouteComponentDefinition(entry.definition));
+      if (!route.record || entries.length === 0) return { status: "not-found", retry: /* @__PURE__ */ __name(() => void 0, "retry") };
+      const loaded = [];
+      const lazyRecords = [];
+      for (const entry of entries) {
+        const { record, definition } = entry;
+        if (!isLazyRouteComponent(definition)) {
+          loaded.push(definition);
+          continue;
+        }
+        lazyRecords.push(record);
+        const lazyState = ensureLazyState(record, definition);
+        if (lazyState.status === "loading") return { status: "loading", retry: /* @__PURE__ */ __name(() => retryLazyRoutes(lazyRecords), "retry") };
+        if (lazyState.status === "error") {
+          return { status: "error", error: lazyState.error, retry: /* @__PURE__ */ __name(() => retryLazyRoutes(lazyRecords), "retry") };
+        }
+        if (lazyState.component) loaded.push(lazyState.component);
+      }
+      const component = loaded[loaded.length - 1];
+      if (!component) return { status: "not-found", retry: /* @__PURE__ */ __name(() => void 0, "retry") };
+      return {
+        status: "ready",
+        component,
+        layouts: loaded.slice(0, -1),
+        retry: /* @__PURE__ */ __name(() => retryLazyRoutes(lazyRecords), "retry")
+      };
+    },
+    devtools: {
+      getRouteTree: routeTree,
+      getCurrentRoute: /* @__PURE__ */ __name(() => currentRoute.value, "getCurrentRoute"),
+      getNavigationState: /* @__PURE__ */ __name(() => navigationState, "getNavigationState"),
+      getNavigationHistory: /* @__PURE__ */ __name(() => [...navigationHistory], "getNavigationHistory"),
+      getPerformanceMetrics: /* @__PURE__ */ __name(() => ({
+        navigationCount,
+        averageNavigationDuration: navigationCount === 0 ? 0 : totalNavigationDuration / navigationCount,
+        slowNavigationCount
+      }), "getPerformanceMetrics"),
+      getDataRequests: /* @__PURE__ */ __name(() => [...dataRequests], "getDataRequests"),
+      getErrors: /* @__PURE__ */ __name(() => [...errors], "getErrors"),
+      trackDataRequest,
+      runAction: /* @__PURE__ */ __name((key, task) => trackDataRequest("action", key, task, { trigger: "manual" }), "runAction"),
+      runFetcher: /* @__PURE__ */ __name((key, task) => trackDataRequest("fetcher", key, task, { trigger: "manual" }), "runFetcher"),
+      reportError,
+      revalidate: /* @__PURE__ */ __name(async (route) => {
+        await Promise.all([...dataLoaders.entries()].filter(([, loader]) => loader.kind === "loader" && (route === void 0 || loader.route === route)).map(([key, loader]) => trackDataRequest(loader.kind, key, loader.task, { route: loader.route, trigger: "revalidate" })));
+      }, "revalidate"),
+      subscribe(event, callback) {
+        let listeners2 = routerListeners.get(event);
+        if (!listeners2) {
+          listeners2 = /* @__PURE__ */ new Set();
+          routerListeners.set(event, listeners2);
+        }
+        listeners2.add(callback);
+        return () => listeners2?.delete(callback);
+      }
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      navigationId++;
+      stopHistory();
+      guards.length = 0;
+      routerListeners.clear();
+      lazyStates.clear();
+      errors.length = 0;
+      dataRequestContexts.clear();
+      currentRoute.dispose();
+      viewRevision.dispose();
+    }
+  };
+  function ensureLazyState(record, definition) {
+    let lazyState = lazyStates.get(record);
+    if (!lazyState) {
+      lazyState = { status: "loading" };
+      lazyStates.set(record, lazyState);
+      void loadRouteComponent(definition).then((component) => {
+        if (destroyed) return;
+        lazyState.status = "ready";
+        lazyState.component = component;
+        viewRevision.value++;
+        emitRouter("route:update", currentRoute.value);
+      }).catch((reason) => {
+        if (destroyed) return;
+        lazyState.status = "error";
+        lazyState.error = toError(reason);
+        reportError("lazy", reason, currentRoute.value.fullPath);
+        viewRevision.value++;
+        emitRouter("route:update", currentRoute.value);
+      });
+    }
+    return lazyState;
+  }
+  __name(ensureLazyState, "ensureLazyState");
+  function retryLazyRoutes(records) {
+    for (const record of records) lazyStates.delete(record);
+    viewRevision.value++;
+  }
+  __name(retryLazyRoutes, "retryLazyRoutes");
+  function ensureActive() {
+    if (destroyed) throw new Error("Vobs Router: \u5DF2\u9500\u6BC1\u7684 Router \u4E0D\u80FD\u7EE7\u7EED\u4F7F\u7528");
+  }
+  __name(ensureActive, "ensureActive");
+  function ensureNavigationIsCurrent(id) {
+    if (id !== navigationId) throw new NavigationCancelledError();
+  }
+  __name(ensureNavigationIsCurrent, "ensureNavigationIsCurrent");
+  return router;
+}
+__name(createRouter, "createRouter");
+function RouterView(props = {}) {
+  const router = props.router ?? inject(ROUTER_KEY);
+  if (!router) throw new Error("Vobs Router: RouterView \u627E\u4E0D\u5230 Router\uFF0C\u8BF7\u5B89\u88C5 routerPlugin");
+  return createFragment((parent, anchor) => {
+    let routeRetry = /* @__PURE__ */ __name(() => void 0, "routeRetry");
+    insertBoundary(parent, anchor, {
+      resetKey: /* @__PURE__ */ __name(() => router.currentRoute.value.fullPath, "resetKey"),
+      onRetry: /* @__PURE__ */ __name(() => routeRetry(), "onRetry"),
+      fallback: /* @__PURE__ */ __name((error, retry) => {
+        router.devtools.reportError("render", error, router.currentRoute.value.fullPath);
+        return props.error?.(error, () => {
+          void retry();
+        }) ?? null;
+      }, "fallback"),
+      children: /* @__PURE__ */ __name(() => {
+        const route = router.currentRoute.value;
+        const view = router.getViewState(route);
+        routeRetry = view.retry;
+        if (view.status === "loading") return props.loading?.() ?? null;
+        if (view.status === "not-found") return props.notFound?.(route) ?? null;
+        if (view.status === "error") {
+          throw view.error ?? new Error("\u8DEF\u7531\u7EC4\u4EF6\u52A0\u8F7D\u5931\u8D25");
+        }
+        if (!view.component) return null;
+        let node = createComponent(view.component, {
+          route,
+          params: route.params,
+          query: route.query
+        });
+        for (let index = (view.layouts?.length ?? 0) - 1; index >= 0; index--) {
+          node = createComponent(view.layouts[index], {
+            route,
+            params: route.params,
+            query: route.query,
+            children: node
+          });
+        }
+        return node;
+      }, "children")
+    });
+  });
+}
+__name(RouterView, "RouterView");
+function useRouter() {
+  const router = inject(ROUTER_KEY);
+  if (!router) throw new Error("Vobs Router: useRouter \u627E\u4E0D\u5230 Router\uFF0C\u8BF7\u5B89\u88C5 routerPlugin");
+  return router;
+}
+__name(useRouter, "useRouter");
+function useRoute() {
+  return useRouter().currentRoute;
+}
+__name(useRoute, "useRoute");
+function routerPlugin(options = {}) {
+  return {
+    name: "@vobs/router",
+    version: "0.1.0",
+    install(context) {
+      const ownedRouter = options.router ? void 0 : createRouter({
+        routes: options.routes ?? [],
+        history: options.history
+      });
+      const router = options.router ?? ownedRouter;
+      context.provide(ROUTER_KEY, router);
+      return () => ownedRouter?.destroy();
+    }
+  };
+}
+__name(routerPlugin, "routerPlugin");
+function defaultHistory() {
+  return typeof window === "undefined" ? createMemoryHistory("/") : createBrowserHistory();
+}
+__name(defaultHistory, "defaultHistory");
+var EMPTY_MATCHED = Object.freeze([]);
+var routeDebugIds = /* @__PURE__ */ new WeakMap();
+function buildRouteDebugTree(routes, lazyStatuses = /* @__PURE__ */ new Map()) {
+  const visit = /* @__PURE__ */ __name((records, parentPath, parentId) => records.map((record, index) => {
+    const path = record.path === void 0 ? parentPath || "/" : resolveChildPath(parentPath, record.path);
+    const id = `${parentId}.${index}`;
+    const definition = record.component;
+    const lazyDefinition = definition !== void 0 && isLazyRouteComponent(definition);
+    const componentName = definition === void 0 ? "Route" : lazyDefinition ? "lazy(...)" : typeof definition === "function" ? definition.name || "Anonymous" : "Route";
+    return {
+      id,
+      path,
+      name: record.name,
+      component: componentName,
+      source: record.source,
+      lazy: lazyDefinition,
+      loader: record.loader !== void 0,
+      action: record.action !== void 0,
+      status: lazyDefinition ? lazyStatuses.get(id) ?? "loading" : "ready",
+      meta: Object.freeze({ ...record.meta ?? {} }),
+      children: visit(record.children ?? [], path, id)
+    };
+  }), "visit");
+  return Object.freeze(visit(routes, "", "route"));
+}
+__name(buildRouteDebugTree, "buildRouteDebugTree");
+function normalizeRoutes(routes) {
+  const matchers = [];
+  let order = 0;
+  function visit(records, parentPath, parentChain, parentMeta, parentId = "route") {
+    records.forEach((record, index) => {
+      const debugId = `${parentId}.${index}`;
+      const children = record.children ?? [];
+      const path = record.path === void 0 ? parentPath : resolveChildPath(parentPath, record.path);
+      const normalized = {
+        ...record,
+        path: record.path === void 0 ? children.length > 0 ? void 0 : path || "/" : path,
+        meta: record.meta ? { ...record.meta } : {}
+      };
+      routeDebugIds.set(normalized, debugId);
+      const chain = [...parentChain, normalized];
+      const meta = Object.freeze({ ...parentMeta, ...normalized.meta ?? {} });
+      if (children.length > 0) {
+        visit(children, path, chain, meta, debugId);
+      } else if (normalized.component) {
+        matchers.push(createMatcher(normalized, chain, meta, order++, debugId));
+      } else if (normalized.path === void 0) {
+        throw new Error(`Vobs Router: \u7B2C ${index + 1} \u4E2A\u8DEF\u7531\u7F3A\u5C11 path \u6216 children`);
+      }
+    });
+  }
+  __name(visit, "visit");
+  visit(routes, "", [], {});
+  return matchers;
+}
+__name(normalizeRoutes, "normalizeRoutes");
+function resolveChildPath(parentPath, childPath) {
+  const normalizedChild = normalizePath(childPath);
+  if (!parentPath || normalizedChild === "/") return normalizedChild === "/" ? parentPath || "/" : normalizedChild;
+  if (childPath.startsWith("/")) return normalizedChild;
+  return normalizePath(`${parentPath}/${childPath}`);
+}
+__name(resolveChildPath, "resolveChildPath");
+function createMatcher(record, chain, meta, order, debugId) {
+  const path = record.path ?? "/";
+  const segments = path === "/" ? [] : path.slice(1).split("/");
+  const keys = [];
+  let score = 0;
+  const pattern = segments.map((segment) => {
+    if (segment === "*") {
+      keys.push("pathMatch");
+      return "(.*)";
+    }
+    if (segment.startsWith(":")) {
+      const key = segment.slice(1);
+      if (!key) throw new Error(`Vobs Router: \u8DEF\u7531 ${path} \u7684\u53C2\u6570\u540D\u4E0D\u80FD\u4E3A\u7A7A`);
+      if (keys.includes(key)) throw new Error(`Vobs Router: \u8DEF\u7531 ${path} \u5B58\u5728\u91CD\u590D\u53C2\u6570 ${key}`);
+      keys.push(key);
+      score += 1;
+      return "([^/]+)";
+    }
+    score += 3;
+    return escapeRegExp(segment);
+  }).join("/");
+  return {
+    record,
+    debugId,
+    chain: Object.freeze([...chain]),
+    meta,
+    regex: new RegExp(segments.length === 0 ? "^/?$" : `^/${pattern}/?$`),
+    keys,
+    score,
+    order
+  };
+}
+__name(createMatcher, "createMatcher");
+function compareMatchers(left, right) {
+  return right.score - left.score || left.order - right.order;
+}
+__name(compareMatchers, "compareMatchers");
+function extractParams(matcher, path) {
+  const match = matcher.regex.exec(path);
+  if (!match) return {};
+  const params = {};
+  matcher.keys.forEach((key, index) => {
+    params[key] = decodeRoutePart(match[index + 1] ?? "");
+  });
+  return Object.freeze(params);
+}
+__name(extractParams, "extractParams");
+function parseTargetString(raw) {
+  const hashIndex = raw.indexOf("#");
+  const hash = hashIndex >= 0 ? normalizeHash(raw.slice(hashIndex + 1)) : "";
+  const withoutHash = hashIndex >= 0 ? raw.slice(0, hashIndex) : raw;
+  const queryIndex = withoutHash.indexOf("?");
+  const path = normalizePath(queryIndex >= 0 ? withoutHash.slice(0, queryIndex) : withoutHash);
+  const query = queryIndex >= 0 ? parseQuery(withoutHash.slice(queryIndex + 1)) : {};
+  return { path, query, hash };
+}
+__name(parseTargetString, "parseTargetString");
+function normalizeTarget(target, matchers) {
+  let path = target.path;
+  if (!path && target.name) {
+    const matcher = matchers.find((candidate) => candidate.record.name === target.name);
+    if (!matcher) throw new Error(`Vobs Router: \u627E\u4E0D\u5230\u540D\u4E3A ${target.name} \u7684\u8DEF\u7531`);
+    path = fillRouteParams(matcher.record.path ?? "/", target.params ?? {});
+  }
+  if (!path) throw new Error("Vobs Router: \u5BFC\u822A\u76EE\u6807\u5FC5\u987B\u63D0\u4F9B path \u6216 name");
+  const parsed = parseTargetString(path);
+  const filledPath = fillRouteParams(parsed.path, target.params ?? {});
+  const query = target.query === void 0 ? parsed.query : normalizeQuery(target.query);
+  const hash = target.hash === void 0 ? parsed.hash : normalizeHash(target.hash);
+  return { path: filledPath, query, hash, state: target.state };
+}
+__name(normalizeTarget, "normalizeTarget");
+function fillRouteParams(path, params) {
+  return path.replace(/:([A-Za-z0-9_]+)|\*/g, (token, key) => {
+    const value = key ? params[key] : params.pathMatch;
+    if (value === void 0 || value === null) return token;
+    return encodeURIComponent(String(value));
+  });
+}
+__name(fillRouteParams, "fillRouteParams");
+function buildTargetPath(path, query, hash) {
+  const params = new URLSearchParams();
+  for (const key of Object.keys(query).sort()) {
+    const value = query[key];
+    if (typeof value === "string") {
+      params.set(key, value);
+    } else {
+      for (const item of value) params.append(key, item);
+    }
+  }
+  const serialized = params.toString();
+  return `${path}${serialized ? `?${serialized}` : ""}${hash}`;
+}
+__name(buildTargetPath, "buildTargetPath");
+function parseQuery(raw) {
+  const params = new URLSearchParams(raw);
+  const result = {};
+  params.forEach((value, key) => {
+    const previous = result[key];
+    if (previous === void 0) result[key] = value;
+    else if (typeof previous === "string") result[key] = [previous, value];
+    else result[key] = [...previous, value];
+  });
+  for (const key of Object.keys(result)) {
+    if (Array.isArray(result[key])) result[key] = Object.freeze(result[key]);
+  }
+  return Object.freeze(result);
+}
+__name(parseQuery, "parseQuery");
+function normalizeQuery(input) {
+  if (input instanceof URLSearchParams) return parseQuery(input.toString());
+  const result = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) result[key] = Object.freeze(value.map((item) => String(item)));
+    else result[key] = String(value);
+  }
+  return Object.freeze(result);
+}
+__name(normalizeQuery, "normalizeQuery");
+function normalizePath(path) {
+  if (!path) return "/";
+  const withoutQuery = path.split(/[?#]/, 1)[0] || "/";
+  const withLeadingSlash = withoutQuery.startsWith("/") ? withoutQuery : `/${withoutQuery}`;
+  if (withLeadingSlash === "/*" || withLeadingSlash === "/") return withLeadingSlash;
+  return withLeadingSlash.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+__name(normalizePath, "normalizePath");
+function normalizeHistoryPath(path) {
+  const parsed = parseTargetString(path);
+  return buildTargetPath(parsed.path, parsed.query, parsed.hash);
+}
+__name(normalizeHistoryPath, "normalizeHistoryPath");
+function normalizeHash(hash) {
+  if (!hash) return "";
+  return hash.startsWith("#") ? hash : `#${hash}`;
+}
+__name(normalizeHash, "normalizeHash");
+function normalizeBase(base) {
+  if (!base || base === "/") return "";
+  return `/${base.replace(/^\/+|\/+$/g, "")}`;
+}
+__name(normalizeBase, "normalizeBase");
+function readBrowserLocation(base) {
+  const pathname = window.location.pathname;
+  const path = base && (pathname === base || pathname.startsWith(`${base}/`)) ? pathname.slice(base.length) || "/" : pathname;
+  return normalizeHistoryPath(`${path}${window.location.search}${window.location.hash}`);
+}
+__name(readBrowserLocation, "readBrowserLocation");
+function withBase(path, base) {
+  return `${base}${path === "/" ? "/" : path}` || "/";
+}
+__name(withBase, "withBase");
+function notifyListeners(listeners2, path, state2) {
+  for (const listener of [...listeners2]) listener(path, state2);
+}
+__name(notifyListeners, "notifyListeners");
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function decodeRoutePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+__name(decodeRoutePart, "decodeRoutePart");
+function isLazyRouteComponent(value) {
+  return typeof value === "object" && value !== null && value.kind === "vobs-lazy-route";
+}
+__name(isLazyRouteComponent, "isLazyRouteComponent");
+function isRouteComponentDefinition(value) {
+  return typeof value === "function" || isLazyRouteComponent(value);
+}
+__name(isRouteComponentDefinition, "isRouteComponentDefinition");
+async function loadRouteComponent(loader) {
+  const module = await loader.load();
+  const component = typeof module === "function" ? module : module.default;
+  if (typeof component !== "function") throw new Error("Vobs Router: \u61D2\u52A0\u8F7D\u6A21\u5757\u6CA1\u6709\u9ED8\u8BA4\u7EC4\u4EF6\u5BFC\u51FA");
+  return component;
+}
+__name(loadRouteComponent, "loadRouteComponent");
+function isRouteLocationRaw(value) {
+  return Boolean(value) && typeof value === "object";
+}
+__name(isRouteLocationRaw, "isRouteLocationRaw");
+function toError(reason) {
+  return reason instanceof Error ? reason : new Error(String(reason));
+}
+__name(toError, "toError");
+function isAbortError(reason) {
+  return Boolean(reason) && typeof reason === "object" && (reason.name === "AbortError" || reason.code === "ERR_CANCELED");
+}
+__name(isAbortError, "isAbortError");
+
+exports.NavigationCancelledError = NavigationCancelledError;
+exports.NavigationRedirectError = NavigationRedirectError;
+exports.ROUTER_KEY = ROUTER_KEY;
+exports.RouterView = RouterView;
+exports.createBrowserHistory = createBrowserHistory;
+exports.createMemoryHistory = createMemoryHistory;
+exports.createRouter = createRouter;
+exports.createRouterDebugId = createRouterDebugId;
+exports.emitRouterDebug = emitRouterDebug;
+exports.lazy = lazy;
+exports.routerPlugin = routerPlugin;
+exports.subscribeRouterDebug = subscribeRouterDebug;
+exports.useRoute = useRoute;
+exports.useRouter = useRouter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map