@fictjs/router 0.2.2 → 0.3.0

package/dist/index.cjs

@@ -20,12 +20,2382 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Router: () => Router
+  Form: () => Form,
+  HashRouter: () => HashRouter,
+  Link: () => Link,
+  MemoryRouter: () => MemoryRouter,
+  NavLink: () => NavLink,
+  Navigate: () => Navigate,
+  Outlet: () => Outlet,
+  Redirect: () => Redirect,
+  Route: () => Route,
+  Router: () => Router,
+  Routes: () => Routes,
+  StaticRouter: () => StaticRouter,
+  action: () => action,
+  cleanupDataUtilities: () => cleanupDataUtilities,
+  clearAllScrollPositions: () => clearAllScrollPositions,
+  clearScrollPosition: () => clearScrollPosition,
+  compileRoute: () => compileRoute,
+  configureScrollRestoration: () => configureScrollRestoration,
+  createBranches: () => createBranches,
+  createBrowserHistory: () => createBrowserHistory,
+  createHashHistory: () => createHashHistory,
+  createLazyRoutes: () => createLazyRoutes,
+  createLocation: () => createLocation,
+  createMemoryHistory: () => createMemoryHistory,
+  createPreload: () => createPreload,
+  createResource: () => createResource,
+  createRouter: () => createRouter,
+  createRoutes: () => createRoutes,
+  createScrollRestoration: () => createScrollRestoration,
+  createStaticHistory: () => createStaticHistory,
+  createURL: () => createURL,
+  getAction: () => getAction,
+  getScrollRestoration: () => getScrollRestoration,
+  isBrowser: () => isBrowser,
+  isLazyComponent: () => isLazyComponent,
+  isServer: () => isServer,
+  joinPaths: () => joinPaths,
+  lazy: () => lazy,
+  lazyRoute: () => lazyRoute,
+  locationsAreEqual: () => locationsAreEqual,
+  matchRoutes: () => matchRoutes,
+  normalizePath: () => normalizePath,
+  parseSearchParams: () => parseSearchParams,
+  parseURL: () => parseURL,
+  preloadLazy: () => preloadLazy,
+  preloadQuery: () => preloadQuery,
+  prependBasePath: () => prependBasePath,
+  query: () => query,
+  resolvePath: () => resolvePath,
+  restoreScrollPosition: () => restoreScrollPosition,
+  revalidate: () => revalidate,
+  saveScrollPosition: () => saveScrollPosition,
+  scoreRoute: () => scoreRoute,
+  scrollToHash: () => scrollToHash,
+  scrollToTop: () => scrollToTop,
+  stringifySearchParams: () => stringifySearchParams,
+  stripBasePath: () => stripBasePath,
+  submitAction: () => submitAction,
+  useBeforeLeave: () => useBeforeLeave,
+  useHref: () => useHref,
+  useIsActive: () => useIsActive,
+  useIsRouting: () => useIsRouting,
+  useLocation: () => useLocation,
+  useMatch: () => useMatch,
+  useMatches: () => useMatches,
+  useNavigate: () => useNavigate,
+  useParams: () => useParams,
+  usePendingLocation: () => usePendingLocation,
+  useResolvedPath: () => useResolvedPath,
+  useRoute: () => useRoute,
+  useRouteData: () => useRouteData,
+  useRouteError: () => useRouteError,
+  useRouter: () => useRouter,
+  useSearchParams: () => useSearchParams,
+  useSubmission: () => useSubmission,
+  useSubmissions: () => useSubmissions
 });
 module.exports = __toCommonJS(index_exports);
-var Router = () => {
+
+// src/components.tsx
+var import_runtime2 = require("@fictjs/runtime");
+var import_advanced = require("@fictjs/runtime/advanced");
+
+// src/context.ts
+var import_runtime = require("@fictjs/runtime");
+
+// src/utils.ts
+function normalizePath(path) {
+  if (!path || path === "/") return "/";
+  let normalized = path.startsWith("/") ? path : "/" + path;
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function joinPaths(...paths) {
+  return normalizePath(
+    paths.filter((p) => p != null && p !== "").join("/").replace(/\/+/g, "/")
+  );
+}
+function resolvePath(base, to) {
+  const toPath = typeof to === "string" ? to : to.pathname || "";
+  if (toPath.startsWith("/")) {
+    return normalizePath(toPath);
+  }
+  const baseSegments = base.split("/").filter(Boolean);
+  const toSegments = toPath.split("/").filter(Boolean);
+  for (const segment of toSegments) {
+    if (segment === "..") {
+      baseSegments.pop();
+    } else if (segment !== ".") {
+      baseSegments.push(segment);
+    }
+  }
+  return "/" + baseSegments.join("/");
+}
+function createLocation(to, state, key) {
+  if (typeof to === "string") {
+    const url = parseURL(to);
+    return {
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash,
+      state: state ?? null,
+      key: key ?? createKey()
+    };
+  }
+  return {
+    pathname: to.pathname || "/",
+    search: to.search || "",
+    hash: to.hash || "",
+    state: state ?? to.state ?? null,
+    key: key ?? to.key ?? createKey()
+  };
+}
+function parseURL(url) {
+  const hashIndex = url.indexOf("#");
+  let hash = "";
+  if (hashIndex >= 0) {
+    hash = url.slice(hashIndex);
+    url = url.slice(0, hashIndex);
+  }
+  const searchIndex = url.indexOf("?");
+  let search = "";
+  if (searchIndex >= 0) {
+    search = url.slice(searchIndex);
+    url = url.slice(0, searchIndex);
+  }
+  return {
+    pathname: normalizePath(url || "/"),
+    search,
+    hash
+  };
+}
+function createURL(location) {
+  const pathname = location.pathname || "/";
+  const search = location.search || "";
+  const hash = location.hash || "";
+  return pathname + search + hash;
+}
+var keyIndex = 0;
+function createKey() {
+  return String(++keyIndex);
+}
+function parsePathPattern(pattern) {
+  const segments = [];
+  const parts = pattern.split("/").filter(Boolean);
+  for (const part of parts) {
+    if (part === "*" || part.startsWith("*")) {
+      const paramName = part.length > 1 ? part.slice(1) : "*";
+      segments.push({ type: "splat", value: part, paramName });
+    } else if (part.startsWith(":")) {
+      const isOptional = part.endsWith("?");
+      const paramName = isOptional ? part.slice(1, -1) : part.slice(1);
+      segments.push({
+        type: isOptional ? "optional" : "dynamic",
+        value: part,
+        paramName
+      });
+    } else {
+      segments.push({ type: "static", value: part.toLowerCase() });
+    }
+  }
+  return segments;
+}
+function scoreRoute(pattern, isIndex = false) {
+  const segments = parsePathPattern(pattern);
+  let score = 0;
+  for (const segment of segments) {
+    switch (segment.type) {
+      case "static":
+        score += 3;
+        break;
+      case "dynamic":
+        score += 2;
+        break;
+      case "optional":
+        score += 1;
+        break;
+      case "splat":
+        score += 0.5;
+        break;
+    }
+  }
+  if (isIndex) {
+    score += 0.5;
+  }
+  return score;
+}
+function createMatcher(pattern, matchFilters) {
+  const segments = parsePathPattern(pattern);
+  const normalizedPattern = normalizePath(pattern);
+  return (pathname) => {
+    const pathSegments = pathname.split("/").filter(Boolean);
+    const params = {};
+    let matchedPath = "";
+    let pathIndex = 0;
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      const pathSegment = pathSegments[pathIndex];
+      switch (segment.type) {
+        case "static":
+          if (!pathSegment || pathSegment.toLowerCase() !== segment.value) {
+            return null;
+          }
+          matchedPath += "/" + pathSegment;
+          pathIndex++;
+          break;
+        case "dynamic":
+          if (!pathSegment) {
+            return null;
+          }
+          if (matchFilters && segment.paramName && matchFilters[segment.paramName]) {
+            if (!validateParam(pathSegment, matchFilters[segment.paramName])) {
+              return null;
+            }
+          }
+          params[segment.paramName] = decodeURIComponent(pathSegment);
+          matchedPath += "/" + pathSegment;
+          pathIndex++;
+          break;
+        case "optional": {
+          if (pathSegment) {
+            const nextSegment = segments[i + 1];
+            if (nextSegment && nextSegment.type === "static" && pathSegment.toLowerCase() === nextSegment.value) {
+              break;
+            }
+            if (matchFilters && segment.paramName && matchFilters[segment.paramName]) {
+              if (!validateParam(pathSegment, matchFilters[segment.paramName])) {
+                break;
+              }
+            }
+            params[segment.paramName] = decodeURIComponent(pathSegment);
+            matchedPath += "/" + pathSegment;
+            pathIndex++;
+          }
+          break;
+        }
+        case "splat": {
+          const remainingSegments = pathSegments.slice(pathIndex);
+          const decodedSegments = remainingSegments.map((seg) => {
+            try {
+              return decodeURIComponent(seg);
+            } catch {
+              return seg;
+            }
+          });
+          params[segment.paramName] = decodedSegments.join("/");
+          matchedPath += remainingSegments.length > 0 ? "/" + remainingSegments.join("/") : "";
+          pathIndex = pathSegments.length;
+          break;
+        }
+      }
+    }
+    if (pathIndex < pathSegments.length) {
+      return null;
+    }
+    return {
+      route: {},
+      // Will be filled in by caller
+      pathname: matchedPath || "/",
+      params,
+      pattern: normalizedPattern
+    };
+  };
+}
+function validateParam(value, filter) {
+  if (filter instanceof RegExp) {
+    return filter.test(value);
+  }
+  if (Array.isArray(filter)) {
+    return filter.includes(value);
+  }
+  if (typeof filter === "function") {
+    return filter(value);
+  }
+  return true;
+}
+var routeKeyCounter = 0;
+function compileRoute(route, parentPattern = "") {
+  const pattern = normalizePath(
+    joinPaths(parentPattern, route.path || (route.index ? "" : void 0))
+  );
+  const compiled = {
+    route,
+    pattern,
+    matcher: createMatcher(pattern, route.matchFilters),
+    score: scoreRoute(pattern, route.index),
+    key: route.key || `route-${++routeKeyCounter}`
+  };
+  if (route.children && route.children.length > 0) {
+    compiled.children = route.children.map(
+      (child) => compileRoute(child, route.index ? parentPattern : pattern)
+    );
+  }
+  return compiled;
+}
+function createBranches(routes) {
+  const branches = [];
+  function buildBranches(route, parentRoutes = []) {
+    const currentRoutes = [...parentRoutes, route];
+    if (route.children && route.children.length > 0) {
+      for (const child of route.children) {
+        buildBranches(child, currentRoutes);
+      }
+    } else {
+      const score = currentRoutes.reduce((sum, r) => sum + r.score, 0);
+      const branchMatcher = (pathname) => {
+        const matches = [];
+        let remainingPath = pathname;
+        let accumulatedParams = {};
+        for (const compiledRoute of currentRoutes) {
+          const match = compiledRoute.matcher(remainingPath);
+          if (!match) {
+            return null;
+          }
+          accumulatedParams = { ...accumulatedParams, ...match.params };
+          matches.push({
+            ...match,
+            route: compiledRoute.route,
+            params: { ...accumulatedParams }
+          });
+          if (compiledRoute !== currentRoutes[currentRoutes.length - 1]) {
+            if (match.pathname !== "/") {
+              remainingPath = remainingPath.slice(match.pathname.length) || "/";
+            }
+          }
+        }
+        return matches;
+      };
+      branches.push({
+        routes: currentRoutes,
+        score,
+        matcher: branchMatcher
+      });
+    }
+  }
+  for (const route of routes) {
+    buildBranches(route);
+  }
+  branches.sort((a, b) => b.score - a.score);
+  return branches;
+}
+function matchRoutes(branches, pathname) {
+  const normalizedPath = normalizePath(pathname);
+  for (const branch of branches) {
+    const matches = branch.matcher(normalizedPath);
+    if (matches) {
+      return matches;
+    }
+  }
+  return null;
+}
+function parseSearchParams(search) {
+  return new URLSearchParams(search);
+}
+function stringifySearchParams(params) {
+  const searchParams = params instanceof URLSearchParams ? params : new URLSearchParams(params);
+  const str = searchParams.toString();
+  return str ? "?" + str : "";
+}
+function locationsAreEqual(a, b) {
+  return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash;
+}
+function stripBasePath(pathname, basePath) {
+  if (basePath === "/" || basePath === "") {
+    return pathname;
+  }
+  const normalizedBase = normalizePath(basePath);
+  if (pathname.startsWith(normalizedBase)) {
+    const stripped = pathname.slice(normalizedBase.length);
+    return stripped || "/";
+  }
+  return pathname;
+}
+function prependBasePath(pathname, basePath) {
+  if (basePath === "/" || basePath === "") {
+    return pathname;
+  }
+  return joinPaths(basePath, pathname);
+}
+function hashParams(params) {
+  const entries = Object.entries(params).sort(([a], [b]) => a.localeCompare(b));
+  return JSON.stringify(entries);
+}
+function isServer() {
+  return typeof window === "undefined";
+}
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+
+// src/context.ts
+var defaultRouterContext = {
+  location: () => ({
+    pathname: "/",
+    search: "",
+    hash: "",
+    state: null,
+    key: "default"
+  }),
+  params: () => ({}),
+  matches: () => [],
+  navigate: () => {
+    console.warn("[fict-router] No router found. Wrap your app in a <Router>");
+  },
+  isRouting: () => false,
+  pendingLocation: () => null,
+  base: "",
+  resolvePath: (to) => typeof to === "string" ? to : to.pathname || "/"
+};
+var RouterContext = (0, import_runtime.createContext)(defaultRouterContext);
+RouterContext.displayName = "RouterContext";
+function useRouter() {
+  return (0, import_runtime.useContext)(RouterContext);
+}
+var defaultRouteContext = {
+  match: () => void 0,
+  data: () => void 0,
+  outlet: () => null,
+  resolvePath: (to) => typeof to === "string" ? to : to.pathname || "/"
+};
+var RouteContext = (0, import_runtime.createContext)(defaultRouteContext);
+RouteContext.displayName = "RouteContext";
+function useRoute() {
+  return (0, import_runtime.useContext)(RouteContext);
+}
+var defaultBeforeLeaveContext = {
+  addHandler: () => () => {
+  },
+  confirm: async () => true
+};
+var BeforeLeaveContext = (0, import_runtime.createContext)(defaultBeforeLeaveContext);
+BeforeLeaveContext.displayName = "BeforeLeaveContext";
+function useBeforeLeaveContext() {
+  return (0, import_runtime.useContext)(BeforeLeaveContext);
+}
+var defaultRouteErrorContext = {
+  error: void 0,
+  reset: void 0
+};
+var RouteErrorContext = (0, import_runtime.createContext)(defaultRouteErrorContext);
+RouteErrorContext.displayName = "RouteErrorContext";
+function useNavigate() {
+  const router = useRouter();
+  return router.navigate;
+}
+function useLocation() {
+  const router = useRouter();
+  return router.location;
+}
+function useParams() {
+  const router = useRouter();
+  return router.params;
+}
+function useSearchParams() {
+  const router = useRouter();
+  const getSearchParams = () => {
+    const location = router.location();
+    return new URLSearchParams(location.search);
+  };
+  const setSearchParams = (params, options) => {
+    const searchParams = params instanceof URLSearchParams ? params : new URLSearchParams(params);
+    const search = searchParams.toString();
+    const location = router.location();
+    router.navigate(
+      {
+        pathname: location.pathname,
+        search: search ? "?" + search : "",
+        hash: location.hash
+      },
+      { replace: options?.replace }
+    );
+  };
+  return [getSearchParams, setSearchParams];
+}
+function useMatches() {
+  const router = useRouter();
+  return router.matches;
+}
+function useIsRouting() {
+  const router = useRouter();
+  return router.isRouting;
+}
+function usePendingLocation() {
+  const router = useRouter();
+  return router.pendingLocation;
+}
+function useRouteData() {
+  const route = useRoute();
+  return route.data;
+}
+function useRouteError() {
+  const errorContext = (0, import_runtime.useContext)(RouteErrorContext);
+  if (errorContext.error !== void 0) {
+    return errorContext.error;
+  }
+  const route = useRoute();
+  return route.error?.();
+}
+function useResolvedPath(to) {
+  const route = useRoute();
+  return () => {
+    const target = typeof to === "function" ? to() : to;
+    return route.resolvePath(target);
+  };
+}
+function useMatch(path) {
+  const router = useRouter();
+  return () => {
+    const targetPath = typeof path === "function" ? path() : path;
+    const matches = router.matches();
+    for (const match of matches) {
+      if (match.pattern === targetPath || match.pathname === targetPath) {
+        return match;
+      }
+    }
+    return null;
+  };
+}
+function useHref(to) {
+  const router = useRouter();
+  return () => {
+    const target = typeof to === "function" ? to() : to;
+    let pathname;
+    let search = "";
+    let hash = "";
+    if (typeof target === "string") {
+      let remaining = target;
+      const hashIndex = remaining.indexOf("#");
+      if (hashIndex >= 0) {
+        hash = remaining.slice(hashIndex);
+        remaining = remaining.slice(0, hashIndex);
+      }
+      const searchIndex = remaining.indexOf("?");
+      if (searchIndex >= 0) {
+        search = remaining.slice(searchIndex);
+        remaining = remaining.slice(0, searchIndex);
+      }
+      pathname = remaining;
+    } else {
+      pathname = target.pathname || "";
+      search = target.search || "";
+      hash = target.hash || "";
+    }
+    let resolved;
+    if (pathname === "") {
+      const currentPathname = router.location().pathname;
+      const normalizedBase = router.base === "/" || router.base === "" ? "" : router.base;
+      if (normalizedBase && !currentPathname.startsWith(normalizedBase)) {
+        return currentPathname + search + hash;
+      }
+      resolved = stripBasePath(currentPathname, router.base);
+    } else {
+      resolved = router.resolvePath(pathname);
+    }
+    const baseHref = prependBasePath(resolved, router.base);
+    return baseHref + search + hash;
+  };
+}
+function useIsActive(to, options) {
+  const router = useRouter();
+  return () => {
+    const target = typeof to === "function" ? to() : to;
+    const resolvedTargetPath = router.resolvePath(target);
+    const currentPath = router.location().pathname;
+    if (router.base && currentPath !== router.base && !currentPath.startsWith(router.base + "/")) {
+      return false;
+    }
+    const currentPathWithoutBase = stripBasePath(currentPath, router.base);
+    if (options?.end) {
+      return currentPathWithoutBase === resolvedTargetPath;
+    }
+    return currentPathWithoutBase === resolvedTargetPath || currentPathWithoutBase.startsWith(resolvedTargetPath + "/");
+  };
+}
+function useBeforeLeave(handler) {
+  const context = useBeforeLeaveContext();
+  const _cleanup = context.addHandler(handler);
+}
+
+// src/history.ts
+function createHistoryState(location, index) {
+  return {
+    usr: location.state,
+    key: location.key,
+    idx: index
+  };
+}
+function readLocation(state, url) {
+  const { pathname, search, hash } = parseURL(url);
+  return {
+    pathname,
+    search,
+    hash,
+    state: state?.usr ?? null,
+    key: state?.key ?? createKey()
+  };
+}
+function createBrowserHistory() {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "[fict-router] createBrowserHistory cannot be used in a server environment. Use createMemoryHistory or createStaticHistory for SSR."
+    );
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  const blockers = /* @__PURE__ */ new Set();
+  let action2 = "POP";
+  let location = readLocation(
+    window.history.state,
+    window.location.pathname + window.location.search + window.location.hash
+  );
+  let index = window.history.state?.idx ?? 0;
+  function handlePopState(event) {
+    const nextLocation = readLocation(
+      event.state,
+      window.location.pathname + window.location.search + window.location.hash
+    );
+    const nextAction = "POP";
+    const nextIndex = event.state?.idx ?? 0;
+    if (blockers.size > 0) {
+      let blocked = false;
+      const retry = () => {
+        window.history.go(nextIndex - index);
+      };
+      for (const blocker of blockers) {
+        blocker({
+          action: nextAction,
+          location: nextLocation,
+          retry
+        });
+        blocked = true;
+        break;
+      }
+      if (blocked) {
+        window.history.go(index - nextIndex);
+        return;
+      }
+    }
+    action2 = nextAction;
+    location = nextLocation;
+    index = nextIndex;
+    notifyListeners();
+  }
+  window.addEventListener("popstate", handlePopState);
+  function notifyListeners() {
+    for (const listener of listeners) {
+      listener({ action: action2, location });
+    }
+  }
+  function push(to, state) {
+    const nextLocation = createLocation(to, state);
+    const nextAction = "PUSH";
+    if (blockers.size > 0) {
+      let blocked = false;
+      const retry = () => push(to, state);
+      for (const blocker of blockers) {
+        blocker({
+          action: nextAction,
+          location: nextLocation,
+          retry
+        });
+        blocked = true;
+        break;
+      }
+      if (blocked) return;
+    }
+    action2 = nextAction;
+    location = nextLocation;
+    index++;
+    const historyState = createHistoryState(location, index);
+    window.history.pushState(historyState, "", createURL(location));
+    notifyListeners();
+  }
+  function replace(to, state) {
+    const nextLocation = createLocation(to, state);
+    const nextAction = "REPLACE";
+    if (blockers.size > 0) {
+      let blocked = false;
+      const retry = () => replace(to, state);
+      for (const blocker of blockers) {
+        blocker({
+          action: nextAction,
+          location: nextLocation,
+          retry
+        });
+        blocked = true;
+        break;
+      }
+      if (blocked) return;
+    }
+    action2 = nextAction;
+    location = nextLocation;
+    const historyState = createHistoryState(location, index);
+    window.history.replaceState(historyState, "", createURL(location));
+    notifyListeners();
+  }
+  function go(delta) {
+    window.history.go(delta);
+  }
+  if (window.history.state === null) {
+    const historyState = createHistoryState(location, index);
+    window.history.replaceState(historyState, "", createURL(location));
+  }
+  return {
+    get action() {
+      return action2;
+    },
+    get location() {
+      return location;
+    },
+    push,
+    replace,
+    go,
+    back() {
+      go(-1);
+    },
+    forward() {
+      go(1);
+    },
+    listen(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    createHref(to) {
+      const loc = typeof to === "string" ? parseURL(to) : to;
+      return createURL(loc);
+    },
+    block(blocker) {
+      blockers.add(blocker);
+      if (blockers.size === 1) {
+        window.addEventListener("beforeunload", handleBeforeUnload);
+      }
+      return () => {
+        blockers.delete(blocker);
+        if (blockers.size === 0) {
+          window.removeEventListener("beforeunload", handleBeforeUnload);
+        }
+      };
+    }
+  };
+}
+function handleBeforeUnload(event) {
+  event.preventDefault();
+  event.returnValue = "";
+}
+function createHashHistory(options = {}) {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "[fict-router] createHashHistory cannot be used in a server environment. Use createMemoryHistory or createStaticHistory for SSR."
+    );
+  }
+  const { hashType = "slash" } = options;
+  const listeners = /* @__PURE__ */ new Set();
+  const blockers = /* @__PURE__ */ new Set();
+  let action2 = "POP";
+  let location = readHashLocation();
+  let index = 0;
+  function readHashLocation() {
+    let hash = window.location.hash.slice(1);
+    if (hashType === "slash" && !hash.startsWith("/")) {
+      hash = "/" + hash;
+    } else if (hashType === "noslash" && hash.startsWith("/")) {
+      hash = hash.slice(1);
+    }
+    const { pathname, search, hash: innerHash } = parseURL(hash || "/");
+    return {
+      pathname: normalizePath(pathname),
+      search,
+      hash: innerHash,
+      state: window.history.state?.usr ?? null,
+      key: window.history.state?.key ?? createKey()
+    };
+  }
+  function createHashHref(location2) {
+    const url = createURL(location2);
+    if (hashType === "noslash") {
+      return "#" + url.slice(1);
+    }
+    return "#" + url;
+  }
+  function handleHashChange() {
+    const nextLocation = readHashLocation();
+    const nextAction = "POP";
+    if (blockers.size > 0) {
+      let blocked = false;
+      const retry = () => {
+        window.location.hash = createHashHref(nextLocation);
+      };
+      for (const blocker of blockers) {
+        blocker({
+          action: nextAction,
+          location: nextLocation,
+          retry
+        });
+        blocked = true;
+        break;
+      }
+      if (blocked) {
+        window.location.hash = createHashHref(location);
+        return;
+      }
+    }
+    action2 = nextAction;
+    location = nextLocation;
+    notifyListeners();
+  }
+  window.addEventListener("hashchange", handleHashChange);
+  function notifyListeners() {
+    for (const listener of listeners) {
+      listener({ action: action2, location });
+    }
+  }
+  function push(to, state) {
+    const nextLocation = createLocation(to, state);
+    const nextAction = "PUSH";
+    if (blockers.size > 0) {
+      let blocked = false;
+      const retry = () => push(to, state);
+      for (const blocker of blockers) {
+        blocker({
+          action: nextAction,
+          location: nextLocation,
+          retry
+        });
+        blocked = true;
+        break;
+      }
+      if (blocked) return;
+    }
+    action2 = nextAction;
+    location = nextLocation;
+    index++;
+    const historyState = createHistoryState(location, index);
+    window.history.pushState(historyState, "", createHashHref(location));
+    notifyListeners();
+  }
+  function replace(to, state) {
+    const nextLocation = createLocation(to, state);
+    const nextAction = "REPLACE";
+    if (blockers.size > 0) {
+      let blocked = false;
+      const retry = () => replace(to, state);
+      for (const blocker of blockers) {
+        blocker({
+          action: nextAction,
+          location: nextLocation,
+          retry
+        });
+        blocked = true;
+        break;
+      }
+      if (blocked) return;
+    }
+    action2 = nextAction;
+    location = nextLocation;
+    const historyState = createHistoryState(location, index);
+    window.history.replaceState(historyState, "", createHashHref(location));
+    notifyListeners();
+  }
+  function go(delta) {
+    window.history.go(delta);
+  }
+  return {
+    get action() {
+      return action2;
+    },
+    get location() {
+      return location;
+    },
+    push,
+    replace,
+    go,
+    back() {
+      go(-1);
+    },
+    forward() {
+      go(1);
+    },
+    listen(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    createHref(to) {
+      const loc = createLocation(to);
+      return createHashHref(loc);
+    },
+    block(blocker) {
+      blockers.add(blocker);
+      if (blockers.size === 1) {
+        window.addEventListener("beforeunload", handleBeforeUnload);
+      }
+      return () => {
+        blockers.delete(blocker);
+        if (blockers.size === 0) {
+          window.removeEventListener("beforeunload", handleBeforeUnload);
+        }
+      };
+    }
+  };
+}
+function createMemoryHistory(options = {}) {
+  const { initialEntries = ["/"], initialIndex } = options;
+  const listeners = /* @__PURE__ */ new Set();
+  const blockers = /* @__PURE__ */ new Set();
+  const entries = initialEntries.map((entry, i) => createLocation(entry, null, `${i}`));
+  let index = initialIndex ?? entries.length - 1;
+  let action2 = "POP";
+  index = Math.max(0, Math.min(index, entries.length - 1));
+  function notifyListeners() {
+    const location = entries[index];
+    for (const listener of listeners) {
+      listener({ action: action2, location });
+    }
+  }
+  function push(to, state) {
+    const nextLocation = createLocation(to, state);
+    const nextAction = "PUSH";
+    if (blockers.size > 0) {
+      let blocked = false;
+      const retry = () => push(to, state);
+      for (const blocker of blockers) {
+        blocker({
+          action: nextAction,
+          location: nextLocation,
+          retry
+        });
+        blocked = true;
+        break;
+      }
+      if (blocked) return;
+    }
+    action2 = nextAction;
+    entries.splice(index + 1);
+    entries.push(nextLocation);
+    index = entries.length - 1;
+    notifyListeners();
+  }
+  function replace(to, state) {
+    const nextLocation = createLocation(to, state);
+    const nextAction = "REPLACE";
+    if (blockers.size > 0) {
+      let blocked = false;
+      const retry = () => replace(to, state);
+      for (const blocker of blockers) {
+        blocker({
+          action: nextAction,
+          location: nextLocation,
+          retry
+        });
+        blocked = true;
+        break;
+      }
+      if (blocked) return;
+    }
+    action2 = nextAction;
+    entries[index] = nextLocation;
+    notifyListeners();
+  }
+  function go(delta) {
+    const nextIndex = Math.max(0, Math.min(index + delta, entries.length - 1));
+    if (nextIndex === index) return;
+    const nextLocation = entries[nextIndex];
+    const nextAction = "POP";
+    if (blockers.size > 0) {
+      let blocked = false;
+      const retry = () => go(delta);
+      for (const blocker of blockers) {
+        blocker({
+          action: nextAction,
+          location: nextLocation,
+          retry
+        });
+        blocked = true;
+        break;
+      }
+      if (blocked) return;
+    }
+    action2 = nextAction;
+    index = nextIndex;
+    notifyListeners();
+  }
+  return {
+    get action() {
+      return action2;
+    },
+    get location() {
+      return entries[index];
+    },
+    push,
+    replace,
+    go,
+    back() {
+      go(-1);
+    },
+    forward() {
+      go(1);
+    },
+    listen(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    createHref(to) {
+      const loc = typeof to === "string" ? parseURL(to) : to;
+      return createURL(loc);
+    },
+    block(blocker) {
+      blockers.add(blocker);
+      return () => blockers.delete(blocker);
+    }
+  };
+}
+function createStaticHistory(url) {
+  const location = createLocation(url);
+  return {
+    get action() {
+      return "POP";
+    },
+    get location() {
+      return location;
+    },
+    push() {
+      console.warn("[fict-router] Cannot push on static history (SSR)");
+    },
+    replace() {
+      console.warn("[fict-router] Cannot replace on static history (SSR)");
+    },
+    go() {
+      console.warn("[fict-router] Cannot go on static history (SSR)");
+    },
+    back() {
+    },
+    forward() {
+    },
+    listen() {
+      return () => {
+      };
+    },
+    createHref(to) {
+      const loc = typeof to === "string" ? parseURL(to) : to;
+      return createURL(loc);
+    },
+    block() {
+      return () => {
+      };
+    }
+  };
+}
+
+// src/scroll.ts
+var scrollPositions = /* @__PURE__ */ new Map();
+var MAX_STORED_POSITIONS = 100;
+function saveScrollPosition(key) {
+  if (!isBrowser()) return;
+  scrollPositions.set(key, {
+    x: window.scrollX,
+    y: window.scrollY
+  });
+  if (scrollPositions.size > MAX_STORED_POSITIONS) {
+    const firstKey = scrollPositions.keys().next().value;
+    if (firstKey) {
+      scrollPositions.delete(firstKey);
+    }
+  }
+}
+function clearScrollPosition(key) {
+  scrollPositions.delete(key);
+}
+function clearAllScrollPositions() {
+  scrollPositions.clear();
+}
+function scrollTo(x, y, behavior = "auto") {
+  if (!isBrowser()) return;
+  window.scrollTo({
+    left: x,
+    top: y,
+    behavior
+  });
+}
+function scrollToTop(behavior = "auto") {
+  scrollTo(0, 0, behavior);
+}
+function scrollToHash(hash, behavior = "auto") {
+  if (!isBrowser() || !hash) return false;
+  const id = hash.startsWith("#") ? hash.slice(1) : hash;
+  if (!id) return false;
+  const element = document.getElementById(id);
+  if (element) {
+    element.scrollIntoView({ behavior });
+    return true;
+  }
+  return false;
+}
+function restoreScrollPosition(key) {
+  if (!isBrowser()) return false;
+  const position = scrollPositions.get(key);
+  if (position) {
+    requestAnimationFrame(() => {
+      scrollTo(position.x, position.y);
+    });
+    return true;
+  }
+  return false;
+}
+var defaultOptions = {
+  enabled: true,
+  restoreOnPop: true,
+  scrollToTopOnPush: true,
+  behavior: "auto"
 };
+function createScrollRestoration(options = {}) {
+  const config = { ...defaultOptions, ...options };
+  if (isBrowser() && "scrollRestoration" in history) {
+    history.scrollRestoration = "manual";
+  }
+  function handleNavigation(from, to, action2) {
+    if (!config.enabled || !isBrowser()) return;
+    if (from?.key) {
+      saveScrollPosition(from.key);
+    }
+    if (action2 === "POP" && config.restoreOnPop) {
+      if (!restoreScrollPosition(to.key)) {
+        if (to.hash) {
+          requestAnimationFrame(() => {
+            if (!scrollToHash(to.hash, config.behavior)) {
+              scrollToTop(config.behavior);
+            }
+          });
+        } else {
+          scrollToTop(config.behavior);
+        }
+      }
+    } else if ((action2 === "PUSH" || action2 === "REPLACE") && config.scrollToTopOnPush) {
+      requestAnimationFrame(() => {
+        if (to.hash) {
+          if (!scrollToHash(to.hash, config.behavior)) {
+            scrollToTop(config.behavior);
+          }
+        } else {
+          scrollToTop(config.behavior);
+        }
+      });
+    }
+  }
+  function reset() {
+    if (isBrowser() && "scrollRestoration" in history) {
+      history.scrollRestoration = "auto";
+    }
+    clearAllScrollPositions();
+  }
+  return {
+    handleNavigation,
+    saveScrollPosition,
+    restoreScrollPosition,
+    scrollToTop: () => scrollToTop(config.behavior),
+    scrollToHash: (hash) => scrollToHash(hash, config.behavior),
+    reset,
+    config
+  };
+}
+var defaultScrollRestoration = null;
+function getScrollRestoration() {
+  if (!defaultScrollRestoration) {
+    defaultScrollRestoration = createScrollRestoration();
+  }
+  return defaultScrollRestoration;
+}
+function configureScrollRestoration(options) {
+  defaultScrollRestoration = createScrollRestoration(options);
+}
+
+// src/components.tsx
+var import_jsx_runtime = require("fict/jsx-runtime");
+var import_meta = {};
+var isDevEnv = typeof import_meta !== "undefined" && import_meta.env?.DEV === true || typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+var didWarnBaseMismatch = false;
+function hasBasePrefix(pathname, base) {
+  if (!base) return true;
+  return pathname === base || pathname.startsWith(base + "/");
+}
+function stripBaseOrWarn(pathname, base) {
+  if (!base) return pathname;
+  if (!hasBasePrefix(pathname, base)) {
+    if (isDevEnv && !didWarnBaseMismatch) {
+      didWarnBaseMismatch = true;
+      console.warn(
+        `[fict-router] Location "${pathname}" does not start with base "${base}". No routes matched.`
+      );
+    }
+    return null;
+  }
+  return stripBasePath(pathname, base);
+}
+function stripBaseIfPresent(pathname, base) {
+  if (!base) return pathname;
+  if (hasBasePrefix(pathname, base)) {
+    return stripBasePath(pathname, base);
+  }
+  return pathname;
+}
+function createRouterState(history2, routes, base = "") {
+  const normalizedBase = normalizePath(base);
+  const baseForStrip = normalizedBase === "/" ? "" : normalizedBase;
+  const compiledRoutes = routes.map((r) => compileRoute(r));
+  const branches = createBranches(compiledRoutes);
+  const matchWithBase = (pathname) => {
+    const strippedPath = stripBaseOrWarn(pathname, baseForStrip);
+    if (strippedPath == null) return [];
+    return matchRoutes(branches, strippedPath) || [];
+  };
+  const initialLocation = history2.location;
+  const initialMatches = matchWithBase(initialLocation.pathname);
+  const locationSignal = (0, import_advanced.createSignal)(initialLocation);
+  const matchesSignal = (0, import_advanced.createSignal)(initialMatches);
+  const isRoutingSignal = (0, import_advanced.createSignal)(false);
+  const pendingLocationSignal = (0, import_advanced.createSignal)(null);
+  const beforeLeaveHandlers = /* @__PURE__ */ new Set();
+  let navigationToken = 0;
+  const beforeLeave = {
+    addHandler(handler) {
+      beforeLeaveHandlers.add(handler);
+      return () => beforeLeaveHandlers.delete(handler);
+    },
+    async confirm(to, from) {
+      if (beforeLeaveHandlers.size === 0) return true;
+      const currentToken = ++navigationToken;
+      let defaultPrevented = false;
+      let retryRequested = false;
+      let forceRetry = false;
+      const event = {
+        to,
+        from,
+        get defaultPrevented() {
+          return defaultPrevented;
+        },
+        preventDefault() {
+          defaultPrevented = true;
+        },
+        retry(force) {
+          retryRequested = true;
+          forceRetry = force ?? false;
+        }
+      };
+      for (const handler of beforeLeaveHandlers) {
+        await handler(event);
+        if (currentToken !== navigationToken) {
+          return false;
+        }
+        if (defaultPrevented && !retryRequested) {
+          return false;
+        }
+        if (retryRequested && forceRetry) {
+          return true;
+        }
+      }
+      if (currentToken !== navigationToken) {
+        return false;
+      }
+      return !defaultPrevented || retryRequested;
+    }
+  };
+  const navigate = (toOrDelta, options) => {
+    if (typeof toOrDelta === "number") {
+      history2.go(toOrDelta);
+      return;
+    }
+    const currentLocation = locationSignal();
+    const to = toOrDelta;
+    let toPathname;
+    let toSearch = "";
+    let toHash = "";
+    if (typeof to === "string") {
+      let remaining = to;
+      const hashIndex = remaining.indexOf("#");
+      if (hashIndex >= 0) {
+        toHash = remaining.slice(hashIndex);
+        remaining = remaining.slice(0, hashIndex);
+      }
+      const searchIndex = remaining.indexOf("?");
+      if (searchIndex >= 0) {
+        toSearch = remaining.slice(searchIndex);
+        remaining = remaining.slice(0, searchIndex);
+      }
+      toPathname = remaining;
+    } else {
+      toPathname = to.pathname || "";
+      toSearch = to.search || "";
+      toHash = to.hash || "";
+    }
+    let targetPath;
+    const currentPathWithoutBase = stripBaseOrWarn(currentLocation.pathname, baseForStrip) || "/";
+    if (typeof to === "string") {
+      if (toPathname === "") {
+        targetPath = currentPathWithoutBase;
+      } else if (options?.relative === "route") {
+        const matches = matchesSignal();
+        const currentMatch = matches[matches.length - 1];
+        const currentRoutePath = currentMatch?.pathname || currentPathWithoutBase;
+        targetPath = resolvePath(currentRoutePath, toPathname);
+      } else {
+        targetPath = toPathname.startsWith("/") ? stripBaseIfPresent(toPathname, baseForStrip) : resolvePath(currentPathWithoutBase, toPathname);
+      }
+    } else {
+      const rawTargetPath = toPathname || currentPathWithoutBase;
+      targetPath = stripBaseIfPresent(rawTargetPath, baseForStrip);
+    }
+    const toState = typeof to === "object" ? to.state : void 0;
+    const toKey = typeof to === "object" ? to.key : void 0;
+    const finalState = options?.state !== void 0 ? options.state : toState;
+    const targetPathWithBase = prependBasePath(targetPath, baseForStrip);
+    const locationSpec = {
+      pathname: targetPathWithBase,
+      search: toSearch,
+      hash: toHash
+    };
+    if (finalState !== void 0) {
+      locationSpec.state = finalState;
+    }
+    if (toKey !== void 0) {
+      locationSpec.key = toKey;
+    }
+    const targetLocation = createLocation(locationSpec, finalState, toKey);
+    (0, import_runtime2.untrack)(async () => {
+      const canNavigate = await beforeLeave.confirm(targetLocation, currentLocation);
+      if (!canNavigate) {
+        pendingLocationSignal(null);
+        return;
+      }
+      (0, import_runtime2.batch)(() => {
+        isRoutingSignal(true);
+        pendingLocationSignal(targetLocation);
+      });
+      (0, import_runtime2.startTransition)(() => {
+        const prevLocation = history2.location;
+        if (options?.replace) {
+          history2.replace(targetLocation, finalState);
+        } else {
+          history2.push(targetLocation, finalState);
+        }
+        if (options?.scroll !== false && isBrowser()) {
+          const scrollRestoration = getScrollRestoration();
+          scrollRestoration.handleNavigation(
+            prevLocation,
+            history2.location,
+            options?.replace ? "REPLACE" : "PUSH"
+          );
+        }
+        if (locationsAreEqual(prevLocation, history2.location)) {
+          (0, import_runtime2.batch)(() => {
+            isRoutingSignal(false);
+            pendingLocationSignal(null);
+          });
+        }
+      });
+    });
+  };
+  const unlisten = history2.listen(({ action: action2, location: newLocation }) => {
+    const prevLocation = locationSignal();
+    (0, import_runtime2.batch)(() => {
+      locationSignal(newLocation);
+      const newMatches = matchWithBase(newLocation.pathname);
+      matchesSignal(newMatches);
+      isRoutingSignal(false);
+      pendingLocationSignal(null);
+    });
+    if (action2 === "POP" && isBrowser()) {
+      const scrollRestoration = getScrollRestoration();
+      scrollRestoration.handleNavigation(prevLocation, newLocation, "POP");
+    }
+  });
+  const state = () => ({
+    location: locationSignal(),
+    matches: matchesSignal(),
+    isRouting: isRoutingSignal(),
+    pendingLocation: pendingLocationSignal()
+  });
+  return {
+    state,
+    navigate,
+    beforeLeave,
+    cleanup: unlisten,
+    normalizedBase: baseForStrip
+  };
+}
+function RouterProvider(props) {
+  const { state, navigate, beforeLeave, cleanup, normalizedBase } = createRouterState(
+    props.history,
+    props.routes,
+    props.base
+  );
+  (0, import_runtime2.onCleanup)(cleanup);
+  const routerContext = {
+    location: () => state().location,
+    params: () => {
+      const matches = state().matches;
+      const allParams = {};
+      for (const match of matches) {
+        Object.assign(allParams, match.params);
+      }
+      return allParams;
+    },
+    matches: () => state().matches,
+    navigate,
+    isRouting: () => state().isRouting,
+    pendingLocation: () => state().pendingLocation,
+    base: normalizedBase,
+    resolvePath: (to) => {
+      const location = state().location;
+      const currentPathWithoutBase = stripBaseOrWarn(location.pathname, normalizedBase) || "/";
+      const rawTargetPath = typeof to === "string" ? to : to.pathname || "/";
+      const targetPath = rawTargetPath.startsWith("/") ? stripBaseIfPresent(rawTargetPath, normalizedBase) : rawTargetPath;
+      return resolvePath(currentPathWithoutBase, targetPath);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RouterContext.Provider, { value: routerContext, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BeforeLeaveContext.Provider, { value: beforeLeave, children: props.children }) });
+}
+function Router(props) {
+  const history2 = props.history || createBrowserHistory();
+  const routes = extractRoutes(props.children);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RouterProvider, { history: history2, routes, base: props.base, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Routes, { children: props.children }) });
+}
+function HashRouter(props) {
+  const hashOptions = props.hashType ? { hashType: props.hashType } : void 0;
+  const history2 = createHashHistory(hashOptions);
+  const routes = extractRoutes(props.children);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RouterProvider, { history: history2, routes, base: props.base, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Routes, { children: props.children }) });
+}
+function MemoryRouter(props) {
+  const memoryOptions = {};
+  if (props.initialEntries !== void 0) {
+    memoryOptions.initialEntries = props.initialEntries;
+  }
+  if (props.initialIndex !== void 0) {
+    memoryOptions.initialIndex = props.initialIndex;
+  }
+  const history2 = createMemoryHistory(
+    Object.keys(memoryOptions).length > 0 ? memoryOptions : void 0
+  );
+  const routes = extractRoutes(props.children);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RouterProvider, { history: history2, routes, base: props.base, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Routes, { children: props.children }) });
+}
+function StaticRouter(props) {
+  const history2 = createStaticHistory(props.url);
+  const routes = extractRoutes(props.children);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RouterProvider, { history: history2, routes, base: props.base, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Routes, { children: props.children }) });
+}
+function Routes(props) {
+  const router = useRouter();
+  const parentRoute = useRoute();
+  const routes = extractRoutes(props.children);
+  const compiledRoutes = routes.map((r) => compileRoute(r));
+  const branches = createBranches(compiledRoutes);
+  const currentMatches = (0, import_runtime2.createMemo)(() => {
+    const location = router.location();
+    const parentMatch = parentRoute.match();
+    const locationPath = stripBaseOrWarn(location.pathname, router.base);
+    if (locationPath == null) return [];
+    let basePath = "/";
+    if (parentMatch) {
+      basePath = parentMatch.pathname;
+    }
+    const relativePath = locationPath.startsWith(basePath) ? locationPath.slice(basePath.length) || "/" : locationPath;
+    return matchRoutes(branches, relativePath) || [];
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: renderMatches(currentMatches(), 0) });
+}
+function renderMatches(matches, index) {
+  if (index >= matches.length) {
+    return null;
+  }
+  const match = matches[index];
+  const route = match.route;
+  const router = useRouter();
+  const dataState = (0, import_advanced.createSignal)({
+    data: void 0,
+    error: void 0,
+    loading: !!route.preload
+  });
+  let preloadToken = 0;
+  if (route.preload) {
+    (0, import_runtime2.createEffect)(() => {
+      const location = router.location();
+      const preloadArgs = {
+        params: match.params,
+        location,
+        intent: "navigate"
+      };
+      const currentToken = ++preloadToken;
+      dataState({ data: void 0, error: void 0, loading: true });
+      Promise.resolve(route.preload(preloadArgs)).then((result) => {
+        if (currentToken === preloadToken) {
+          dataState({ data: result, error: void 0, loading: false });
+        }
+      }).catch((error) => {
+        if (currentToken === preloadToken) {
+          dataState({ data: void 0, error, loading: false });
+        }
+      });
+    });
+  }
+  const routeContext = {
+    match: () => match,
+    data: () => dataState().data,
+    error: () => dataState().error,
+    outlet: () => renderMatches(matches, index + 1),
+    resolvePath: (to) => {
+      const basePath = match.pathname;
+      const targetPath = typeof to === "string" ? to : to.pathname || "/";
+      return resolvePath(basePath, targetPath);
+    }
+  };
+  const renderContent = () => {
+    const state = dataState();
+    if (state.error !== void 0 && route.errorElement) {
+      return route.errorElement;
+    }
+    if (state.loading && route.loadingElement) {
+      return route.loadingElement;
+    }
+    if (route.component) {
+      const Component = route.component;
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { params: match.params, location: router.location(), data: state.data, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Outlet, {}) });
+    } else if (route.element) {
+      return route.element;
+    } else if (route.children) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Outlet, {});
+    }
+    return null;
+  };
+  let content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RouteContext.Provider, { value: routeContext, children: renderContent() });
+  if (route.errorElement) {
+    content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_runtime2.ErrorBoundary,
+      {
+        fallback: (err, reset) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RouteErrorContext.Provider, { value: { error: err, reset }, children: route.errorElement }),
+        children: content
+      }
+    );
+  }
+  if (route.loadingElement) {
+    content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_runtime2.Suspense, { fallback: route.loadingElement, children: content });
+  }
+  return content;
+}
+function Route(_props) {
+  return null;
+}
+function Outlet() {
+  const route = useRoute();
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: route.outlet() });
+}
+function Navigate(props) {
+  const router = useRouter();
+  (0, import_runtime2.createEffect)(() => {
+    router.navigate(props.to, {
+      replace: props.replace ?? true,
+      state: props.state
+    });
+  });
+  return null;
+}
+function Redirect(props) {
+  const router = useRouter();
+  (0, import_runtime2.createEffect)(() => {
+    router.navigate(props.to, {
+      replace: props.push !== true,
+      // Replace by default, push only if explicitly requested
+      state: props.state
+    });
+  });
+  return null;
+}
+function extractRoutes(children) {
+  const routes = [];
+  if (children == null) return routes;
+  const childArray = Array.isArray(children) ? children : [children];
+  for (const child of childArray) {
+    if (child == null || typeof child !== "object") continue;
+    const vnode = child;
+    if (vnode.type === Route) {
+      const props = vnode.props || {};
+      const routeDef = {};
+      if (props.path !== void 0) routeDef.path = props.path;
+      if (props.component !== void 0) routeDef.component = props.component;
+      if (props.element !== void 0) routeDef.element = props.element;
+      if (props.index !== void 0) routeDef.index = props.index;
+      if (props.preload !== void 0)
+        routeDef.preload = props.preload;
+      if (props.errorElement !== void 0) routeDef.errorElement = props.errorElement;
+      if (props.loadingElement !== void 0)
+        routeDef.loadingElement = props.loadingElement;
+      if (props.children) routeDef.children = extractRoutes(props.children);
+      routes.push(routeDef);
+    } else if (vnode.type === import_runtime2.Fragment && vnode.props?.children) {
+      routes.push(...extractRoutes(vnode.props.children));
+    }
+  }
+  return routes;
+}
+function createRoutes(routes) {
+  return routes;
+}
+function createRouter(routes, options) {
+  return {
+    Router: (props) => {
+      const history2 = options?.history || createBrowserHistory();
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RouterProvider, { history: history2, routes, base: options?.base, children: props.children || /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Routes, { children: routesToElements(routes) }) });
+    }
+  };
+}
+function routesToElements(routes) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: routes.map((route, i) => {
+    const routeProps = { key: route.key || `route-${i}` };
+    if (route.path !== void 0) routeProps.path = route.path;
+    if (route.component !== void 0) routeProps.component = route.component;
+    if (route.element !== void 0) routeProps.element = route.element;
+    if (route.index !== void 0) routeProps.index = route.index;
+    if (route.children) routeProps.children = routesToElements(route.children);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Route, { ...routeProps });
+  }) });
+}
+
+// src/link.tsx
+var import_runtime3 = require("@fictjs/runtime");
+var import_jsx_runtime2 = require("fict/jsx-runtime");
+function Link(props) {
+  const router = useRouter();
+  const href = useHref(() => props.to);
+  let preloadTriggered = false;
+  const handleClick = (event) => {
+    if (props.onClick) {
+      props.onClick(event);
+    }
+    if (event.defaultPrevented) return;
+    if (event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) return;
+    if (event.button !== 0) return;
+    if (props.reloadDocument) return;
+    if (props.disabled) return;
+    const target = event.currentTarget.target;
+    if (target && target !== "_self") return;
+    event.preventDefault();
+    const options = {
+      replace: props.replace,
+      state: props.state,
+      scroll: props.scroll,
+      relative: props.relative
+    };
+    router.navigate(props.to, options);
+  };
+  const triggerPreload = () => {
+    if (preloadTriggered || props.disabled || props.prefetch === "none") return;
+    preloadTriggered = true;
+    const hrefValue = href();
+    if (typeof window !== "undefined" && window.dispatchEvent) {
+      window.dispatchEvent(
+        new CustomEvent("fict-router:preload", {
+          detail: { href: hrefValue, to: props.to }
+        })
+      );
+    }
+  };
+  const handleMouseEnter = (event) => {
+    if (props.prefetch === "intent" || props.prefetch === void 0) {
+      triggerPreload();
+    }
+    const onMouseEnter = props.onMouseEnter;
+    if (onMouseEnter) onMouseEnter(event);
+  };
+  const handleFocus = (event) => {
+    if (props.prefetch === "intent" || props.prefetch === void 0) {
+      triggerPreload();
+    }
+    const onFocus = props.onFocus;
+    if (onFocus) onFocus(event);
+  };
+  const {
+    to: _to,
+    replace: _replace,
+    state: _state,
+    scroll: _scroll,
+    relative: _relative,
+    reloadDocument: _reloadDocument,
+    prefetch,
+    disabled,
+    onClick: _onClick,
+    children,
+    ...anchorProps
+  } = props;
+  if (disabled) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { ...anchorProps, children });
+  }
+  if (prefetch === "render") {
+    triggerPreload();
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "a",
+    {
+      ...anchorProps,
+      href: href(),
+      onClick: handleClick,
+      onMouseEnter: handleMouseEnter,
+      onFocus: handleFocus,
+      children
+    }
+  );
+}
+function NavLink(props) {
+  const router = useRouter();
+  const isActive = useIsActive(() => props.to, { end: props.end });
+  const href = useHref(() => props.to);
+  const pendingLocation = usePendingLocation();
+  const computeIsPending = () => {
+    const pending = pendingLocation();
+    if (!pending) return false;
+    const resolvedHref = href();
+    const baseToStrip = router.base === "/" ? "" : router.base;
+    const pendingPathWithoutBase = stripBasePath(pending.pathname, baseToStrip);
+    const parsed = parseURL(resolvedHref);
+    const targetPathWithoutBase = stripBasePath(parsed.pathname, baseToStrip);
+    if (props.end) {
+      return pendingPathWithoutBase === targetPathWithoutBase;
+    }
+    return pendingPathWithoutBase === targetPathWithoutBase || pendingPathWithoutBase.startsWith(targetPathWithoutBase + "/");
+  };
+  const getRenderProps = () => ({
+    isActive: isActive(),
+    isPending: computeIsPending(),
+    isTransitioning: router.isRouting()
+  });
+  const computedClassName = (0, import_runtime3.createMemo)(() => {
+    const renderProps = getRenderProps();
+    const classes = [];
+    if (typeof props.className === "function") {
+      const result = props.className(renderProps);
+      if (result) classes.push(result);
+    } else if (props.className) {
+      classes.push(props.className);
+    }
+    if (renderProps.isActive && props.activeClassName) {
+      classes.push(props.activeClassName);
+    }
+    if (renderProps.isPending && props.pendingClassName) {
+      classes.push(props.pendingClassName);
+    }
+    return classes.join(" ") || void 0;
+  });
+  const computedStyle = (0, import_runtime3.createMemo)(() => {
+    const renderProps = getRenderProps();
+    const style = {};
+    if (typeof props.style === "function") {
+      const result = props.style(renderProps);
+      if (result) Object.assign(style, result);
+    } else if (props.style) {
+      Object.assign(style, props.style);
+    }
+    if (renderProps.isActive && props.activeStyle) {
+      Object.assign(style, props.activeStyle);
+    }
+    if (renderProps.isPending && props.pendingStyle) {
+      Object.assign(style, props.pendingStyle);
+    }
+    return Object.keys(style).length > 0 ? style : void 0;
+  });
+  const computedChildren = (0, import_runtime3.createMemo)(() => {
+    const renderProps = getRenderProps();
+    if (typeof props.children === "function") {
+      return props.children(renderProps);
+    }
+    return props.children;
+  });
+  const ariaCurrent = (0, import_runtime3.createMemo)(() => {
+    const renderProps = getRenderProps();
+    if (!renderProps.isActive) return void 0;
+    return props["aria-current"] || "page";
+  });
+  const handleClick = (event) => {
+    if (props.onClick) {
+      props.onClick(event);
+    }
+    if (event.defaultPrevented) return;
+    if (event.metaKey || event.altKey || event.ctrlKey || event.shiftKey) return;
+    if (event.button !== 0) return;
+    if (props.reloadDocument) return;
+    if (props.disabled) return;
+    const target = event.currentTarget.target;
+    if (target && target !== "_self") return;
+    event.preventDefault();
+    router.navigate(props.to, {
+      replace: props.replace,
+      state: props.state,
+      scroll: props.scroll,
+      relative: props.relative
+    });
+  };
+  const {
+    to: _to,
+    replace: _replace,
+    state: _state,
+    scroll: _scroll,
+    relative: _relative,
+    reloadDocument: _reloadDocument,
+    prefetch: _prefetch,
+    disabled,
+    onClick: _onClick,
+    children: _children,
+    className: _className,
+    style: _style,
+    end: _end,
+    caseSensitive: _caseSensitive,
+    activeClassName: _activeClassName,
+    pendingClassName: _pendingClassName,
+    activeStyle: _activeStyle,
+    pendingStyle: _pendingStyle,
+    "aria-current": _ariaCurrent,
+    ...anchorProps
+  } = props;
+  if (disabled) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { ...anchorProps, className: computedClassName(), style: computedStyle(), children: computedChildren() });
+  }
+  const finalClassName = computedClassName();
+  const finalStyle = computedStyle();
+  const finalAriaCurrent = ariaCurrent();
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "a",
+    {
+      ...anchorProps,
+      href: href(),
+      ...finalClassName !== void 0 ? { className: finalClassName } : {},
+      ...finalStyle !== void 0 ? { style: finalStyle } : {},
+      ...finalAriaCurrent !== void 0 ? { "aria-current": finalAriaCurrent } : {},
+      onClick: handleClick,
+      children: computedChildren()
+    }
+  );
+}
+function Form(props) {
+  const router = useRouter();
+  const handleSubmit = (event) => {
+    if (props.onSubmit) {
+      props.onSubmit(event);
+    }
+    if (event.defaultPrevented) return;
+    const form = event.currentTarget;
+    const target = form.target;
+    if (target && target !== "_self") return;
+    event.preventDefault();
+    const formData = new FormData(form);
+    const method2 = props.method?.toUpperCase() || "GET";
+    const actionUrl = props.action || router.location().pathname;
+    if (method2 === "GET") {
+      const searchParams = new URLSearchParams();
+      formData.forEach((value, key) => {
+        if (typeof value === "string") {
+          searchParams.append(key, value);
+        }
+      });
+      router.navigate(
+        {
+          pathname: actionUrl,
+          search: "?" + searchParams.toString()
+        },
+        { replace: props.replace }
+      );
+    } else {
+      submitFormAction(form, actionUrl, method2, formData, {
+        navigate: props.navigate !== false,
+        replace: props.replace ?? false,
+        router
+      });
+    }
+  };
+  async function submitFormAction(formElement, url, method2, formData, options) {
+    try {
+      const response = await fetch(url, {
+        method: method2,
+        body: formData,
+        headers: {
+          // Let the browser set Content-Type for FormData (includes boundary)
+          Accept: "application/json"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const contentType = response.headers.get("Content-Type");
+      let data = null;
+      if (contentType?.includes("application/json")) {
+        data = await response.json();
+      }
+      const redirectUrl = response.headers.get("X-Redirect") || response.headers.get("Location");
+      if (options.navigate && redirectUrl) {
+        options.router.navigate(redirectUrl, { replace: options.replace });
+      }
+      formElement.dispatchEvent(
+        new CustomEvent("formsubmit", {
+          bubbles: true,
+          detail: { data, response }
+        })
+      );
+      return { data, response };
+    } catch (error) {
+      formElement.dispatchEvent(
+        new CustomEvent("formerror", {
+          bubbles: true,
+          detail: { error }
+        })
+      );
+      console.error("[fict-router] Form submission failed:", error);
+      throw error;
+    }
+  }
+  const {
+    action: action2,
+    method,
+    replace: _replace,
+    relative: _relative,
+    preventScrollReset: _preventScrollReset,
+    navigate: _navigate,
+    fetcherKey: _fetcherKey,
+    children,
+    onSubmit: _onSubmit,
+    ...formProps
+  } = props;
+  const htmlMethod = method && ["get", "post"].includes(method) ? method : void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "form",
+    {
+      ...formProps,
+      ...action2 !== void 0 ? { action: action2 } : {},
+      ...htmlMethod !== void 0 ? { method: htmlMethod } : {},
+      onSubmit: handleSubmit,
+      children
+    }
+  );
+}
+
+// src/data.ts
+var import_runtime4 = require("@fictjs/runtime");
+var import_advanced2 = require("@fictjs/runtime/advanced");
+var CACHE_DURATION = 3 * 60 * 1e3;
+var PRELOAD_CACHE_DURATION = 5 * 1e3;
+var MAX_CACHE_SIZE = 500;
+var NORMAL_CLEANUP_INTERVAL = 60 * 1e3;
+var FAST_CLEANUP_INTERVAL = 10 * 1e3;
+var queryCache = /* @__PURE__ */ new Map();
+var cacheCleanupTimer;
+var currentCleanupInterval = NORMAL_CLEANUP_INTERVAL;
+function evictOldestEntries() {
+  if (queryCache.size <= MAX_CACHE_SIZE) return;
+  const entries = Array.from(queryCache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
+  const toRemove = queryCache.size - MAX_CACHE_SIZE;
+  for (let i = 0; i < toRemove && i < entries.length; i++) {
+    queryCache.delete(entries[i][0]);
+  }
+}
+function runCacheCleanup() {
+  const now = Date.now();
+  for (const [key, entry] of queryCache) {
+    const maxAge = entry.intent === "preload" ? PRELOAD_CACHE_DURATION : CACHE_DURATION;
+    if (now - entry.timestamp > maxAge) {
+      queryCache.delete(key);
+    }
+  }
+  const newInterval = queryCache.size > MAX_CACHE_SIZE / 2 ? FAST_CLEANUP_INTERVAL : NORMAL_CLEANUP_INTERVAL;
+  if (newInterval !== currentCleanupInterval) {
+    currentCleanupInterval = newInterval;
+    stopCacheCleanup();
+    startCacheCleanup();
+  }
+}
+function startCacheCleanup() {
+  if (cacheCleanupTimer) return;
+  cacheCleanupTimer = setInterval(runCacheCleanup, currentCleanupInterval);
+}
+function stopCacheCleanup() {
+  if (cacheCleanupTimer) {
+    clearInterval(cacheCleanupTimer);
+    cacheCleanupTimer = void 0;
+  }
+}
+function query(fn, name) {
+  startCacheCleanup();
+  return (...args) => {
+    const cacheKey = `${name}:${hashParams(args)}`;
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.result !== void 0) {
+      const maxAge = cached.intent === "preload" ? PRELOAD_CACHE_DURATION : CACHE_DURATION;
+      if (Date.now() - cached.timestamp < maxAge) {
+        return () => cached.result;
+      }
+    }
+    const resultSignal = (0, import_advanced2.createSignal)(cached?.result);
+    const errorSignal = (0, import_advanced2.createSignal)(void 0);
+    const loadingSignal = (0, import_advanced2.createSignal)(true);
+    const promise = Promise.resolve(fn(...args)).then((result) => {
+      const entry = {
+        timestamp: Date.now(),
+        promise,
+        result,
+        intent: "navigate"
+      };
+      queryCache.set(cacheKey, entry);
+      evictOldestEntries();
+      (0, import_runtime4.batch)(() => {
+        resultSignal(result);
+        loadingSignal(false);
+      });
+      return result;
+    }).catch((error) => {
+      (0, import_runtime4.batch)(() => {
+        errorSignal(error);
+        loadingSignal(false);
+      });
+      throw error;
+    });
+    if (!cached) {
+      queryCache.set(cacheKey, {
+        timestamp: Date.now(),
+        promise,
+        intent: "navigate"
+      });
+    }
+    return () => resultSignal();
+  };
+}
+function revalidate(keys) {
+  if (!keys) {
+    queryCache.clear();
+    return;
+  }
+  if (typeof keys === "string") {
+    for (const cacheKey of queryCache.keys()) {
+      if (cacheKey.startsWith(keys)) {
+        queryCache.delete(cacheKey);
+      }
+    }
+    return;
+  }
+  if (Array.isArray(keys)) {
+    for (const key of keys) {
+      for (const cacheKey of queryCache.keys()) {
+        if (cacheKey.startsWith(key)) {
+          queryCache.delete(cacheKey);
+        }
+      }
+    }
+    return;
+  }
+  if (keys instanceof RegExp) {
+    for (const cacheKey of queryCache.keys()) {
+      if (keys.test(cacheKey)) {
+        queryCache.delete(cacheKey);
+      }
+    }
+  }
+}
+var actionRegistry = /* @__PURE__ */ new Map();
+var submissionCounter = 0;
+function action(fn, name) {
+  const actionName = name || `action-${++submissionCounter}`;
+  const actionUrl = `/_action/${actionName}`;
+  actionRegistry.set(actionUrl, fn);
+  return {
+    url: actionUrl,
+    name: actionName,
+    submit: async (formData) => {
+      const baseUrl = typeof window !== "undefined" && window.location ? window.location.origin : "http://localhost";
+      const request = new Request(new URL(actionUrl, baseUrl).href, {
+        method: "POST",
+        body: formData
+      });
+      return fn(formData, { params: {}, request });
+    }
+  };
+}
+function getAction(url) {
+  return actionRegistry.get(url);
+}
+var activeSubmissions = (0, import_advanced2.createSignal)(/* @__PURE__ */ new Map());
+function useSubmission(actionOrUrl) {
+  const url = typeof actionOrUrl === "string" ? actionOrUrl : actionOrUrl.url;
+  return () => {
+    const submissions = activeSubmissions();
+    return submissions.get(url);
+  };
+}
+function useSubmissions() {
+  return () => Array.from(activeSubmissions().values());
+}
+async function submitAction(action2, formData, params = {}) {
+  const key = `submission-${++submissionCounter}`;
+  const submission = {
+    key,
+    formData,
+    state: "submitting",
+    clear: () => {
+      const submissions2 = new Map(activeSubmissions());
+      submissions2.delete(action2.url);
+      activeSubmissions(submissions2);
+    },
+    retry: () => {
+      submitAction(action2, formData, params);
+    }
+  };
+  const submissions = new Map(activeSubmissions());
+  submissions.set(action2.url, submission);
+  activeSubmissions(submissions);
+  try {
+    const result = await action2.submit(formData);
+    submission.result = result;
+    submission.state = "idle";
+    const updatedSubmissions = new Map(activeSubmissions());
+    updatedSubmissions.set(action2.url, submission);
+    activeSubmissions(updatedSubmissions);
+    return result;
+  } catch (error) {
+    submission.error = error;
+    submission.state = "idle";
+    const updatedSubmissions = new Map(activeSubmissions());
+    updatedSubmissions.set(action2.url, submission);
+    activeSubmissions(updatedSubmissions);
+    throw error;
+  }
+}
+function preloadQuery(queryFn, ...args) {
+  queryFn(...args);
+}
+function createPreload(fn) {
+  return async (args) => {
+    return fn(args);
+  };
+}
+function createResource(source, fetcher) {
+  const dataSignal = (0, import_advanced2.createSignal)(void 0);
+  const loadingSignal = (0, import_advanced2.createSignal)(true);
+  const errorSignal = (0, import_advanced2.createSignal)(void 0);
+  const latestSignal = (0, import_advanced2.createSignal)(void 0);
+  let currentSource;
+  let fetchId = 0;
+  const doFetch = async (s, id) => {
+    loadingSignal(true);
+    errorSignal(void 0);
+    try {
+      const result = await fetcher(s);
+      if (id === fetchId) {
+        (0, import_runtime4.batch)(() => {
+          dataSignal(result);
+          latestSignal(result);
+          loadingSignal(false);
+        });
+        return result;
+      }
+      return void 0;
+    } catch (err) {
+      if (id === fetchId) {
+        (0, import_runtime4.batch)(() => {
+          errorSignal(err);
+          loadingSignal(false);
+        });
+      }
+      return void 0;
+    }
+  };
+  (0, import_runtime4.createEffect)(() => {
+    const s = source();
+    if (s !== currentSource) {
+      currentSource = s;
+      const currentFetchId = ++fetchId;
+      doFetch(s, currentFetchId);
+    }
+  });
+  const resource = (() => dataSignal());
+  resource.loading = () => loadingSignal();
+  resource.error = () => errorSignal();
+  resource.latest = () => latestSignal();
+  resource.refetch = () => {
+    const currentFetchId = ++fetchId;
+    return doFetch(currentSource, currentFetchId);
+  };
+  return resource;
+}
+function cleanupDataUtilities() {
+  stopCacheCleanup();
+  queryCache.clear();
+  actionRegistry.clear();
+  activeSubmissions(/* @__PURE__ */ new Map());
+}
+
+// src/lazy.tsx
+var import_runtime5 = require("@fictjs/runtime");
+var import_advanced3 = require("@fictjs/runtime/advanced");
+var import_jsx_runtime3 = require("fict/jsx-runtime");
+function lazy(loader) {
+  let cachedComponent = null;
+  let loadPromise = null;
+  const LazyComponent = (props) => {
+    const state = (0, import_advanced3.createSignal)({
+      component: cachedComponent,
+      error: null,
+      loading: !cachedComponent
+    });
+    if (cachedComponent) {
+      const CachedComponent = cachedComponent;
+      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(CachedComponent, { ...props });
+    }
+    if (!loadPromise) {
+      loadPromise = loader().then((module2) => {
+        const component = "default" in module2 ? module2.default : module2;
+        cachedComponent = component;
+        return component;
+      });
+    }
+    loadPromise.then((component) => {
+      state({ component, error: null, loading: false });
+    }).catch((error) => {
+      state({ component: null, error, loading: false });
+    });
+    const currentState = state();
+    if (currentState.error) {
+      throw currentState.error;
+    }
+    if (currentState.loading || !currentState.component) {
+      throw loadPromise;
+    }
+    const LoadedComponent = currentState.component;
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(LoadedComponent, { ...props });
+  };
+  LazyComponent.__lazy = true;
+  LazyComponent.__preload = () => {
+    if (!loadPromise) {
+      loadPromise = loader().then((module2) => {
+        const component = "default" in module2 ? module2.default : module2;
+        cachedComponent = component;
+        return component;
+      });
+    }
+    return loadPromise;
+  };
+  return LazyComponent;
+}
+function preloadLazy(component) {
+  const lazyComp = component;
+  if (lazyComp.__lazy && lazyComp.__preload) {
+    return lazyComp.__preload();
+  }
+  return Promise.resolve();
+}
+function isLazyComponent(component) {
+  return !!(component && typeof component === "function" && component.__lazy);
+}
+function lazyRoute(config) {
+  const LazyComponent = lazy(config.component);
+  const routeDef = {
+    component: LazyComponent
+  };
+  if (config.path !== void 0) routeDef.path = config.path;
+  if (config.loadingElement !== void 0) routeDef.loadingElement = config.loadingElement;
+  if (config.errorElement !== void 0) routeDef.errorElement = config.errorElement;
+  if (config.preload !== void 0) routeDef.preload = config.preload;
+  if (config.children !== void 0) routeDef.children = config.children;
+  if (config.index !== void 0) routeDef.index = config.index;
+  if (config.key !== void 0) routeDef.key = config.key;
+  return routeDef;
+}
+function createLazyRoutes(modules, options = {}) {
+  const routes = [];
+  for (const [filePath, loader] of Object.entries(modules)) {
+    const path = options.pathTransform ? options.pathTransform(filePath) : filePath.replace(/^\.\/pages/, "").replace(/\.(tsx?|jsx?)$/, "").toLowerCase();
+    routes.push(
+      lazyRoute({
+        path,
+        component: loader,
+        loadingElement: options.loadingElement,
+        errorElement: options.errorElement
+      })
+    );
+  }
+  return routes;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Router
+  Form,
+  HashRouter,
+  Link,
+  MemoryRouter,
+  NavLink,
+  Navigate,
+  Outlet,
+  Redirect,
+  Route,
+  Router,
+  Routes,
+  StaticRouter,
+  action,
+  cleanupDataUtilities,
+  clearAllScrollPositions,
+  clearScrollPosition,
+  compileRoute,
+  configureScrollRestoration,
+  createBranches,
+  createBrowserHistory,
+  createHashHistory,
+  createLazyRoutes,
+  createLocation,
+  createMemoryHistory,
+  createPreload,
+  createResource,
+  createRouter,
+  createRoutes,
+  createScrollRestoration,
+  createStaticHistory,
+  createURL,
+  getAction,
+  getScrollRestoration,
+  isBrowser,
+  isLazyComponent,
+  isServer,
+  joinPaths,
+  lazy,
+  lazyRoute,
+  locationsAreEqual,
+  matchRoutes,
+  normalizePath,
+  parseSearchParams,
+  parseURL,
+  preloadLazy,
+  preloadQuery,
+  prependBasePath,
+  query,
+  resolvePath,
+  restoreScrollPosition,
+  revalidate,
+  saveScrollPosition,
+  scoreRoute,
+  scrollToHash,
+  scrollToTop,
+  stringifySearchParams,
+  stripBasePath,
+  submitAction,
+  useBeforeLeave,
+  useHref,
+  useIsActive,
+  useIsRouting,
+  useLocation,
+  useMatch,
+  useMatches,
+  useNavigate,
+  useParams,
+  usePendingLocation,
+  useResolvedPath,
+  useRoute,
+  useRouteData,
+  useRouteError,
+  useRouter,
+  useSearchParams,
+  useSubmission,
+  useSubmissions
 });
+//# sourceMappingURL=index.cjs.map