one 1.25.5 → 1.25.7

package/dist/esm/router/router.native.js

@@ -0,0 +1,865 @@
+import { StackActions } from "@react-navigation/native";
+import { Fragment, startTransition, useDeferredValue, useSyncExternalStore } from "react";
+import { devtoolsRegistry } from "../devtools/registry.native.js";
+import { resolveHref } from "../link/href.native.js";
+import { openExternalURL } from "../link/openExternalURL.native.js";
+import { resolve } from "../link/path.native.js";
+import { checkBlocker } from "../useBlocker.native.js";
+import { assertIsReady } from "../utils/assertIsReady.native.js";
+import { PLATFORM } from "../utils/platform.native.js";
+import { isVersionStale } from "../skewProtection.native.js";
+import { shouldLinkExternally } from "../utils/url.native.js";
+import { ParamValidationError, RouteValidationError, validateParams } from "../validateParams.native.js";
+import { extractParamsFromState, extractPathnameFromHref, extractSearchFromHref, findAllRouteNodesFromState, findRouteNodeFromState } from "./findRouteNode.native.js";
+import { getRouteInfo } from "./getRouteInfo.native.js";
+import { isStateAwaitingNavigatorMount } from "./isStateAwaitingNavigatorMount.native.js";
+import { getRoutes } from "./getRoutes.native.js";
+import { setLastAction } from "./lastAction.native.js";
+import { getResolvedLinking, resetLinking, setupLinking } from "./linkingConfig.native.js";
+import { getSafeWindowPathname, getSafeWindowPathname as getSafeWindowPathname2, normalizeRoutePathname, stripTrailingSlash } from "./path.native.js";
+import { sortRoutes } from "./sortRoutes.native.js";
+import { getQualifiedRouteComponent } from "./useScreens.native.js";
+import { getNavigateAction } from "./utils/getNavigateAction.native.js";
+import { setClientMatches } from "../useMatches.native.js";
+import { findInterceptRoute, setNavigationType, storeInterceptState, updateURLWithoutNavigation } from "./interceptRoutes.native.js";
+import { setSlotState } from "../views/Navigator.native.js";
+import { clearNotFoundState, findNearestNotFoundRoute, setNotFoundState } from "../notFoundState.native.js";
+function _instanceof(left, right) {
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);else return left instanceof right;
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var routeNode = null;
+var rootComponent;
+var 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) {
+  var normalizedHref = extractPathnameFromHref(href).replace(/^\/+|\/+$/g, "");
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = protectedRouteRegistry[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [contextKey, guardedRedirects] = _step.value;
+      var normalizedContextKey = contextKey.replace(/^\/+|\/+$/g, "");
+      if (!normalizedContextKey || normalizedHref === normalizedContextKey || normalizedHref.startsWith(`${normalizedContextKey}/`)) {
+        var routeName = normalizedHref.slice(normalizedContextKey.length).replace(/^\//, "").split("/")[0] || "index";
+        var normalizedRouteName = routeName.replace(/\/index$/, "");
+        if (guardedRedirects.has(routeName)) return guardedRedirects.get(routeName);
+        if (guardedRedirects.has(normalizedRouteName)) return guardedRedirects.get(normalizedRouteName);
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+    } finally {
+      if (_didIteratorError) throw _iteratorError;
+    }
+  }
+  return false;
+}
+function resolveProtectedHref(href) {
+  var target = href;
+  var visited = /* @__PURE__ */new Set();
+  while (!visited.has(target)) {
+    visited.add(target);
+    var redirectTo = getProtectedRedirect(target);
+    if (redirectTo === false) return target;
+    if (redirectTo === void 0) return;
+    target = resolveHref(redirectTo);
+  }
+}
+function isRouteProtected(href) {
+  return getProtectedRedirect(href) !== false;
+}
+var hasAttemptedToHideSplash = false;
+var initialState;
+var rootState;
+var initialPathname;
+var lastIntendedPathname;
+var nextState;
+var routeInfo;
+var splashScreenAnimationFrame;
+var pendingNavigationPathname;
+var pendingNavigationAction;
+var navigationRef = null;
+var rootStateSubscribers = /* @__PURE__ */new Set();
+var loadingStateSubscribers = /* @__PURE__ */new Set();
+var storeSubscribers = /* @__PURE__ */new Set();
+var currentMatches = [];
+var validationState = {
+  status: "idle"
+};
+var validationStateSubscribers = /* @__PURE__ */new Set();
+function subscribeToValidationState(subscriber) {
+  validationStateSubscribers.add(subscriber);
+  return function () {
+    return validationStateSubscribers.delete(subscriber);
+  };
+}
+function setValidationState(state) {
+  validationState = state;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = validationStateSubscribers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var subscriber = _step.value;
+      subscriber(state);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+    } finally {
+      if (_didIteratorError) throw _iteratorError;
+    }
+  }
+}
+function getValidationState() {
+  return validationState;
+}
+function useValidationState() {
+  return useSyncExternalStore(subscribeToValidationState, getValidationState, getValidationState);
+}
+var cachedRouteNode = null;
+var cachedRootComponent = null;
+var cachedContext = null;
+function initialize(context, ref, initialLocation, linking) {
+  cleanUpState();
+  if (context !== cachedContext || !cachedRouteNode) {
+    cachedRouteNode = getRoutes(context, {
+      ignoreEntryPoints: true,
+      platform: PLATFORM
+    });
+    cachedRootComponent = cachedRouteNode ? getQualifiedRouteComponent(cachedRouteNode) : Fragment;
+    cachedContext = context;
+  }
+  routeNode = cachedRouteNode;
+  rootComponent = cachedRootComponent || Fragment;
+  if (!routeNode && process.env.NODE_ENV === "production") throw new Error("No routes found");
+  if (process.env.ONE_DEBUG_ROUTER && routeNode) {
+    var _routeNode_slots;
+    var formatRouteTree = function (node) {
+      var indent = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "",
+        isLast = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
+      var _node_slots;
+      var prefix = indent + (isLast ? "└─ " : "├─ ");
+      var childIndent = indent + (isLast ? "   " : "│  ");
+      var dynamicBadge = node.dynamic ? ` [${node.dynamic.map(function (d) {
+        return d.name;
+      }).join(", ")}]` : "";
+      var typeBadge = node.type !== "layout" ? ` (${node.type})` : "";
+      var slotsBadge = ((_node_slots = node.slots) === null || _node_slots === void 0 ? void 0 : _node_slots.size) ? ` {@${Array.from(node.slots.keys()).join(", @")}}` : "";
+      var line = `${prefix}${node.route || "/"}${dynamicBadge}${typeBadge}${slotsBadge}`;
+      var visibleChildren = node.children.filter(function (child2) {
+        return !child2.internal;
+      });
+      for (var i = 0; i < visibleChildren.length; i++) {
+        var child = visibleChildren[i];
+        var 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 = routeNode.slots) === null || _routeNode_slots === void 0 ? void 0 : _routeNode_slots.size) {
+      console.info(`[one] \u{1F4E6} Slots on root layout:`);
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = routeNode.slots[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var [slotName, slotConfig] = _step.value;
+          var _slotConfig_defaultRoute;
+          console.info(`  @${slotName}:`, {
+            defaultRoute: (_slotConfig_defaultRoute = slotConfig.defaultRoute) === null || _slotConfig_defaultRoute === void 0 ? void 0 : _slotConfig_defaultRoute.route,
+            interceptRoutes: slotConfig.interceptRoutes.map(function (r) {
+              return {
+                route: r.route,
+                intercept: r.intercept
+              };
+            })
+          });
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+        } finally {
+          if (_didIteratorError) throw _iteratorError;
+        }
+      }
+    }
+  }
+  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;
+  resetLinking();
+  rootStateSubscribers.clear();
+  storeSubscribers.clear();
+}
+function setupLinkingAndRouteInfo(initialLocation, linking) {
+  var _ref;
+  initialState = setupLinking(routeNode, initialLocation, linking);
+  initialPathname = (_ref = initialLocation === null || initialLocation === void 0 ? void 0 : initialLocation.pathname) !== null && _ref !== void 0 ? _ref : getSafeWindowPathname();
+  if (initialState) {
+    rootState = initialState;
+    routeInfo = getRouteInfo(initialState);
+  } else routeInfo = {
+    unstable_globalHref: "",
+    pathname: "",
+    isIndex: false,
+    params: {},
+    segments: []
+  };
+}
+function handleNavigationContainerStateChange(navState) {
+  if (!navState) return;
+  var state = {
+    ...navState
+  };
+  if (state.key) {
+    if (hashes[state.key]) {
+      state.hash = hashes[state.key];
+      delete hashes[state.key];
+    }
+  }
+  if (!hasAttemptedToHideSplash) {
+    hasAttemptedToHideSplash = true;
+    splashScreenAnimationFrame = requestAnimationFrame(function () {});
+  }
+  if (shouldKeepPendingNavigationState(state)) return;
+  if (nextOptions) {
+    state = {
+      ...state,
+      linkOptions: nextOptions
+    };
+    nextOptions = null;
+  }
+  var shouldUpdateSubscribers = nextState === state;
+  nextState = void 0;
+  if (state && state !== rootState) {
+    updateState(state, void 0);
+    shouldUpdateSubscribers = true;
+  }
+  if (shouldUpdateSubscribers) startTransition(function () {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = rootStateSubscribers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var subscriber = _step.value;
+        subscriber(state);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+  });
+}
+function subscribeToNavigationChanges() {
+  startTransition(function () {
+    updateSnapshot();
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = storeSubscribers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var subscriber = _step.value;
+        subscriber();
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+  });
+}
+function navigate(url, options) {
+  return linkTo(resolveHref(url), "NAVIGATE", options);
+}
+function push(url, options) {
+  return linkTo(resolveHref(url), "PUSH", options);
+}
+function dismiss(count) {
+  if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F519} dismiss${count ? ` (${count})` : ""}`);
+  navigationRef === null || navigationRef === void 0 || navigationRef.dispatch(StackActions.pop(count));
+}
+function replace(url, options) {
+  return linkTo(resolveHref(url), "REPLACE", options);
+}
+function setParams() {
+  var params = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var _navigationRef_current;
+  assertIsReady(navigationRef);
+  return navigationRef === null || navigationRef === void 0 ? void 0 : (_navigationRef_current = navigationRef.current) === null || _navigationRef_current === void 0 ? void 0 : _navigationRef_current.setParams(params);
+}
+function dismissAll() {
+  if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F519} dismissAll`);
+  navigationRef === null || navigationRef === void 0 || navigationRef.dispatch(StackActions.popToTop());
+}
+function goBack() {
+  var _navigationRef_current;
+  if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F519} goBack`);
+  assertIsReady(navigationRef);
+  navigationRef === null || navigationRef === void 0 || (_navigationRef_current = navigationRef.current) == null || _navigationRef_current.goBack();
+}
+function canGoBack() {
+  var _ref;
+  var _navigationRef_current;
+  if (!navigationRef.isReady()) return false;
+  return (_ref = navigationRef === null || navigationRef === void 0 ? void 0 : (_navigationRef_current = navigationRef.current) === null || _navigationRef_current === void 0 ? void 0 : _navigationRef_current.canGoBack()) !== null && _ref !== void 0 ? _ref : false;
+}
+function canDismiss() {
+  var state = rootState;
+  while (state) {
+    var _state_routes_state_index, _state_routes;
+    if (state.type === "stack" && state.routes.length > 1) return true;
+    if (state.index === void 0) return false;
+    state = (_state_routes = state.routes) === null || _state_routes === void 0 ? void 0 : (_state_routes_state_index = _state_routes[state.index]) === null || _state_routes_state_index === void 0 ? void 0 : _state_routes_state_index.state;
+  }
+  return false;
+}
+function getSortedRoutes() {
+  if (!routeNode) throw new Error("No routes");
+  return routeNode.children.filter(function (route) {
+    return !route.internal;
+  }).sort(sortRoutes);
+}
+function updateState(state) {
+  var nextStateParam = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : state;
+  rootState = state;
+  nextState = nextStateParam;
+  if (isStateAwaitingNavigatorMount(state, routeNode)) {
+    if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F9ED} keeping ${routeInfo === null || routeInfo === void 0 ? void 0 : routeInfo.pathname}: a navigator has not mounted`);
+    return;
+  }
+  var nextRouteInfo = getRouteInfo(state);
+  if (pendingNavigationPathname === nextRouteInfo.pathname) pendingNavigationPathname = void 0;
+  if (!deepEqual(routeInfo, nextRouteInfo)) {
+    if (process.env.ONE_DEBUG_ROUTER) {
+      var from = (routeInfo === null || routeInfo === void 0 ? void 0 : routeInfo.pathname) || "(initial)";
+      var to = nextRouteInfo.pathname;
+      var params = Object.keys(nextRouteInfo.params || {}).length ? nextRouteInfo.params : void 0;
+      console.info(`[one] \u{1F9ED} ${from} \u2192 ${to}`, params ? {
+        params
+      } : "");
+    }
+    routeInfo = nextRouteInfo;
+    var params1 = extractParamsFromState(state);
+    var newMatches = buildNativeMatches(state, nextRouteInfo.pathname, params1);
+    currentMatches = newMatches;
+    setClientMatches(newMatches);
+  }
+  if (process.env.NODE_ENV === "development" && typeof window !== "undefined") window.__oneDevtools = {
+    routeInfo: nextRouteInfo,
+    rootState: state,
+    routeNode,
+    getRoutes: function () {
+      return (routeNode === null || routeNode === void 0 ? void 0 : routeNode.children) || [];
+    },
+    getLoaderTimingHistory: function () {
+      var _ref;
+      var _devtoolsRegistry_getLoaderTimingHistory;
+      return (_ref = (_devtoolsRegistry_getLoaderTimingHistory = devtoolsRegistry.getLoaderTimingHistory) === null || _devtoolsRegistry_getLoaderTimingHistory === void 0 ? void 0 : _devtoolsRegistry_getLoaderTimingHistory.call(devtoolsRegistry)) !== null && _ref !== void 0 ? _ref : [];
+    },
+    getPreloadHistory
+  };
+}
+function consumePendingNavigationAction() {
+  var action = pendingNavigationAction;
+  pendingNavigationAction = void 0;
+  return action;
+}
+function subscribeToRootState(subscriber) {
+  rootStateSubscribers.add(subscriber);
+  return function () {
+    rootStateSubscribers.delete(subscriber);
+  };
+}
+function notifyRootStateSubscribers(state) {
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = rootStateSubscribers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var subscriber = _step.value;
+      subscriber(state);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+    } finally {
+      if (_didIteratorError) throw _iteratorError;
+    }
+  }
+}
+function subscribeToStore(subscriber) {
+  storeSubscribers.add(subscriber);
+  return function () {
+    storeSubscribers.delete(subscriber);
+  };
+}
+function subscribeToLoadingState(subscriber) {
+  loadingStateSubscribers.add(subscriber);
+  return function () {
+    loadingStateSubscribers.delete(subscriber);
+  };
+}
+function setLoadingState(state) {
+  startTransition(function () {
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = loadingStateSubscribers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var listener = _step.value;
+        listener(state);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+  });
+}
+var currentSnapshot = null;
+function updateSnapshot() {
+  currentSnapshot = getSnapshot();
+}
+function snapshot() {
+  return currentSnapshot;
+}
+function getSnapshot() {
+  return {
+    linkTo,
+    routeNode,
+    rootComponent,
+    linking: getResolvedLinking(),
+    hasAttemptedToHideSplash,
+    initialState,
+    rootState,
+    nextState,
+    routeInfo,
+    splashScreenAnimationFrame,
+    navigationRef,
+    rootStateSubscribers,
+    storeSubscribers
+  };
+}
+function rootStateSnapshot() {
+  return rootState;
+}
+function routeInfoSnapshot() {
+  return routeInfo;
+}
+function getBrowserPathname() {
+  var pathname = getSafeWindowPathname();
+  return pathname === void 0 ? void 0 : normalizeRoutePathname(pathname);
+}
+function shouldKeepPendingNavigationState(currentState) {
+  if (!pendingNavigationPathname) return false;
+  return getRouteInfo(currentState).pathname !== pendingNavigationPathname;
+}
+function shouldPreserveInitialRouteInfo(currentState) {
+  if (!initialState || !(routeInfo === null || routeInfo === void 0 ? void 0 : routeInfo.pathname)) return false;
+  var nextPathname = getRouteInfo(currentState).pathname;
+  if (nextPathname === routeInfo.pathname) return false;
+  if (nextPathname && nextPathname === pendingNavigationPathname) return false;
+  var browserPathname = getBrowserPathname();
+  if (nextPathname && browserPathname && nextPathname === browserPathname) return false;
+  return true;
+}
+function useOneRouter() {
+  return useDeferredValue(useSyncExternalStore(subscribeToStore, snapshot, snapshot));
+}
+function syncStoreRootState() {
+  if (!navigationRef) throw new Error(`No navigationRef, possible duplicate One dep`);
+  if (navigationRef.isReady()) {
+    var currentState = navigationRef.getRootState();
+    if (rootState !== currentState) {
+      if (shouldKeepPendingNavigationState(currentState)) return;
+      if (shouldPreserveInitialRouteInfo(currentState)) return;
+      updateState(currentState);
+    }
+  }
+}
+function useStoreRootState() {
+  syncStoreRootState();
+  return useDeferredValue(useSyncExternalStore(subscribeToRootState, rootStateSnapshot, rootStateSnapshot));
+}
+function useStoreRouteInfo() {
+  syncStoreRootState();
+  return useSyncExternalStore(subscribeToRootState, routeInfoSnapshot, routeInfoSnapshot);
+}
+function cleanup() {
+  if (splashScreenAnimationFrame) cancelAnimationFrame(splashScreenAnimationFrame);
+}
+var preloadingLoader = {};
+var preloadedLoaderData = {};
+var cssInjectFunctions = {};
+var preloadHistory = [];
+function getPreloadHistory() {
+  return preloadHistory;
+}
+function preloadRoute(href) {
+  arguments.length > 1 && arguments[1] !== void 0 && arguments[1];
+}
+function normalizeLoaderPath(href) {
+  return new URL(href, "http://example.com").pathname.replace(/\/index$/, "").replace(/\/$/, "") || "/";
+}
+function buildClientMatches(href, matchingNode, params, loaderData) {
+  var pathname = extractPathnameFromHref(href);
+  var routeId = (matchingNode === null || matchingNode === void 0 ? void 0 : matchingNode.contextKey) || pathname;
+  var layoutMatches = currentMatches.filter(function (m) {
+    return m.routeId.includes("_layout");
+  });
+  var pageMatch = {
+    routeId,
+    pathname,
+    params,
+    loaderData
+  };
+  return [...layoutMatches, pageMatch];
+}
+function buildNativeMatches(state, pathname, params) {
+  return findAllRouteNodesFromState(state, routeNode).map(function (node) {
+    return {
+      routeId: node.contextKey || pathname,
+      pathname,
+      params,
+      loaderData: void 0
+    };
+  });
+}
+function initClientMatches(matches) {
+  currentMatches = matches;
+  setClientMatches(matches);
+}
+async function linkTo(href, event, options) {
+  if (process.env.ONE_DEBUG_ROUTER) console.info(`[one] \u{1F517} ${event || "NAVIGATE"} ${href}`);
+  setNavigationType("soft");
+  clearNotFoundState();
+  if (href[0] === "#") return;
+  if (shouldLinkExternally(href)) {
+    openExternalURL(href);
+    return;
+  }
+  if (isVersionStale()) {
+    window.location.href = href;
+    return;
+  }
+  if (checkBlocker(href, event === "REPLACE" ? "replace" : "push")) return;
+  var protectedHref = resolveProtectedHref(href);
+  if (!protectedHref) return;
+  if (protectedHref !== href) return linkTo(protectedHref, "REPLACE", options);
+  var currentLayoutNode = routeNode;
+  var currentPath = (routeInfo === null || routeInfo === void 0 ? void 0 : routeInfo.pathname) || "/";
+  var interceptResult = findInterceptRoute(href, currentLayoutNode, currentPath);
+  if (interceptResult) {
+    var {
+      interceptRoute,
+      slotName,
+      layoutContextKey,
+      params
+    } = interceptResult;
+    var scopedSlotKey = `${layoutContextKey}:${slotName}`;
+    storeInterceptState(scopedSlotKey, interceptRoute, params);
+    updateURLWithoutNavigation(href);
+    setSlotState(scopedSlotKey, {
+      activeRouteKey: interceptRoute.contextKey,
+      activeRouteNode: interceptRoute,
+      params,
+      isIntercepted: true
+    });
+    return;
+  }
+  assertIsReady(navigationRef);
+  var current = navigationRef.current;
+  if (current == null) throw new Error("Couldn't find a navigation object. Is your component inside NavigationContainer?");
+  var linking = getResolvedLinking();
+  if (!linking) throw new Error("Attempted to link to route when no routes are present");
+  setLastAction();
+  if (href === ".." || href === "../") {
+    current.goBack();
+    return;
+  }
+  if (href.startsWith(".")) {
+    var _ref;
+    var _routeInfo_segments;
+    var base = (_ref = routeInfo === null || routeInfo === void 0 ? void 0 : (_routeInfo_segments = routeInfo.segments) === null || _routeInfo_segments === void 0 ? void 0 : _routeInfo_segments.map(function (segment) {
+      var _routeInfo_params;
+      if (!segment.startsWith("[")) return segment;
+      if (segment.startsWith("[...")) {
+        var _ref3;
+        var _routeInfo_params1, _params_split;
+        segment = segment.slice(4, -1);
+        var params3 = routeInfo === null || routeInfo === void 0 ? void 0 : (_routeInfo_params1 = routeInfo.params) === null || _routeInfo_params1 === void 0 ? void 0 : _routeInfo_params1[segment];
+        if (Array.isArray(params3)) return params3.join("/");
+        return (_ref3 = params3 === null || params3 === void 0 ? void 0 : (_params_split = params3.split(",")) === null || _params_split === void 0 ? void 0 : _params_split.join("/")) !== null && _ref3 !== void 0 ? _ref3 : "";
+      }
+      segment = segment.slice(1, -1);
+      return routeInfo === null || routeInfo === void 0 ? void 0 : (_routeInfo_params = routeInfo.params) === null || _routeInfo_params === void 0 ? void 0 : _routeInfo_params[segment];
+    }).filter(Boolean).join("/")) !== null && _ref !== void 0 ? _ref : "/";
+    if (!(routeInfo === null || routeInfo === void 0 ? void 0 : routeInfo.isIndex)) base += "/..";
+    href = resolve(base, href);
+  }
+  var 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");
+  var normalizedPreloadPath = normalizeLoaderPath(href);
+  if (!(normalizedPreloadPath in preloadedLoaderData) && !(href in preloadedLoaderData)) await preloadRoute(href, true);else if (process.env.NODE_ENV !== "development") {
+    var inject = cssInjectFunctions[href];
+    if (inject) inject().catch(function () {});
+  }
+  var preloadResult = preloadedLoaderData[normalizedPreloadPath];
+  if (preloadResult === null || preloadResult === void 0 ? void 0 : preloadResult.__oneRedirect) {
+    var redirectTarget = preloadResult.__oneRedirect;
+    delete preloadedLoaderData[normalizedPreloadPath];
+    delete preloadingLoader[normalizedPreloadPath];
+    delete preloadedLoaderData[href];
+    delete preloadingLoader[href];
+    setLoadingState("loaded");
+    linkTo(redirectTarget, "REPLACE");
+    return;
+  }
+  if ((preloadResult === null || preloadResult === void 0 ? void 0 : preloadResult.__oneError) === 404) {
+    delete preloadedLoaderData[normalizedPreloadPath];
+    delete preloadingLoader[normalizedPreloadPath];
+    delete preloadedLoaderData[href];
+    delete preloadingLoader[href];
+    setLoadingState("loaded");
+    var notFoundRoute = findNearestNotFoundRoute(href, routeNode);
+    setNotFoundState({
+      notFoundPath: preloadResult.__oneNotFoundPath || "/+not-found",
+      notFoundRouteNode: notFoundRoute || void 0,
+      originalPath: href
+    });
+    return;
+  }
+  var matchingRouteNode = findRouteNodeFromState(state, routeNode);
+  if (matchingRouteNode === null || matchingRouteNode === void 0 ? void 0 : matchingRouteNode.loadRoute) {
+    setValidationState({
+      status: "validating",
+      lastValidatedHref: href
+    });
+    try {
+      var loadedRoute = matchingRouteNode.loadRoute();
+      var params1 = extractParamsFromState(state);
+      var search = extractSearchFromHref(href);
+      var pathname = extractPathnameFromHref(href);
+      if (loadedRoute.validateParams) validateParams(loadedRoute.validateParams, params1);
+      if (loadedRoute.validateRoute) {
+        var validationResult = await loadedRoute.validateRoute({
+          params: params1,
+          search,
+          pathname,
+          href
+        });
+        if (validationResult && !validationResult.valid) {
+          var _$error = new RouteValidationError(validationResult.error || "Route validation failed", validationResult.details);
+          setValidationState({
+            status: "error",
+            error: _$error,
+            lastValidatedHref: href
+          });
+          throw _$error;
+        }
+      }
+      setValidationState({
+        status: "valid",
+        lastValidatedHref: href
+      });
+    } catch (error) {
+      if (error && typeof error.then === "function") {
+        await error.catch(function () {});
+        setValidationState({
+          status: "valid",
+          lastValidatedHref: href
+        });
+      } else if (_instanceof(error, ParamValidationError) || _instanceof(error, RouteValidationError)) {
+        setValidationState({
+          status: "error",
+          error,
+          lastValidatedHref: href
+        });
+        throw error;
+      } else throw error;
+    }
+  }
+  var loaderData = preloadedLoaderData[normalizeLoaderPath(href)];
+  var params2 = extractParamsFromState(state);
+  var newMatches = buildClientMatches(href, matchingRouteNode, params2, loaderData);
+  currentMatches = newMatches;
+  setClientMatches(newMatches);
+  if (!navigationRef.isReady()) {
+    setLoadingState("loaded");
+    return;
+  }
+  var currentRootState = navigationRef.getRootState();
+  var hash = href.indexOf("#");
+  if (currentRootState.key && hash > 0) hashes[currentRootState.key] = href.slice(hash);
+  nextOptions = options !== null && options !== void 0 ? options : null;
+  pendingNavigationPathname = stripTrailingSlash(extractPathnameFromHref(href));
+  pendingNavigationAction = event === "PUSH" || event === "REPLACE" || event === "NAVIGATE" ? event : void 0;
+  lastIntendedPathname = pendingNavigationPathname;
+  var freshRootState = navigationRef.getRootState();
+  var currentRouteBeforeDispatch = navigationRef.getCurrentRoute();
+  if (event === "REPLACE") {
+    var targetPathname = pendingNavigationPathname;
+    var optimisticState = nextOptions ? {
+      ...state,
+      linkOptions: nextOptions
+    } : state;
+    updateState(optimisticState);
+    pendingNavigationPathname = targetPathname;
+    notifyRootStateSubscribers(optimisticState);
+    navigationRef.resetRoot(state);
+  } else {
+    var _action_payload;
+    var action = getNavigateAction(state, freshRootState, event);
+    var targetName = (_action_payload = action.payload) === null || _action_payload === void 0 ? void 0 : _action_payload.name;
+    var isGroupTarget = typeof targetName === "string" && targetName.startsWith("(") && targetName.endsWith(")");
+    var hasFreshRootState = freshRootState.type === "stack";
+    var isRootTarget = action.target === freshRootState.key;
+    var currentFocusedRoute = freshRootState.routes[freshRootState.index];
+    var currentFocusedName = currentFocusedRoute === null || currentFocusedRoute === void 0 ? void 0 : currentFocusedRoute.name;
+    if (isRootTarget && isGroupTarget && hasFreshRootState) {
+      var targetRoute = state.routes[state.routes.length - 1];
+      var targetRootName = targetRoute.name;
+      if (currentFocusedName === targetRootName) {
+        var _ref1;
+        var routes = [...freshRootState.routes];
+        routes[freshRootState.index] = {
+          ...targetRoute,
+          key: (_ref1 = currentFocusedRoute === null || currentFocusedRoute === void 0 ? void 0 : currentFocusedRoute.key) !== null && _ref1 !== void 0 ? _ref1 : targetRoute.key
+        };
+        navigationRef.resetRoot({
+          ...freshRootState,
+          routes
+        });
+      } else {
+        var _ref2;
+        var existingTargetRoute = freshRootState.routes.find(function (route) {
+          return route.name === targetRootName;
+        });
+        var existingRoutes = freshRootState.routes.filter(function (route) {
+          return route.name !== targetRootName;
+        });
+        var nextRootState = {
+          ...freshRootState,
+          routes: [...existingRoutes, {
+            ...targetRoute,
+            key: (_ref2 = existingTargetRoute === null || existingTargetRoute === void 0 ? void 0 : existingTargetRoute.key) !== null && _ref2 !== void 0 ? _ref2 : `${targetRootName}-${freshRootState.key}`
+          }],
+          index: existingRoutes.length
+        };
+        navigationRef.resetRoot(nextRootState);
+      }
+    } else navigationRef.dispatch(action);
+  }
+  var warningTm;
+  var interval = setInterval(function () {
+    if (!navigationRef.isReady()) {
+      clearTimeout(warningTm);
+      clearInterval(interval);
+      return;
+    }
+    if (currentRouteBeforeDispatch !== navigationRef.getCurrentRoute()) setTimeout(function () {
+      setLoadingState("loaded");
+    });
+    clearTimeout(warningTm);
+    clearInterval(interval);
+  }, 16);
+  if (process.env.NODE_ENV === "development") warningTm = setTimeout(function () {
+    console.warn(`Routing took more than 8 seconds`);
+  }, 1e3);
+}
+var hashes = {};
+var 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 (var i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+    return true;
+  }
+  if ((typeof a === "undefined" ? "undefined" : _type_of(a)) === "object" && (typeof b === "undefined" ? "undefined" : _type_of(b)) === "object") {
+    var keysA = Object.keys(a);
+    var keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = keysA[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var key = _step.value;
+        if (!deepEqual(a[key], b[key])) return false;
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+      } finally {
+        if (_didIteratorError) throw _iteratorError;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+export { canDismiss, canGoBack, cleanup, consumePendingNavigationAction, dismiss, dismissAll, getPreloadHistory, getSafeWindowPathname2 as getSafeWindowPathname, getSortedRoutes, getValidationState, goBack, handleNavigationContainerStateChange, hasAttemptedToHideSplash, initClientMatches, initialPathname, initialState, initialize, isRouteProtected, lastIntendedPathname, linkTo, navigate, navigationRef, preloadRoute, preloadedLoaderData, preloadingLoader, push, registerProtectedRoutes, replace, resolveProtectedHref, rootComponent, rootState, rootStateSnapshot, routeInfo, routeInfoSnapshot, routeNode, setLoadingState, setParams, setValidationState, snapshot, subscribeToLoadingState, subscribeToRootState, subscribeToStore, subscribeToValidationState, unregisterProtectedRoutes, updateState, useOneRouter, useStoreRootState, useStoreRouteInfo, useValidationState };
+//# sourceMappingURL=router.native.js.map