one 1.25.4 → 1.25.5

package/dist/cjs/router/router.cjs

@@ -1,909 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
-};
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
-var router_exports = {};
-__export(router_exports, {
-  canDismiss: () => canDismiss,
-  canGoBack: () => canGoBack,
-  cleanup: () => cleanup,
-  consumePendingNavigationAction: () => consumePendingNavigationAction,
-  dismiss: () => dismiss,
-  dismissAll: () => dismissAll,
-  getPreloadHistory: () => getPreloadHistory,
-  getSafeWindowPathname: () => import_path3.getSafeWindowPathname,
-  getSortedRoutes: () => getSortedRoutes,
-  getValidationState: () => getValidationState,
-  goBack: () => goBack,
-  handleNavigationContainerStateChange: () => handleNavigationContainerStateChange,
-  hasAttemptedToHideSplash: () => hasAttemptedToHideSplash,
-  initClientMatches: () => initClientMatches,
-  initialPathname: () => initialPathname,
-  initialState: () => initialState,
-  initialize: () => initialize,
-  isRouteProtected: () => isRouteProtected,
-  lastIntendedPathname: () => lastIntendedPathname,
-  linkTo: () => linkTo,
-  navigate: () => navigate,
-  navigationRef: () => navigationRef,
-  preloadRoute: () => preloadRoute,
-  preloadedLoaderData: () => preloadedLoaderData,
-  preloadingLoader: () => preloadingLoader,
-  push: () => push,
-  registerProtectedRoutes: () => registerProtectedRoutes,
-  replace: () => replace,
-  resolveProtectedHref: () => resolveProtectedHref,
-  rootComponent: () => rootComponent,
-  rootState: () => rootState,
-  rootStateSnapshot: () => rootStateSnapshot,
-  routeInfo: () => routeInfo,
-  routeInfoSnapshot: () => routeInfoSnapshot,
-  routeNode: () => routeNode,
-  setLoadingState: () => setLoadingState,
-  setParams: () => setParams,
-  setValidationState: () => setValidationState,
-  snapshot: () => snapshot,
-  subscribeToLoadingState: () => subscribeToLoadingState,
-  subscribeToRootState: () => subscribeToRootState,
-  subscribeToStore: () => subscribeToStore,
-  subscribeToValidationState: () => subscribeToValidationState,
-  unregisterProtectedRoutes: () => unregisterProtectedRoutes,
-  updateState: () => updateState,
-  useOneRouter: () => useOneRouter,
-  useStoreRootState: () => useStoreRootState,
-  useStoreRouteInfo: () => useStoreRouteInfo,
-  useValidationState: () => useValidationState
-});
-module.exports = __toCommonJS(router_exports);
-var import_native = require("@react-navigation/native");
-var import_react = require("react");
-var import_registry = require("../devtools/registry.cjs");
-var import_href = require("../link/href.cjs");
-var import_openExternalURL = require("../link/openExternalURL.cjs");
-var import_path = require("../link/path.cjs");
-var import_useBlocker = require("../useBlocker.cjs");
-var import_assertIsReady = require("../utils/assertIsReady.cjs");
-var import_cleanUrl = require("../utils/cleanUrl.cjs");
-var import_dynamicImport = require("../utils/dynamicImport.cjs");
-var import_platform = require("../utils/platform.cjs");
-var import_skewProtection = require("../skewProtection.cjs");
-var import_url = require("../utils/url.cjs");
-var import_validateParams = require("../validateParams.cjs");
-var import_findRouteNode = require("./findRouteNode.cjs");
-var import_getRouteInfo = require("./getRouteInfo.cjs");
-var import_isStateAwaitingNavigatorMount = require("./isStateAwaitingNavigatorMount.cjs");
-var import_getRouteArtifactPath = require("./getRouteArtifactPath.cjs");
-var import_getRoutes = require("./getRoutes.cjs");
-var import_lastAction = require("./lastAction.cjs");
-var import_linkingConfig = require("./linkingConfig.cjs");
-var import_path2 = require("./path.cjs");
-var import_sortRoutes = require("./sortRoutes.cjs");
-var import_useScreens = require("./useScreens.cjs");
-var import_useViteRoutes = require("./useViteRoutes.cjs");
-var import_getNavigateAction = require("./utils/getNavigateAction.cjs");
-var import_useMatches = require("../useMatches.cjs");
-var import_interceptRoutes = require("./interceptRoutes.cjs");
-var import_Navigator = require("../views/Navigator.cjs");
-var import_notFoundState = require("../notFoundState.cjs");
-var import_path3 = require("./path.cjs");
-let routeNode = null;
-let rootComponent;
-const protectedRouteRegistry = /* @__PURE__ */new Map();
-function registerProtectedRoutes(contextKey, guardedRedirects) {
-  if (guardedRedirects.size === 0) protectedRouteRegistry.delete(contextKey);else protectedRouteRegistry.set(contextKey, guardedRedirects);
-}
-function unregisterProtectedRoutes(contextKey) {
-  protectedRouteRegistry.delete(contextKey);
-}
-function getProtectedRedirect(href) {
-  const normalizedHref = (0, import_findRouteNode.extractPathnameFromHref)(href).replace(/^\/+|\/+$/g, "");
-  for (const [contextKey, guardedRedirects] of protectedRouteRegistry) {
-    const normalizedContextKey = contextKey.replace(/^\/+|\/+$/g, "");
-    if (!normalizedContextKey || normalizedHref === normalizedContextKey || normalizedHref.startsWith(`${normalizedContextKey}/`)) {
-      const routeName = normalizedHref.slice(normalizedContextKey.length).replace(/^\//, "").split("/")[0] || "index";
-      const normalizedRouteName = routeName.replace(/\/index$/, "");
-      if (guardedRedirects.has(routeName)) return guardedRedirects.get(routeName);
-      if (guardedRedirects.has(normalizedRouteName)) return guardedRedirects.get(normalizedRouteName);
-    }
-  }
-  return false;
-}
-function resolveProtectedHref(href) {
-  let target = href;
-  const visited = /* @__PURE__ */new Set();
-  while (!visited.has(target)) {
-    visited.add(target);
-    const redirectTo = getProtectedRedirect(target);
-    if (redirectTo === false) return target;
-    if (redirectTo === void 0) return;
-    target = (0, import_href.resolveHref)(redirectTo);
-  }
-}
-function isRouteProtected(href) {
-  return getProtectedRedirect(href) !== false;
-}
-let hasAttemptedToHideSplash = false;
-let initialState;
-let rootState;
-let initialPathname;
-let lastIntendedPathname;
-let nextState;
-let routeInfo;
-let splashScreenAnimationFrame;
-let pendingNavigationPathname;
-let pendingNavigationAction;
-let navigationRef = null;
-const rootStateSubscribers = /* @__PURE__ */new Set();
-const loadingStateSubscribers = /* @__PURE__ */new Set();
-const storeSubscribers = /* @__PURE__ */new Set();
-let currentMatches = [];
-let validationState = {
-  status: "idle"
-};
-const validationStateSubscribers = /* @__PURE__ */new Set();
-function subscribeToValidationState(subscriber) {
-  validationStateSubscribers.add(subscriber);
-  return () => validationStateSubscribers.delete(subscriber);
-}
-function setValidationState(state) {
-  validationState = state;
-  for (const subscriber of validationStateSubscribers) subscriber(state);
-  if (state.status === "error" && state.error) window.dispatchEvent(new CustomEvent("one-validation-error", {
-    detail: {
-      error: {
-        message: state.error.message,
-        name: state.error.name,
-        stack: state.error.stack
-      },
-      href: state.lastValidatedHref,
-      timestamp: Date.now()
-    }
-  }));
-}
-function getValidationState() {
-  return validationState;
-}
-function useValidationState() {
-  return (0, import_react.useSyncExternalStore)(subscribeToValidationState, getValidationState, getValidationState);
-}
-let cachedRouteNode = null;
-let cachedRootComponent = null;
-let cachedContext = null;
-function initialize(context, ref, initialLocation, linking) {
-  cleanUpState();
-  if (context !== cachedContext || !cachedRouteNode) {
-    cachedRouteNode = (0, import_getRoutes.getRoutes)(context, {
-      ignoreEntryPoints: true,
-      platform: import_platform.PLATFORM
-    });
-    cachedRootComponent = cachedRouteNode ? (0, import_useScreens.getQualifiedRouteComponent)(cachedRouteNode) : import_react.Fragment;
-    cachedContext = context;
-  }
-  routeNode = cachedRouteNode;
-  rootComponent = cachedRootComponent || import_react.Fragment;
-  if (!routeNode && process.env.NODE_ENV === "production") throw new Error("No routes found");
-  if (process.env.ONE_DEBUG_ROUTER && routeNode) {
-    const formatRouteTree = (node, indent = "", isLast = true) => {
-      const prefix = indent + (isLast ? "└─ " : "├─ ");
-      const childIndent = indent + (isLast ? "   " : "│  ");
-      const dynamicBadge = node.dynamic ? ` [${node.dynamic.map(d => d.name).join(", ")}]` : "";
-      const typeBadge = node.type !== "layout" ? ` (${node.type})` : "";
-      const slotsBadge = node.slots?.size ? ` {@${Array.from(node.slots.keys()).join(", @")}}` : "";
-      let line = `${prefix}${node.route || "/"}${dynamicBadge}${typeBadge}${slotsBadge}`;
-      const visibleChildren = node.children.filter(child => !child.internal);
-      for (let i = 0; i < visibleChildren.length; i++) {
-        const child = visibleChildren[i];
-        const childIsLast = i === visibleChildren.length - 1;
-        line += "\n" + formatRouteTree(child, childIndent, childIsLast);
-      }
-      return line;
-    };
-    console.info(`[one] \u{1F4CD} Route structure:
-${formatRouteTree(routeNode)}`);
-    if (routeNode.slots?.size) {
-      console.info(`[one] \u{1F4E6} Slots on root layout:`);
-      for (const [slotName, slotConfig] of routeNode.slots) console.info(`  @${slotName}:`, {
-        defaultRoute: slotConfig.defaultRoute?.route,
-        interceptRoutes: slotConfig.interceptRoutes.map(r => ({
-          route: r.route,
-          intercept: r.intercept
-        }))
-      });
-    }
-  }
-  navigationRef = ref;
-  setupLinkingAndRouteInfo(initialLocation, linking);
-  subscribeToNavigationChanges();
-}
-function cleanUpState() {
-  initialState = void 0;
-  initialPathname = void 0;
-  lastIntendedPathname = void 0;
-  rootState = void 0;
-  nextState = void 0;
-  routeInfo = void 0;
-  pendingNavigationPathname = void 0;
-  pendingNavigationAction = void 0;
-  (0, import_linkingConfig.resetLinking)();
-  rootStateSubscribers.clear();
-  storeSubscribers.clear();
-}
-function setupLinkingAndRouteInfo(initialLocation, linking) {
-  initialState = (0, import_linkingConfig.setupLinking)(routeNode, initialLocation, linking);
-  initialPathname = initialLocation?.pathname ?? (0, import_path2.getSafeWindowPathname)();
-  if (initialState) {
-    rootState = initialState;
-    routeInfo = (0, import_getRouteInfo.getRouteInfo)(initialState);
-  } else routeInfo = {
-    unstable_globalHref: "",
-    pathname: "",
-    isIndex: false,
-    params: {},
-    segments: []
-  };
-}
-function handleNavigationContainerStateChange(navState) {
-  if (!navState) return;
-  let state = {
-    ...navState
-  };
-  if (state.key) {
-    if (hashes[state.key]) {
-      state.hash = hashes[state.key];
-      delete hashes[state.key];
-    }
-  }
-  if (!hasAttemptedToHideSplash) {
-    hasAttemptedToHideSplash = true;
-    splashScreenAnimationFrame = requestAnimationFrame(() => {});
-  }
-  if (shouldKeepPendingNavigationState(state)) return;
-  if (nextOptions) {
-    state = {
-      ...state,
-      linkOptions: nextOptions
-    };
-    nextOptions = null;
-  }
-  let shouldUpdateSubscribers = nextState === state;
-  nextState = void 0;
-  if (state && state !== rootState) {
-    updateState(state, void 0);
-    shouldUpdateSubscribers = true;
-  }
-  if (shouldUpdateSubscribers) (0, import_react.startTransition)(() => {
-    for (const subscriber of rootStateSubscribers) subscriber(state);
-  });
-}
-function subscribeToNavigationChanges() {
-  (0, import_react.startTransition)(() => {
-    updateSnapshot();
-    for (const subscriber of storeSubscribers) subscriber();
-  });
-}
-function navigate(url, options) {
-  return linkTo((0, import_href.resolveHref)(url), "NAVIGATE", options);
-}
-function push(url, options) {
-  return linkTo((0, import_href.resolveHref)(url), "PUSH", options);
-}
-function dismiss(count) {
-  if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F519} dismiss${count ? ` (${count})` : ""}`);
-  navigationRef?.dispatch(import_native.StackActions.pop(count));
-}
-function replace(url, options) {
-  return linkTo((0, import_href.resolveHref)(url), "REPLACE", options);
-}
-function setParams(params = {}) {
-  (0, import_assertIsReady.assertIsReady)(navigationRef);
-  return navigationRef?.current?.setParams(
-  // @ts-expect-error
-  params);
-}
-function dismissAll() {
-  if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F519} dismissAll`);
-  navigationRef?.dispatch(import_native.StackActions.popToTop());
-}
-function goBack() {
-  if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F519} goBack`);
-  (0, import_assertIsReady.assertIsReady)(navigationRef);
-  navigationRef?.current?.goBack();
-}
-function canGoBack() {
-  if (!navigationRef.isReady()) return false;
-  return navigationRef?.current?.canGoBack() ?? false;
-}
-function canDismiss() {
-  let state = rootState;
-  while (state) {
-    if (state.type === "stack" && state.routes.length > 1) return true;
-    if (state.index === void 0) return false;
-    state = state.routes?.[state.index]?.state;
-  }
-  return false;
-}
-function getSortedRoutes() {
-  if (!routeNode) throw new Error("No routes");
-  return routeNode.children.filter(route => !route.internal).sort(import_sortRoutes.sortRoutes);
-}
-function updateState(state, nextStateParam = state) {
-  rootState = state;
-  nextState = nextStateParam;
-  if ((0, import_isStateAwaitingNavigatorMount.isStateAwaitingNavigatorMount)(state, routeNode)) {
-    if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F9ED} keeping ${routeInfo?.pathname}: a navigator has not mounted`);
-    return;
-  }
-  const nextRouteInfo = (0, import_getRouteInfo.getRouteInfo)(state);
-  if (pendingNavigationPathname === nextRouteInfo.pathname) pendingNavigationPathname = void 0;
-  if (!deepEqual(routeInfo, nextRouteInfo)) {
-    if (process.env.ONE_DEBUG_ROUTER) {
-      const from = routeInfo?.pathname || "(initial)";
-      const to = nextRouteInfo.pathname;
-      const params = Object.keys(nextRouteInfo.params || {}).length ? nextRouteInfo.params : void 0;
-      console.info(`[one] \u{1F9ED} ${from} \u2192 ${to}`, params ? {
-        params
-      } : "");
-    }
-    routeInfo = nextRouteInfo;
-  }
-  if (process.env.NODE_ENV === "development" && typeof window !== "undefined") {
-    window.__oneDevtools = {
-      routeInfo: nextRouteInfo,
-      rootState: state,
-      routeNode,
-      getRoutes: () => routeNode?.children || [],
-      getLoaderTimingHistory: () => import_registry.devtoolsRegistry.getLoaderTimingHistory?.() ?? [],
-      getPreloadHistory
-    };
-    window.dispatchEvent(new CustomEvent("one-route-change", {
-      detail: nextRouteInfo
-    }));
-  }
-}
-function consumePendingNavigationAction() {
-  const action = pendingNavigationAction;
-  pendingNavigationAction = void 0;
-  return action;
-}
-function subscribeToRootState(subscriber) {
-  rootStateSubscribers.add(subscriber);
-  return () => {
-    rootStateSubscribers.delete(subscriber);
-  };
-}
-function notifyRootStateSubscribers(state) {
-  for (const subscriber of rootStateSubscribers) subscriber(state);
-}
-function subscribeToStore(subscriber) {
-  storeSubscribers.add(subscriber);
-  return () => {
-    storeSubscribers.delete(subscriber);
-  };
-}
-function subscribeToLoadingState(subscriber) {
-  loadingStateSubscribers.add(subscriber);
-  return () => {
-    loadingStateSubscribers.delete(subscriber);
-  };
-}
-function setLoadingState(state) {
-  (0, import_react.startTransition)(() => {
-    for (const listener of loadingStateSubscribers) listener(state);
-  });
-}
-let currentSnapshot = null;
-function updateSnapshot() {
-  currentSnapshot = getSnapshot();
-}
-function snapshot() {
-  return currentSnapshot;
-}
-function getSnapshot() {
-  return {
-    linkTo,
-    routeNode,
-    rootComponent,
-    linking: (0, import_linkingConfig.getResolvedLinking)(),
-    hasAttemptedToHideSplash,
-    initialState,
-    rootState,
-    nextState,
-    routeInfo,
-    splashScreenAnimationFrame,
-    navigationRef,
-    rootStateSubscribers,
-    storeSubscribers
-  };
-}
-function rootStateSnapshot() {
-  return rootState;
-}
-function routeInfoSnapshot() {
-  return routeInfo;
-}
-function getBrowserPathname() {
-  const pathname = (0, import_path2.getSafeWindowPathname)();
-  return pathname === void 0 ? void 0 : (0, import_path2.normalizeRoutePathname)(pathname);
-}
-function shouldKeepPendingNavigationState(currentState) {
-  if (!pendingNavigationPathname) return false;
-  return (0, import_getRouteInfo.getRouteInfo)(currentState).pathname !== pendingNavigationPathname;
-}
-function shouldPreserveInitialRouteInfo(currentState) {
-  if (!initialState || !routeInfo?.pathname) return false;
-  const nextPathname = (0, import_getRouteInfo.getRouteInfo)(currentState).pathname;
-  if (nextPathname === routeInfo.pathname) return false;
-  if (nextPathname && nextPathname === pendingNavigationPathname) return false;
-  const browserPathname = getBrowserPathname();
-  if (nextPathname && browserPathname && nextPathname === browserPathname) return false;
-  return true;
-}
-function useOneRouter() {
-  const state = (0, import_react.useSyncExternalStore)(subscribeToStore, snapshot, snapshot);
-  return (0, import_react.useDeferredValue)(state);
-}
-function syncStoreRootState() {
-  if (!navigationRef) throw new Error(`No navigationRef, possible duplicate One dep`);
-  if (navigationRef.isReady()) {
-    const currentState = navigationRef.getRootState();
-    if (rootState !== currentState) {
-      if (shouldKeepPendingNavigationState(currentState)) return;
-      if (shouldPreserveInitialRouteInfo(currentState)) return;
-      updateState(currentState);
-    }
-  }
-}
-function useStoreRootState() {
-  syncStoreRootState();
-  const state = (0, import_react.useSyncExternalStore)(subscribeToRootState, rootStateSnapshot, rootStateSnapshot);
-  return (0, import_react.useDeferredValue)(state);
-}
-function useStoreRouteInfo() {
-  syncStoreRootState();
-  return (0, import_react.useSyncExternalStore)(subscribeToRootState, routeInfoSnapshot, routeInfoSnapshot);
-}
-function cleanup() {
-  if (splashScreenAnimationFrame) cancelAnimationFrame(splashScreenAnimationFrame);
-}
-const preloadingLoader = {};
-const PRELOAD_MAP_MAX = 200;
-function setBoundedPreloadRecord(record, key, value) {
-  if (!(key in record)) {
-    const keys = Object.keys(record);
-    if (keys.length >= PRELOAD_MAP_MAX) delete record[keys[0]];
-  }
-  record[key] = value;
-}
-async function doPreloadDev(href) {
-  if (process.env.NODE_ENV === "development") {
-    const startTime = performance.now();
-    const normalizedPath = normalizeLoaderPath(href);
-    if (globalThis["__vxrnHeadless"]) return null;
-    try {
-      const loaderJSUrl = (0, import_cleanUrl.getLoaderPath)(href, true);
-      const moduleLoadStart = performance.now();
-      const modulePromise = (0, import_dynamicImport.dynamicImport)(loaderJSUrl);
-      if (!modulePromise) return null;
-      const module2 = await modulePromise.catch(() => null);
-      const moduleLoadTime = performance.now() - moduleLoadStart;
-      if (!module2?.loader) return null;
-      const executionStart = performance.now();
-      const result = await module2.loader();
-      const executionTime = performance.now() - executionStart;
-      const totalTime = performance.now() - startTime;
-      if (result?.__oneRedirect) return result;
-      import_registry.devtoolsRegistry.recordLoaderTiming?.({
-        path: normalizedPath,
-        startTime,
-        moduleLoadTime,
-        executionTime,
-        totalTime,
-        source: "preload"
-      });
-      return result ?? null;
-    } catch (err) {
-      const totalTime = performance.now() - startTime;
-      import_registry.devtoolsRegistry.recordLoaderTiming?.({
-        path: normalizedPath,
-        startTime,
-        totalTime,
-        error: err instanceof Error ? err.message : String(err),
-        source: "preload"
-      });
-      if (process.env.ONE_DEBUG_ROUTER) console.warn(`[one] dev preload failed for ${href}:`, err);
-      return null;
-    }
-  }
-}
-async function doPreload(href) {
-  if (globalThis["__vxrnHeadless"]) return null;
-  const artifactPaths = (0, import_getRouteArtifactPath.getRouteArtifactPaths)(href, (0, import_linkingConfig.getResolvedLinking)(), routeNode);
-  const preloadPath = (0, import_cleanUrl.getPreloadPath)(artifactPaths.preload);
-  const loaderPath = (0, import_cleanUrl.getLoaderPath)(artifactPaths.loader);
-  const cssPreloadPath = (0, import_cleanUrl.getPreloadCSSPath)(artifactPaths.preload);
-  recordPreloadStart(href);
-  try {
-    const [_preload, cssPreloadModule, loader] = await Promise.all([(0, import_dynamicImport.dynamicImport)(preloadPath)?.catch(err => {
-      recordPreloadError(href, err instanceof Error ? err.message : String(err));
-      return null;
-    }), (0, import_dynamicImport.dynamicImport)(cssPreloadPath)?.catch(() => null) ?? Promise.resolve(null), (0, import_dynamicImport.dynamicImport)(loaderPath)?.catch(() => null) ?? Promise.resolve(null), (0, import_useViteRoutes.preloadRouteModules)(href)]);
-    const hasCss = !!cssPreloadModule?.injectCSS;
-    if (hasCss) setBoundedCssInject(href, cssPreloadModule.injectCSS);
-    if (!!!loader?.loader) {
-      recordPreloadComplete(href, false, hasCss);
-      return null;
-    }
-    const result = await loader.loader();
-    if (result?.__oneRedirect) return result;
-    recordPreloadComplete(href, true, hasCss);
-    return result ?? null;
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    console.error(`[one] preload error for ${href}:`, err);
-    recordPreloadError(href, errorMessage);
-    return null;
-  }
-}
-const preloadedLoaderData = {};
-const cssInjectFunctions = {};
-function setBoundedCssInject(key, value) {
-  if (!(key in cssInjectFunctions)) {
-    const keys = Object.keys(cssInjectFunctions);
-    if (keys.length >= PRELOAD_MAP_MAX) delete cssInjectFunctions[keys[0]];
-  }
-  cssInjectFunctions[key] = value;
-}
-const preloadHistory = [];
-const MAX_PRELOAD_HISTORY = 30;
-function recordPreloadStart(href) {
-  if (process.env.NODE_ENV !== "development") return;
-  const existing = preloadHistory.find(p => p.href === href);
-  if (existing) {
-    existing.status = "loading";
-    existing.startTime = performance.now();
-    return;
-  }
-  preloadHistory.unshift({
-    href,
-    status: "loading",
-    startTime: performance.now(),
-    hasLoader: false,
-    hasCss: false
-  });
-  if (preloadHistory.length > MAX_PRELOAD_HISTORY) preloadHistory.pop();
-  dispatchPreloadEvent();
-}
-function recordPreloadComplete(href, hasLoader, hasCss) {
-  if (process.env.NODE_ENV !== "development") return;
-  const entry = preloadHistory.find(p => p.href === href);
-  if (entry) {
-    entry.status = "loaded";
-    entry.endTime = performance.now();
-    entry.hasLoader = hasLoader;
-    entry.hasCss = hasCss;
-  }
-  dispatchPreloadEvent();
-}
-function recordPreloadError(href, error) {
-  if (process.env.NODE_ENV !== "development") return;
-  const entry = preloadHistory.find(p => p.href === href);
-  if (entry) {
-    entry.status = "error";
-    entry.endTime = performance.now();
-    entry.error = error;
-  }
-  dispatchPreloadEvent();
-}
-function dispatchPreloadEvent() {
-  window.dispatchEvent(new CustomEvent("one-preload-update"));
-}
-function getPreloadHistory() {
-  return preloadHistory;
-}
-function preloadRoute(href, injectCSS = false) {
-  if (process.env.NODE_ENV === "development") {
-    const normalizedHref = normalizeLoaderPath(href);
-    if (!preloadingLoader[normalizedHref]) setBoundedPreloadRecord(preloadingLoader, normalizedHref, doPreloadDev(href).then(data => {
-      setBoundedPreloadRecord(preloadedLoaderData, normalizedHref, data);
-      return data;
-    }));
-    return preloadingLoader[normalizedHref];
-  }
-  if (!preloadingLoader[href]) setBoundedPreloadRecord(preloadingLoader, href, doPreload(href).then(data => {
-    setBoundedPreloadRecord(preloadedLoaderData, href, data);
-    return data;
-  }));
-  if (injectCSS) return preloadingLoader[href]?.then(async data => {
-    const inject = cssInjectFunctions[href];
-    if (inject) await Promise.race([inject(), new Promise(r => setTimeout(r, 800))]);
-    return data;
-  });
-  return preloadingLoader[href];
-}
-function normalizeLoaderPath(href) {
-  return new URL(href, "http://example.com").pathname.replace(/\/index$/, "").replace(/\/$/, "") || "/";
-}
-function buildClientMatches(href, matchingNode, params, loaderData) {
-  const pathname = (0, import_findRouteNode.extractPathnameFromHref)(href);
-  const routeId = matchingNode?.contextKey || pathname;
-  const layoutMatches = currentMatches.filter(m => m.routeId.includes("_layout"));
-  const pageMatch = {
-    routeId,
-    pathname,
-    params,
-    loaderData
-  };
-  return [...layoutMatches, pageMatch];
-}
-function initClientMatches(matches) {
-  currentMatches = matches;
-  (0, import_useMatches.setClientMatches)(matches);
-}
-async function linkTo(href, event, options) {
-  if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F517} ${event || "NAVIGATE"} ${href}`);
-  (0, import_interceptRoutes.setNavigationType)("soft");
-  (0, import_notFoundState.clearNotFoundState)();
-  if (href[0] === "#") return;
-  if ((0, import_url.shouldLinkExternally)(href)) {
-    (0, import_openExternalURL.openExternalURL)(href);
-    return;
-  }
-  if ((0, import_skewProtection.isVersionStale)()) {
-    window.location.href = href;
-    return;
-  }
-  if ((0, import_useBlocker.checkBlocker)(href, event === "REPLACE" ? "replace" : "push")) return;
-  const protectedHref = resolveProtectedHref(href);
-  if (!protectedHref) return;
-  if (protectedHref !== href) return linkTo(protectedHref, "REPLACE", options);
-  const currentLayoutNode = routeNode;
-  const currentPath = routeInfo?.pathname || "/";
-  const interceptResult = (0, import_interceptRoutes.findInterceptRoute)(href, currentLayoutNode, currentPath);
-  if (interceptResult) {
-    const {
-      interceptRoute,
-      slotName,
-      layoutContextKey,
-      params: params2
-    } = interceptResult;
-    const scopedSlotKey = `${layoutContextKey}:${slotName}`;
-    (0, import_interceptRoutes.storeInterceptState)(scopedSlotKey, interceptRoute, params2);
-    (0, import_interceptRoutes.updateURLWithoutNavigation)(href);
-    (0, import_Navigator.setSlotState)(scopedSlotKey, {
-      activeRouteKey: interceptRoute.contextKey,
-      activeRouteNode: interceptRoute,
-      params: params2,
-      isIntercepted: true
-    });
-    return;
-  }
-  (0, import_assertIsReady.assertIsReady)(navigationRef);
-  const current = navigationRef.current;
-  if (current == null) throw new Error("Couldn't find a navigation object. Is your component inside NavigationContainer?");
-  const linking = (0, import_linkingConfig.getResolvedLinking)();
-  if (!linking) throw new Error("Attempted to link to route when no routes are present");
-  (0, import_lastAction.setLastAction)();
-  if (href === ".." || href === "../") {
-    current.goBack();
-    return;
-  }
-  if (href.startsWith(".")) {
-    let base = routeInfo?.segments?.map(segment => {
-      if (!segment.startsWith("[")) return segment;
-      if (segment.startsWith("[...")) {
-        segment = segment.slice(4, -1);
-        const params2 = routeInfo?.params?.[segment];
-        if (Array.isArray(params2)) return params2.join("/");
-        return params2?.split(",")?.join("/") ?? "";
-      }
-      segment = segment.slice(1, -1);
-      return routeInfo?.params?.[segment];
-    }).filter(Boolean).join("/") ?? "/";
-    if (!routeInfo?.isIndex) base += "/..";
-    href = (0, import_path.resolve)(base, href);
-  }
-  const state = linking.getStateFromPath(href, linking.config);
-  if (!state || state.routes.length === 0) {
-    console.error("Could not generate a valid navigation state for the given path: " + href);
-    console.error(`linking.config`, linking.config);
-    console.error(`routes`, getSortedRoutes());
-    return;
-  }
-  setLoadingState("loading");
-  const normalizedPreloadPath = normalizeLoaderPath(href);
-  if (!(normalizedPreloadPath in preloadedLoaderData) && !(href in preloadedLoaderData)) await preloadRoute(href, true);else if (process.env.NODE_ENV !== "development") {
-    const inject = cssInjectFunctions[href];
-    if (inject) inject().catch(() => {});
-  }
-  const preloadResult = preloadedLoaderData[normalizedPreloadPath];
-  if (preloadResult?.__oneRedirect) {
-    const redirectTarget = preloadResult.__oneRedirect;
-    delete preloadedLoaderData[normalizedPreloadPath];
-    delete preloadingLoader[normalizedPreloadPath];
-    delete preloadedLoaderData[href];
-    delete preloadingLoader[href];
-    setLoadingState("loaded");
-    linkTo(redirectTarget, "REPLACE");
-    return;
-  }
-  if (preloadResult?.__oneError === 404) {
-    delete preloadedLoaderData[normalizedPreloadPath];
-    delete preloadingLoader[normalizedPreloadPath];
-    delete preloadedLoaderData[href];
-    delete preloadingLoader[href];
-    setLoadingState("loaded");
-    const notFoundRoute = (0, import_notFoundState.findNearestNotFoundRoute)(href, routeNode);
-    (0, import_notFoundState.setNotFoundState)({
-      notFoundPath: preloadResult.__oneNotFoundPath || "/+not-found",
-      notFoundRouteNode: notFoundRoute || void 0,
-      originalPath: href
-    });
-    return;
-  }
-  const matchingRouteNode = (0, import_findRouteNode.findRouteNodeFromState)(state, routeNode);
-  if (matchingRouteNode?.loadRoute) {
-    setValidationState({
-      status: "validating",
-      lastValidatedHref: href
-    });
-    try {
-      const loadedRoute = matchingRouteNode.loadRoute();
-      const params2 = (0, import_findRouteNode.extractParamsFromState)(state);
-      const search = (0, import_findRouteNode.extractSearchFromHref)(href);
-      const pathname = (0, import_findRouteNode.extractPathnameFromHref)(href);
-      if (loadedRoute.validateParams) (0, import_validateParams.validateParams)(loadedRoute.validateParams, params2);
-      if (loadedRoute.validateRoute) {
-        const validationResult = await loadedRoute.validateRoute({
-          params: params2,
-          search,
-          pathname,
-          href
-        });
-        if (validationResult && !validationResult.valid) {
-          const error = new import_validateParams.RouteValidationError(validationResult.error || "Route validation failed", validationResult.details);
-          setValidationState({
-            status: "error",
-            error,
-            lastValidatedHref: href
-          });
-          throw error;
-        }
-      }
-      setValidationState({
-        status: "valid",
-        lastValidatedHref: href
-      });
-    } catch (error) {
-      if (error && typeof error.then === "function") {
-        await error.catch(() => {});
-        setValidationState({
-          status: "valid",
-          lastValidatedHref: href
-        });
-      } else if (error instanceof import_validateParams.ParamValidationError || error instanceof import_validateParams.RouteValidationError) {
-        setValidationState({
-          status: "error",
-          error,
-          lastValidatedHref: href
-        });
-        throw error;
-      } else throw error;
-    }
-  }
-  const loaderData = preloadedLoaderData[normalizeLoaderPath(href)];
-  const params = (0, import_findRouteNode.extractParamsFromState)(state);
-  const newMatches = buildClientMatches(href, matchingRouteNode, params, loaderData);
-  currentMatches = newMatches;
-  (0, import_useMatches.setClientMatches)(newMatches);
-  if (!navigationRef.isReady()) {
-    setLoadingState("loaded");
-    return;
-  }
-  const currentRootState = navigationRef.getRootState();
-  const hash = href.indexOf("#");
-  if (currentRootState.key && hash > 0) hashes[currentRootState.key] = href.slice(hash);
-  nextOptions = options ?? null;
-  pendingNavigationPathname = (0, import_path2.stripTrailingSlash)((0, import_findRouteNode.extractPathnameFromHref)(href));
-  pendingNavigationAction = event === "PUSH" || event === "REPLACE" || event === "NAVIGATE" ? event : void 0;
-  lastIntendedPathname = pendingNavigationPathname;
-  const freshRootState = navigationRef.getRootState();
-  const currentRouteBeforeDispatch = navigationRef.getCurrentRoute();
-  if (event === "REPLACE") {
-    const targetPathname = pendingNavigationPathname;
-    const optimisticState = nextOptions ? {
-      ...state,
-      linkOptions: nextOptions
-    } : state;
-    updateState(optimisticState);
-    pendingNavigationPathname = targetPathname;
-    notifyRootStateSubscribers(optimisticState);
-    navigationRef.resetRoot(state);
-  } else {
-    const action = (0, import_getNavigateAction.getNavigateAction)(state, freshRootState, event);
-    const targetName = action.payload?.name;
-    const isGroupTarget = typeof targetName === "string" && targetName.startsWith("(") && targetName.endsWith(")");
-    const hasFreshRootState = freshRootState.type === "stack";
-    const isRootTarget = action.target === freshRootState.key;
-    const currentFocusedRoute = freshRootState.routes[freshRootState.index];
-    const currentFocusedName = currentFocusedRoute?.name;
-    if (isRootTarget && isGroupTarget && hasFreshRootState) {
-      const targetRoute = state.routes[state.routes.length - 1];
-      const targetRootName = targetRoute.name;
-      if (currentFocusedName === targetRootName) {
-        const routes = [...freshRootState.routes];
-        routes[freshRootState.index] = {
-          ...targetRoute,
-          key: currentFocusedRoute?.key ?? targetRoute.key
-        };
-        navigationRef.resetRoot({
-          ...freshRootState,
-          routes
-        });
-      } else {
-        const existingTargetRoute = freshRootState.routes.find(route => route.name === targetRootName);
-        const existingRoutes = freshRootState.routes.filter(route => route.name !== targetRootName);
-        const nextRootState = {
-          ...freshRootState,
-          routes: [...existingRoutes, {
-            ...targetRoute,
-            key: existingTargetRoute?.key ?? `${targetRootName}-${freshRootState.key}`
-          }],
-          index: existingRoutes.length
-        };
-        navigationRef.resetRoot(nextRootState);
-      }
-    } else navigationRef.dispatch(action);
-  }
-  let warningTm;
-  const interval = setInterval(() => {
-    if (!navigationRef.isReady()) {
-      clearTimeout(warningTm);
-      clearInterval(interval);
-      return;
-    }
-    if (currentRouteBeforeDispatch !== navigationRef.getCurrentRoute()) setTimeout(() => {
-      setLoadingState("loaded");
-    });
-    clearTimeout(warningTm);
-    clearInterval(interval);
-  }, 16);
-  if (process.env.NODE_ENV === "development") warningTm = setTimeout(() => {
-    console.warn(`Routing took more than 8 seconds`);
-  }, 1e3);
-}
-const hashes = {};
-let nextOptions = null;
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
-    return true;
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const keysA = Object.keys(a);
-    const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
-    for (const key of keysA) if (!deepEqual(a[key], b[key])) return false;
-    return true;
-  }
-  return false;
-}