sinwan-router 0.1.1 → 1.0.0

package/dist/index.js

@@ -0,0 +1,899 @@
+// src/router.ts
+import { signal, computed } from "sinwan/reactivity";
+
+// src/matcher.ts
+function createNode(prefix) {
+  return {
+    prefix,
+    children: [],
+    isParam: prefix.startsWith(":"),
+    paramName: prefix.startsWith(":") ? prefix.slice(1) : "",
+    isWildcard: prefix === "*" || prefix.startsWith("*"),
+    route: null
+  };
+}
+function normalizePath(path) {
+  const qIdx = path.indexOf("?");
+  if (qIdx !== -1)
+    path = path.slice(0, qIdx);
+  const hIdx = path.indexOf("#");
+  if (hIdx !== -1)
+    path = path.slice(0, hIdx);
+  if (!path.startsWith("/"))
+    path = "/" + path;
+  if (path.length > 1 && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  return path;
+}
+function splitSegments(path) {
+  return path.split("/").filter(Boolean);
+}
+function extractSearchParams(path) {
+  const qIdx = path.indexOf("?");
+  if (qIdx === -1)
+    return new URLSearchParams;
+  return new URLSearchParams(path.slice(qIdx + 1));
+}
+function radixInsert(root, pattern, data) {
+  const segments = splitSegments(normalizePath(pattern));
+  insertNode(root, segments, 0, data);
+}
+function insertNode(node, segments, depth, data) {
+  if (depth === segments.length) {
+    node.route = data;
+    return;
+  }
+  const seg = segments[depth];
+  if (seg === undefined)
+    return;
+  if (seg === "*" || seg.startsWith("*")) {
+    const existing = node.children.find((c) => c.isWildcard);
+    if (existing) {
+      insertNode(existing, segments, depth + 1, data);
+      return;
+    }
+    const wc = createNode(seg);
+    node.children.push(wc);
+    insertNode(wc, segments, depth + 1, data);
+    return;
+  }
+  if (seg.startsWith(":")) {
+    const paramName = seg.slice(1);
+    for (const child of node.children) {
+      if (child.isParam && child.paramName === paramName) {
+        insertNode(child, segments, depth + 1, data);
+        return;
+      }
+    }
+    const pc = createNode(seg);
+    node.children.push(pc);
+    insertNode(pc, segments, depth + 1, data);
+    return;
+  }
+  for (const child of node.children) {
+    if (child.isParam || child.isWildcard)
+      continue;
+    if (child.prefix === seg) {
+      insertNode(child, segments, depth + 1, data);
+      return;
+    }
+  }
+  const sc = createNode(seg);
+  node.children.push(sc);
+  insertNode(sc, segments, depth + 1, data);
+}
+function radixSearch(root, path) {
+  const segments = splitSegments(normalizePath(path));
+  const params = Object.create(null);
+  const result = searchNode(root, segments, 0, params, "");
+  if (!result)
+    return null;
+  return result;
+}
+function searchNode(node, segments, depth, params, pathSoFar) {
+  if (depth === segments.length) {
+    if (node.route) {
+      return {
+        data: node.route,
+        params: copyParams(params),
+        matchedPath: pathSoFar
+      };
+    }
+    for (const child of node.children) {
+      if (child.isWildcard && child.route) {
+        const paramName = child.prefix === "*" ? "" : child.prefix.slice(1);
+        if (paramName) {
+          params[paramName] = "";
+        } else {
+          params["_wildcard"] = "";
+        }
+        return {
+          data: child.route,
+          params: copyParams(params),
+          matchedPath: pathSoFar + "/*"
+        };
+      }
+    }
+    return null;
+  }
+  const seg = segments[depth];
+  if (seg === undefined)
+    return null;
+  for (const child of node.children) {
+    if (child.isParam || child.isWildcard)
+      continue;
+    if (child.prefix !== seg)
+      continue;
+    const found = searchNode(child, segments, depth + 1, params, pathSoFar + "/" + child.prefix);
+    if (found)
+      return found;
+  }
+  for (const child of node.children) {
+    if (!child.isParam)
+      continue;
+    params[child.paramName] = decodeURIComponent(seg);
+    const found = searchNode(child, segments, depth + 1, params, pathSoFar + "/:" + child.paramName);
+    if (found)
+      return found;
+    delete params[child.paramName];
+  }
+  for (const child of node.children) {
+    if (!child.isWildcard)
+      continue;
+    if (!child.route)
+      continue;
+    const rest = wildcardValue(segments, depth);
+    const paramName = child.prefix === "*" ? "" : child.prefix.slice(1);
+    if (paramName) {
+      params[paramName] = rest;
+    } else {
+      params["_wildcard"] = rest;
+    }
+    return {
+      data: child.route,
+      params: copyParams(params),
+      matchedPath: pathSoFar + "/*"
+    };
+  }
+  return null;
+}
+function wildcardValue(segments, depth) {
+  let rest = "";
+  for (let i = depth;i < segments.length; i += 1) {
+    const seg = segments[i];
+    if (seg === undefined || seg === "")
+      continue;
+    if (rest === "")
+      rest = seg;
+    else
+      rest += "/" + seg;
+  }
+  return rest;
+}
+function copyParams(src) {
+  const dst = Object.create(null);
+  for (const key in src)
+    dst[key] = src[key];
+  return dst;
+}
+function createRadixTree() {
+  return createNode("");
+}
+function buildPath(pattern, params = {}) {
+  return pattern.replace(/:(\w+)/g, (_match, name) => {
+    const value = params[name];
+    if (value === undefined) {
+      throw new Error(`Missing param "${name}" for pattern "${pattern}"`);
+    }
+    return encodeURIComponent(value);
+  });
+}
+
+// src/router.ts
+function hasTrueFlag(value, key) {
+  return key in value && value[key] === true;
+}
+function isLazyComponent(comp) {
+  if (typeof comp !== "function")
+    return false;
+  if (hasTrueFlag(comp, "_SinwanComponent"))
+    return false;
+  if (hasTrueFlag(comp, "_SinwanLazy"))
+    return true;
+  return comp.length === 0;
+}
+function lazy(loader) {
+  const factory = () => loader();
+  return Object.assign(factory, { _SinwanLazy: true });
+}
+
+class Router {
+  tree;
+  routeList;
+  _path;
+  _searchParams;
+  _matched;
+  _params;
+  lazyCache = new Map;
+  lazyErrors = new Map;
+  lazyInflight = new Map;
+  _lazyTick;
+  popstateHandler = null;
+  constructor(routes, initialPath) {
+    this.tree = createRadixTree();
+    this.routeList = [];
+    this._lazyTick = signal(0);
+    for (const route of routes) {
+      this.insertRoute(route, "");
+    }
+    const startPath = initialPath ?? (typeof window !== "undefined" ? window.location.pathname + window.location.search : "/");
+    this._path = signal(normalizePath(startPath));
+    this._searchParams = signal(extractSearchParams(startPath));
+    this._matched = computed(() => {
+      const path = normalizePath(this._path.value);
+      const result = radixSearch(this.tree, path);
+      if (!result)
+        return null;
+      const leaf = result.data;
+      const params = result.params;
+      let parent;
+      let matched;
+      for (let i = 0;i < leaf.chain.length; i++) {
+        const entry = leaf.chain[i];
+        const m = {
+          route: entry.route,
+          params,
+          path,
+          matchedPath: entry.fullPattern,
+          parent: i > 0 ? parent : undefined
+        };
+        parent = m;
+        matched = m;
+      }
+      return matched ?? null;
+    });
+    this._params = computed(() => {
+      const matched = this._matched.value;
+      return matched ? matched.params : {};
+    });
+    if (typeof window !== "undefined") {
+      this.popstateHandler = () => {
+        const url = window.location.pathname + window.location.search;
+        this._path.value = normalizePath(url);
+        this._searchParams.value = extractSearchParams(url);
+      };
+      window.addEventListener("popstate", this.popstateHandler);
+    }
+  }
+  insertRoute(route, parentPath, parentChain = []) {
+    const fullPattern = joinPaths(parentPath, route.path);
+    const chain = [...parentChain, { route, fullPattern }];
+    const leafData = { route, fullPattern, chain };
+    radixInsert(this.tree, fullPattern, leafData);
+    this.routeList.push(route);
+    if (route.children) {
+      for (const child of route.children) {
+        this.insertRoute(child, fullPattern, chain);
+      }
+    }
+  }
+  bumpLazyTick() {
+    this._lazyTick.value = this._lazyTick.value + 1;
+  }
+  get lazyTick() {
+    return this._lazyTick.value;
+  }
+  peekLazy(cacheKey) {
+    const cached = this.lazyCache.get(cacheKey);
+    if (cached)
+      return { status: "ready", component: cached };
+    if (this.lazyInflight.has(cacheKey))
+      return { status: "loading" };
+    if (this.lazyErrors.has(cacheKey)) {
+      return { status: "error", error: this.lazyErrors.get(cacheKey) };
+    }
+    return { status: "idle" };
+  }
+  ensureLazy(cacheKey, loader) {
+    const state = this.peekLazy(cacheKey);
+    if (state.status !== "idle")
+      return;
+    this.startLazyLoad(cacheKey, loader);
+  }
+  startLazyLoad(cacheKey, loader) {
+    this.lazyErrors.delete(cacheKey);
+    const pending = loader().then((mod) => {
+      this.lazyCache.set(cacheKey, mod.default);
+      this.lazyErrors.delete(cacheKey);
+      this.bumpLazyTick();
+      return mod.default;
+    }).catch((err) => {
+      this.lazyErrors.set(cacheKey, err);
+      this.bumpLazyTick();
+      throw err;
+    }).finally(() => {
+      this.lazyInflight.delete(cacheKey);
+    });
+    this.lazyInflight.set(cacheKey, pending);
+    pending.catch(() => {});
+    return pending;
+  }
+  get path() {
+    return this._path.value;
+  }
+  get pathSignal() {
+    return this._path;
+  }
+  get matched() {
+    return this._matched.value;
+  }
+  get matchedComputed() {
+    return this._matched;
+  }
+  get params() {
+    return this._params.value;
+  }
+  get searchParams() {
+    return this._searchParams.value;
+  }
+  get routes() {
+    return this.routeList;
+  }
+  navigate(to, options = {}) {
+    const normalized = normalizePath(to);
+    if (typeof window !== "undefined") {
+      if (options.replace) {
+        window.history.replaceState(options.state ?? {}, "", to);
+      } else {
+        window.history.pushState(options.state ?? {}, "", to);
+      }
+    }
+    this._path.value = normalized;
+    this._searchParams.value = extractSearchParams(to);
+  }
+  prefetch(path) {
+    if (typeof window === "undefined")
+      return;
+    const normalized = normalizePath(path);
+    const result = radixSearch(this.tree, normalized);
+    if (!result)
+      return;
+    const leaf = result.data;
+    const route = leaf.route;
+    if (!isLazyComponent(route.component))
+      return;
+    const cacheKey = leaf.fullPattern;
+    const state = this.peekLazy(cacheKey);
+    if (state.status === "ready" || state.status === "loading")
+      return;
+    this.startLazyLoad(cacheKey, route.component);
+  }
+  async resolveComponent(route) {
+    if (!isLazyComponent(route.component)) {
+      return route.component;
+    }
+    const cacheKey = this.findFullPattern(route) ?? route.path;
+    const cached = this.lazyCache.get(cacheKey);
+    if (cached)
+      return cached;
+    const inflight = this.lazyInflight.get(cacheKey);
+    if (inflight)
+      return inflight;
+    return this.startLazyLoad(cacheKey, route.component);
+  }
+  findFullPattern(route) {
+    return this.searchForRoute(this.tree, route, "");
+  }
+  searchForRoute(node, target, pathSoFar) {
+    if (node.route) {
+      const leaf = node.route;
+      if (leaf.route === target)
+        return leaf.fullPattern;
+    }
+    for (const child of node.children) {
+      const seg = child.isParam ? "/:" + child.paramName : child.isWildcard ? "/*" : "/" + child.prefix;
+      const found = this.searchForRoute(child, target, pathSoFar + seg);
+      if (found)
+        return found;
+    }
+    return;
+  }
+  dispose() {
+    if (this.popstateHandler && typeof window !== "undefined") {
+      window.removeEventListener("popstate", this.popstateHandler);
+      this.popstateHandler = null;
+    }
+    this.lazyCache.clear();
+    this.lazyErrors.clear();
+    this.lazyInflight.clear();
+  }
+}
+function joinPaths(parent, child) {
+  if (child === "/")
+    return parent || "/";
+  const relativeChild = child.startsWith("/") ? child.slice(1) : child;
+  if (parent === "/" || parent === "")
+    return "/" + relativeChild;
+  return parent + "/" + relativeChild;
+}
+function createRouter(routes, initialPath) {
+  return new Router(routes, initialPath);
+}
+// src/components.tsx
+import { _$createTemplate } from "sinwan/renderer";
+import { cc } from "sinwan/component";
+import { Key } from "sinwan/component";
+import { computed as computed2 } from "sinwan/reactivity";
+
+// src/hooks.ts
+import { inject } from "sinwan/component";
+var RouterKey = Symbol("sinwan.router");
+function useRouter() {
+  const router = inject(RouterKey);
+  if (!router) {
+    throw new Error("useRouter() called outside of a Router provider.");
+  }
+  return router;
+}
+function useParams() {
+  return useRouter().params;
+}
+function useSearchParams() {
+  return useRouter().searchParams;
+}
+function useRoute() {
+  return useRouter().matched;
+}
+function useNavigate() {
+  const router = useRouter();
+  return router.navigate.bind(router);
+}
+function usePath() {
+  return useRouter().path;
+}
+
+// src/link-nav.ts
+function jsxClass(value) {
+  return value;
+}
+function isExternalHref(href) {
+  if (href.startsWith("//"))
+    return true;
+  const colon = href.indexOf(":");
+  if (colon <= 0)
+    return false;
+  const slash = href.indexOf("/");
+  if (slash !== -1 && slash < colon)
+    return false;
+  return true;
+}
+function isHashOnlyHref(href, currentPath) {
+  if (href.startsWith("#"))
+    return true;
+  const hashIdx = href.indexOf("#");
+  if (hashIdx === -1)
+    return false;
+  const beforeHash = href.slice(0, hashIdx);
+  if (beforeHash === "")
+    return true;
+  const qIdx = beforeHash.indexOf("?");
+  const pathPart = qIdx === -1 ? beforeHash : beforeHash.slice(0, qIdx);
+  if (pathPart === "" || pathPart === ".")
+    return true;
+  const normalized = pathPart.startsWith("/") ? pathPart : "/" + pathPart;
+  const stripped = normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+  return stripped === currentPath;
+}
+function shouldInterceptLinkClick(event, href, currentPath, options = {}) {
+  if (event.defaultPrevented)
+    return false;
+  if (event.button !== 0)
+    return false;
+  if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
+    return false;
+  }
+  if (options.target != null && options.target !== "" && options.target !== "_self") {
+    return false;
+  }
+  if (options.download !== undefined && options.download !== false) {
+    return false;
+  }
+  if (isExternalHref(href))
+    return false;
+  if (isHashOnlyHref(href, currentPath))
+    return false;
+  return true;
+}
+
+// src/outlet.ts
+function getMatchAtDepth(matched, depth) {
+  if (!matched)
+    return null;
+  let current = matched;
+  const chain = [];
+  while (current) {
+    chain.unshift(current);
+    current = current.parent;
+  }
+  return chain[depth] ?? null;
+}
+function routeIdentity(matched) {
+  const pattern = matched.matchedPath;
+  if (pattern.includes("*")) {
+    return matched.path;
+  }
+  let concrete = pattern;
+  for (const key of Object.keys(matched.params)) {
+    const value = matched.params[key];
+    if (value === undefined)
+      continue;
+    concrete = concrete.replace(":" + key, encodeURIComponent(value));
+  }
+  if (concrete.includes(":")) {
+    return matched.path;
+  }
+  return concrete;
+}
+function lazyStatusSuffix(router, matched) {
+  if (!isLazyComponent(matched.route.component))
+    return "sync";
+  const state = router.peekLazy(matched.matchedPath);
+  return state.status;
+}
+function computeOutletKey(router, depth) {
+  router.lazyTick;
+  const matched = getMatchAtDepth(router.matched, depth);
+  if (!matched) {
+    return depth > 0 ? `__empty:${depth}` : "__notfound__";
+  }
+  return `${routeIdentity(matched)}:${lazyStatusSuffix(router, matched)}`;
+}
+
+// src/components.tsx
+import { jsxDEV } from "sinwan/jsx-dev-runtime";
+var _$tmpl_0 = {
+  html: '<a href="" class="" target="" download="" rel="" onclick="" onmouseenter=""><!--s:0--></a>',
+  slots: [{
+    path: [],
+    type: "attr",
+    name: "href"
+  }, {
+    path: [],
+    type: "attr",
+    name: "class"
+  }, {
+    path: [],
+    type: "attr",
+    name: "target"
+  }, {
+    path: [],
+    type: "attr",
+    name: "download"
+  }, {
+    path: [],
+    type: "attr",
+    name: "rel"
+  }, {
+    path: [],
+    type: "event",
+    name: "onclick"
+  }, {
+    path: [],
+    type: "event",
+    name: "onmouseenter"
+  }, {
+    path: [0],
+    type: "child"
+  }]
+};
+var _$tmpl_1 = {
+  html: '<a href="" class="" target="" download="" rel="" onclick="" onmouseenter=""><!--s:0--></a>',
+  slots: [{
+    path: [],
+    type: "attr",
+    name: "href"
+  }, {
+    path: [],
+    type: "attr",
+    name: "class"
+  }, {
+    path: [],
+    type: "attr",
+    name: "target"
+  }, {
+    path: [],
+    type: "attr",
+    name: "download"
+  }, {
+    path: [],
+    type: "attr",
+    name: "rel"
+  }, {
+    path: [],
+    type: "event",
+    name: "onclick"
+  }, {
+    path: [],
+    type: "event",
+    name: "onmouseenter"
+  }, {
+    path: [0],
+    type: "child"
+  }]
+};
+var _$tmpl_2 = {
+  html: "<div>404 - Page not found</div>",
+  slots: []
+};
+var _$tmpl_3 = {
+  html: "<div>Loading...</div>",
+  slots: []
+};
+var _$tmpl_4 = {
+  html: "<div>Failed to load page</div>",
+  slots: []
+};
+function onLinkClick(event, href, router, options) {
+  if (!shouldInterceptLinkClick(event, href, router.path, options))
+    return;
+  event.preventDefault();
+  router.navigate(href);
+}
+function downloadAttr(download) {
+  if (download === undefined || download === false)
+    return;
+  if (download === true)
+    return "";
+  return download;
+}
+var Link = cc(({
+  href,
+  prefetch = true,
+  class: cls,
+  children,
+  target,
+  download,
+  rel
+}) => {
+  const router = useRouter();
+  return _$createTemplate(_$tmpl_0, [href, cls, target, downloadAttr(download), rel, (e) => {
+    onLinkClick(e, href, router, {
+      target,
+      download
+    });
+  }, () => {
+    if (prefetch)
+      router.prefetch(href);
+  }, children]);
+});
+var NavLink = cc(({
+  href,
+  prefetch = true,
+  activeClass = "active",
+  class: cls,
+  children,
+  target,
+  download,
+  rel
+}) => {
+  const router = useRouter();
+  const className = computed2(() => router.path === href || router.path.startsWith(href + "/") ? `${cls ?? ""} ${activeClass}`.trim() : cls ?? "");
+  return _$createTemplate(_$tmpl_1, [href, jsxClass(() => className.value), target, downloadAttr(download), rel, (e) => {
+    onLinkClick(e, href, router, {
+      target,
+      download
+    });
+  }, () => {
+    if (prefetch)
+      router.prefetch(href);
+  }, children]);
+});
+var DefaultNotFound = cc(() => _$createTemplate(_$tmpl_2, []));
+var DefaultLoading = cc(() => _$createTemplate(_$tmpl_3, []));
+var DefaultError = cc(() => _$createTemplate(_$tmpl_4, []));
+function resolveOutletNode(matched, router, fallback, errorComp) {
+  const route = matched.route;
+  if (!isLazyComponent(route.component)) {
+    const Comp = route.component;
+    return /* @__PURE__ */ jsxDEV(Comp, {}, undefined, false, undefined, this);
+  }
+  const cacheKey = matched.matchedPath;
+  const state = router.peekLazy(cacheKey);
+  if (state.status === "ready") {
+    const Comp = state.component;
+    return /* @__PURE__ */ jsxDEV(Comp, {}, undefined, false, undefined, this);
+  }
+  if (state.status === "error") {
+    const ErrorView = errorComp;
+    return /* @__PURE__ */ jsxDEV(ErrorView, {
+      error: state.error
+    }, undefined, false, undefined, this);
+  }
+  router.ensureLazy(cacheKey, route.component);
+  const Fallback = fallback;
+  return /* @__PURE__ */ jsxDEV(Fallback, {}, undefined, false, undefined, this);
+}
+var RouterOutlet = cc(({
+  fallback,
+  notFound,
+  error,
+  depth = 0
+}) => {
+  const router = useRouter();
+  const Fallback = fallback ?? DefaultLoading;
+  const NotFound = notFound ?? DefaultNotFound;
+  const ErrorView = error ?? DefaultError;
+  return /* @__PURE__ */ jsxDEV(Key, {
+    when: () => computeOutletKey(router, depth),
+    children: () => {
+      const matched = getMatchAtDepth(router.matched, depth);
+      if (!matched) {
+        if (depth > 0)
+          return null;
+        return /* @__PURE__ */ jsxDEV(NotFound, {}, undefined, false, undefined, this);
+      }
+      return resolveOutletNode(matched, router, Fallback, ErrorView);
+    }
+  }, undefined, false, undefined, this);
+});
+// src/jsx-routes.tsx
+import { cc as cc2, provide, onDispose } from "sinwan/component";
+import { jsxDEV as jsxDEV2 } from "sinwan/jsx-dev-runtime";
+var ROUTE_TYPE = Symbol.for("sinwan.router.Route");
+function isElementLike(value) {
+  return value != null && typeof value === "object" && "tag" in value;
+}
+function routePropsRecord(props) {
+  const record = {
+    path: props.path,
+    component: props.component
+  };
+  if (props.meta !== undefined)
+    record.meta = props.meta;
+  if (props.children !== undefined)
+    record.children = props.children;
+  return record;
+}
+function Route(props) {
+  return {
+    tag: ROUTE_TYPE,
+    props: routePropsRecord(props),
+    children: []
+  };
+}
+function isRouteElement(value) {
+  if (!isElementLike(value))
+    return false;
+  return value.tag === ROUTE_TYPE || value.tag === Route;
+}
+function isRouteDefinition(value) {
+  if (value == null || typeof value !== "object")
+    return false;
+  if ("tag" in value)
+    return false;
+  const rec = value;
+  return typeof rec.path === "string" && rec.component != null;
+}
+function flattenNodes(node) {
+  if (node == null || typeof node === "boolean")
+    return [];
+  if (Array.isArray(node)) {
+    const out = [];
+    for (const child of node) {
+      out.push(...flattenNodes(child));
+    }
+    return out;
+  }
+  if (isElementLike(node) && node.tag === "") {
+    const fromKids = flattenNodes(node.children);
+    if (fromKids.length > 0)
+      return fromKids;
+    return flattenNodes(node.props.children);
+  }
+  return [node];
+}
+function nestedDefinitions(source) {
+  if (source == null)
+    return;
+  if (Array.isArray(source) && source.length > 0 && isRouteDefinition(source[0])) {
+    const defs = [];
+    for (const item of source) {
+      if (isRouteDefinition(item))
+        defs.push(item);
+    }
+    return defs.length > 0 ? defs : undefined;
+  }
+  if (isRouteDefinition(source))
+    return [source];
+  const collected = collectRouteDefinitions(source);
+  return collected.length > 0 ? collected : undefined;
+}
+function routeNodeToDefinition(node) {
+  if (isRouteDefinition(node)) {
+    const def = {
+      path: node.path,
+      component: node.component
+    };
+    if (node.meta)
+      def.meta = node.meta;
+    if (node.children && node.children.length > 0)
+      def.children = node.children;
+    return def;
+  }
+  if (!isRouteElement(node))
+    return null;
+  const props = node.props;
+  const path = props.path;
+  const component = props.component;
+  if (typeof path !== "string" || component == null)
+    return null;
+  const def = {
+    path,
+    component
+  };
+  const meta = props.meta;
+  if (meta != null && typeof meta === "object") {
+    def.meta = meta;
+  }
+  const nested = nestedDefinitions(props.children ?? node.children);
+  if (nested)
+    def.children = nested;
+  return def;
+}
+function collectRouteDefinitions(children) {
+  const defs = [];
+  for (const node of flattenNodes(children)) {
+    const def = routeNodeToDefinition(node);
+    if (def)
+      defs.push(def);
+  }
+  return defs;
+}
+var Routes = cc2(({
+  children,
+  fallback,
+  notFound,
+  error,
+  initialPath
+}) => {
+  const router = createRouter(collectRouteDefinitions(children), initialPath);
+  provide(RouterKey, router);
+  onDispose(() => {
+    router.dispose();
+  });
+  return /* @__PURE__ */ jsxDEV2(RouterOutlet, {
+    fallback,
+    notFound,
+    error
+  }, undefined, false, undefined, this);
+});
+export {
+  Link,
+  NavLink,
+  Route,
+  Router,
+  RouterKey,
+  RouterOutlet,
+  Routes,
+  buildPath,
+  collectRouteDefinitions,
+  createRadixTree,
+  createRouter,
+  extractSearchParams,
+  isLazyComponent,
+  isRouteElement,
+  lazy,
+  normalizePath,
+  radixInsert,
+  radixSearch,
+  useNavigate,
+  useParams,
+  usePath,
+  useRoute,
+  useRouter,
+  useSearchParams
+};
+
+//# debugId=B05954AB6554A08764756E2164756E21
+//# sourceMappingURL=index.js.map