one 1.1.308 → 1.1.310

package/dist/cjs/useLoader.cjs

@@ -0,0 +1,114 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var useLoader_exports = {};
+__export(useLoader_exports, {
+  useLoader: () => useLoader
+});
+module.exports = __toCommonJS(useLoader_exports);
+var import_react = require("react"),
+  import_cleanUrl = require("./cleanUrl.cjs"),
+  import_hooks = require("./hooks.cjs"),
+  import_href = require("./link/href.cjs"),
+  import_Route = require("./Route.cjs"),
+  import_router = require("./router/router.cjs"),
+  import_dynamicImport = require("./utils/dynamicImport.cjs"),
+  import_weakKey = require("./utils/weakKey.cjs");
+const promises = {},
+  errors = {},
+  loadedData = {};
+function useLoader(loader) {
+  const preloadedProps = globalThis.__vxrnLoaderProps__;
+  if (typeof window > "u") return useAsyncFn(loader, preloadedProps || {
+    params: (0, import_hooks.useActiveParams)()
+  });
+  const isNative = !1,
+    routeNode = (0, import_Route.useRouteNode)(),
+    params = (0, import_hooks.useParams)(),
+    pathName = "/" + (0, import_href.resolveHref)({
+      pathname: routeNode?.route || "",
+      params
+    }).replace(/index$/, ""),
+    currentPath = (isNative ? null : globalThis.__vxrntodopath) || (
+    // @zetavg: not sure why we're using `globalThis['__vxrntodopath']` here, but this breaks native when switching between tabs where the value stays with the previous path, so ignoring this on native
+    // TODO likely either not needed or needs proper path from server side
+    typeof window < "u" ? window.location?.pathname || pathName : "/"),
+    preloadedData = preloadedProps?.path === currentPath ? globalThis.__vxrnLoaderData__ : void 0,
+    currentData = (0, import_react.useRef)(preloadedData);
+  if ((0, import_react.useEffect)(() => {
+    preloadedData && (loadedData[currentPath] = preloadedData, delete globalThis.__vxrnLoaderData__);
+  }, [preloadedData]), errors[currentPath]) throw errors[currentPath];
+  const loaded = loadedData[currentPath];
+  if (typeof loaded < "u") return loaded;
+  if (!preloadedData) {
+    if (import_router.preloadingLoader[currentPath] && (typeof import_router.preloadingLoader[currentPath] == "function" && (import_router.preloadingLoader[currentPath] = import_router.preloadingLoader[currentPath]()), promises[currentPath] = import_router.preloadingLoader[currentPath].then(val => {
+      loadedData[currentPath] = val;
+    }).catch(err => {
+      console.error("Error loading loader", err), errors[currentPath] = err, delete promises[currentPath], delete import_router.preloadingLoader[currentPath];
+    })), !promises[currentPath]) {
+      const getData = async () => {
+        const loaderJSUrl = (0, import_cleanUrl.getLoaderPath)(currentPath, !0);
+        try {
+          const response = await (async () => {
+            if (isNative) {
+              const nativeLoaderJSUrl = `${loaderJSUrl}&platform=ios`;
+              try {
+                const loaderJsCodeResp = await fetch(nativeLoaderJSUrl);
+                if (!loaderJsCodeResp.ok) throw new Error(`Response not ok: ${loaderJsCodeResp.status}`);
+                const loaderJsCode = await loaderJsCodeResp.text(),
+                  result = eval(`() => { var exports = {}; ${loaderJsCode}; return exports; }`)();
+                if (typeof result.loader != "function") throw new Error("Loader code isn't exporting a `loader` function");
+                return result;
+              } catch (e) {
+                return console.error(`Error fetching loader from URL: ${nativeLoaderJSUrl}, ${e}`), {
+                  loader: () => ({})
+                };
+              }
+            }
+            return await (0, import_dynamicImport.dynamicImport)(loaderJSUrl);
+          })();
+          return loadedData[currentPath] = response.loader(), loadedData[currentPath];
+        } catch (err) {
+          return console.error(`Error calling loader: ${err}`), errors[currentPath] = err, delete promises[currentPath], null;
+        }
+      };
+      promises[currentPath] = getData();
+    }
+    throw promises[currentPath];
+  }
+  return currentData.current;
+}
+const results = /* @__PURE__ */new Map(),
+  started = /* @__PURE__ */new Map();
+function useAsyncFn(val, props) {
+  const key = (val ? (0, import_weakKey.weakKey)(val) : "") + JSON.stringify(props);
+  if (val && !started.get(key)) {
+    started.set(key, !0);
+    let next = val(props);
+    next instanceof Promise && (next = next.then(final => {
+      results.set(key, final);
+    }).catch(err => {
+      console.error("Error running loader()", err), results.set(key, void 0);
+    })), results.set(key, next);
+  }
+  const current = results.get(key);
+  if (current instanceof Promise) throw current;
+  return current;
+}

package/dist/cjs/useNavigation.cjs

@@ -0,0 +1,68 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var useNavigation_exports = {};
+__export(useNavigation_exports, {
+  resolveParentId: () => resolveParentId,
+  useNavigation: () => useNavigation
+});
+module.exports = __toCommonJS(useNavigation_exports);
+var import_native = require("@react-navigation/native"),
+  import_react = __toESM(require("react"), 1),
+  import_matchers = require("./matchers.cjs"),
+  import_Route = require("./Route.cjs");
+function useNavigation(parent) {
+  const navigation = (0, import_native.useNavigation)(),
+    contextKey = (0, import_Route.useContextKey)(),
+    normalizedParent = import_react.default.useMemo(() => {
+      if (!parent) return null;
+      const normalized = (0, import_matchers.getNameFromFilePath)(parent);
+      return parent.startsWith(".") ? relativePaths(contextKey, parent) : normalized;
+    }, [contextKey, parent]);
+  if (normalizedParent != null) {
+    const parentNavigation = navigation.getParent(normalizedParent);
+    if (!parentNavigation) throw new Error(`Could not find parent navigation with route "${parent}".` + (normalizedParent !== parent ? ` (normalized: ${normalizedParent})` : ""));
+    return parentNavigation;
+  }
+  return navigation;
+}
+function resolveParentId(contextKey, parentId) {
+  return parentId ? parentId.startsWith(".") ? (0, import_matchers.getNameFromFilePath)(relativePaths(contextKey, parentId)) : (0, import_matchers.getNameFromFilePath)(parentId) : null;
+}
+function relativePaths(from, to) {
+  const fromParts = from.split("/").filter(Boolean),
+    toParts = to.split("/").filter(Boolean);
+  for (const part of toParts) if (part === "..") {
+    if (fromParts.length === 0) throw new Error(`Cannot resolve path "${to}" relative to "${from}"`);
+    fromParts.pop();
+  } else part === "." || fromParts.push(part);
+  return "/" + fromParts.join("/");
+}

package/dist/cjs/useScreens.cjs

@@ -0,0 +1,233 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var useScreens_exports = {};
+__export(useScreens_exports, {
+  Group: () => Group,
+  Screen: () => Screen,
+  createGetIdForRoute: () => createGetIdForRoute,
+  getQualifiedRouteComponent: () => getQualifiedRouteComponent,
+  useSortedScreens: () => useSortedScreens
+});
+module.exports = __toCommonJS(useScreens_exports);
+var import_core = require("@react-navigation/core"),
+  import_react = __toESM(require("react"), 1),
+  import_Route = require("./Route.cjs"),
+  import_import_mode = __toESM(require("./import-mode/index.cjs"), 1),
+  import_sortRoutes = require("./sortRoutes.cjs"),
+  import_EmptyRoute = require("./views/EmptyRoute.cjs"),
+  import_RootErrorBoundary = require("./views/RootErrorBoundary.cjs"),
+  import_Try = require("./views/Try.cjs"),
+  import_getPageExport = require("./utils/getPageExport.cjs"),
+  import_jsx_runtime = require("react/jsx-runtime"),
+  import_react2 = require("react");
+const {
+  Screen,
+  Group
+} = (0, import_core.createNavigatorFactory)({})();
+function getSortedChildren(children, order, initialRouteName) {
+  if (!order?.length) return children.sort((0, import_sortRoutes.sortRoutesWithInitial)(initialRouteName)).map(route => ({
+    route,
+    props: {}
+  }));
+  const entries = [...children],
+    ordered = order.map(({
+      name,
+      redirect,
+      initialParams,
+      listeners,
+      options,
+      getId
+    }) => {
+      if (!entries.length) return console.warn(`[Layout children]: Too many screens defined. Route "${name}" is extraneous.`), null;
+      const matchIndex = entries.findIndex(child => child.route === name);
+      if (matchIndex === -1) return console.warn(`[Layout children]: No route named "${name}" exists in nested children:`, children.map(({
+        route
+      }) => route)), null;
+      const match = entries[matchIndex];
+      if (entries.splice(matchIndex, 1), redirect) {
+        if (typeof redirect == "string") throw new Error("Redirecting to a specific route is not supported yet.");
+        return null;
+      }
+      return {
+        route: match,
+        props: {
+          initialParams,
+          listeners,
+          options,
+          getId
+        }
+      };
+    }).filter(Boolean);
+  return ordered.push(...entries.sort((0, import_sortRoutes.sortRoutesWithInitial)(initialRouteName)).map(route => ({
+    route,
+    props: {}
+  }))), ordered;
+}
+function useSortedScreens(order) {
+  const node = (0, import_Route.useRouteNode)();
+  return import_react.default.useMemo(() => (node?.children?.length ? getSortedChildren(node.children, order, node.initialRouteName) : []).map(value => routeToScreen(value.route, value.props)), [node?.children, node?.initialRouteName, order]);
+}
+function fromImport({
+  ErrorBoundary,
+  ...component
+}) {
+  if (ErrorBoundary) return {
+    default: import_react.default.forwardRef((props, ref) => {
+      const children = import_react.default.createElement((0, import_getPageExport.getPageExport)(component) || import_EmptyRoute.EmptyRoute, {
+        ...props,
+        ref
+      });
+      return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Try.Try, {
+        catch: ErrorBoundary,
+        children
+      });
+    })
+  };
+  if (process.env.NODE_ENV !== "production") {
+    const exported = (0, import_getPageExport.getPageExport)(component);
+    if (exported && typeof exported == "object" && Object.keys(exported).length === 0) return {
+      default: import_EmptyRoute.EmptyRoute
+    };
+  }
+  return {
+    default: (0, import_getPageExport.getPageExport)(component)
+  };
+}
+const qualifiedStore = /* @__PURE__ */new WeakMap();
+function getQualifiedRouteComponent(value) {
+  if (value && qualifiedStore.has(value)) return qualifiedStore.get(value);
+  let ScreenComponent;
+  import_import_mode.default === "lazy" ? ScreenComponent = import_react.default.forwardRef((props, ref) => {
+    const [loaded, setLoaded] = (0, import_react.useState)(null);
+    if ((0, import_react.useEffect)(() => {
+      try {
+        const found = value.loadRoute();
+        found && setLoaded(found);
+      } catch (err) {
+        err instanceof Promise ? err.then(res => {
+          setLoaded(res);
+        }).catch(err2 => {
+          console.error("Error loading route", err2);
+        }) : setLoaded(err);
+      }
+    }, []), loaded) {
+      const Component = (0, import_getPageExport.getPageExport)(fromImport(loaded));
+      return (
+        // <Suspense fallback={null}>
+        /* @__PURE__ */
+        (0, import_jsx_runtime.jsx)(Component, {
+          ...props,
+          ref
+        })
+      );
+    }
+    return null;
+  }) : ScreenComponent = import_react.default.forwardRef((props, ref) => {
+    const res = value.loadRoute(),
+      Component = (0, import_getPageExport.getPageExport)(fromImport(res));
+    return (
+      // <Suspense fallback={null}>
+      /* @__PURE__ */
+      (0, import_jsx_runtime.jsx)(Component, {
+        ...props,
+        ref
+      })
+    );
+  });
+  const wrapSuspense = children => children,
+    getLoadable = (props, ref) => /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_RootErrorBoundary.RootErrorBoundary, {
+      children: wrapSuspense(/* @__PURE__ */(0, import_jsx_runtime.jsx)(ScreenComponent, {
+        ...props,
+        ref,
+        // Expose the template segment path, e.g. `(home)`, `[foo]`, `index`
+        // the intention is to make it possible to deduce shared routes.
+        segment: value.route
+      }))
+    }),
+    SuspenseFallback = ({
+      route
+    }) => ((0, import_react.useEffect)(() => {}, [route]), null),
+    QualifiedRoute = import_react.default.forwardRef(({
+      // Remove these React Navigation props to
+      // enforce usage of router hooks (where the query params are correct).
+      route,
+      navigation,
+      // Pass all other props to the component
+      ...props
+    }, ref) => {
+      const loadable = getLoadable(props, ref);
+      return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_Route.Route, {
+        node: value,
+        children: loadable
+      });
+    });
+  return QualifiedRoute.displayName = `Route(${value.route})`, qualifiedStore.set(value, QualifiedRoute), QualifiedRoute;
+}
+function createGetIdForRoute(route) {
+  const include = /* @__PURE__ */new Map();
+  if (route.dynamic) for (const segment of route.dynamic) include.set(segment.name, segment);
+  return ({
+    params = {}
+  } = {}) => {
+    const segments = [];
+    for (const dynamic of include.values()) {
+      const value = params?.[dynamic.name];
+      Array.isArray(value) && value.length > 0 ? segments.push(value.join("/")) : value && !Array.isArray(value) ? segments.push(value) : dynamic.deep ? segments.push(`[...${dynamic.name}]`) : segments.push(`[${dynamic.name}]`);
+    }
+    return segments.join("/") ?? route.contextKey;
+  };
+}
+function routeToScreen(route, {
+  options,
+  ...props
+} = {}) {
+  return /* @__PURE__ */(0, import_react2.createElement)(Screen, {
+    getId: createGetIdForRoute(route),
+    ...props,
+    name: route.route,
+    key: route.route,
+    options: args => {
+      const staticOptions = route.generated ? route.loadRoute()?.getNavOptions : null,
+        staticResult = typeof staticOptions == "function" ? staticOptions(args) : staticOptions,
+        dynamicResult = typeof options == "function" ? options?.(args) : options,
+        output = {
+          ...staticResult,
+          ...dynamicResult
+        };
+      return route.generated && (output.tabBarButton = () => null, output.drawerItemStyle = {
+        height: 0,
+        display: "none"
+      }), output;
+    },
+    getComponent: () => getQualifiedRouteComponent(route)
+  });
+}

package/dist/cjs/{useViteRoutes.js → useViteRoutes.cjs}

@@ -3,15 +3,21 @@ 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: !0 });
-}, __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__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: !0 }), mod);
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
 var useViteRoutes_exports = {};
 __export(useViteRoutes_exports, {
   globbedRoutesToRouteContext: () => globbedRoutesToRouteContext,
@@ -19,9 +25,11 @@ __export(useViteRoutes_exports, {
   useViteRoutes: () => useViteRoutes
 });
 module.exports = __toCommonJS(useViteRoutes_exports);
-var import_cleanUrl = require("./cleanUrl"), import_dynamicImport = require("./utils/dynamicImport");
+var import_cleanUrl = require("./cleanUrl.cjs"),
+  import_dynamicImport = require("./utils/dynamicImport.cjs");
 const import_meta = {};
-let lastVersion = 0, context;
+let lastVersion = 0,
+  context;
 function useViteRoutes(routes, options, version) {
   return version && version > lastVersion && (context = null, lastVersion = version), context || loadRoutes(routes, options), context;
 }
@@ -29,27 +37,32 @@ function loadRoutes(paths, options) {
   return context || (globalThis.__importMetaGlobbed = paths, context = globbedRoutesToRouteContext(paths, options), context);
 }
 function globbedRoutesToRouteContext(paths, options) {
-  const routesSync = {}, promises = {}, loadedRoutes = {}, clears = {};
-  Object.keys(paths).map((path) => {
+  const routesSync = {},
+    promises = {},
+    loadedRoutes = {},
+    clears = {};
+  Object.keys(paths).map(path => {
     if (!paths[path]) {
       console.error(`Error: Missing route at path ${path}`);
       return;
     }
-    const loadRouteFunction = paths[path], pathWithoutRelative = path.replace("/app/", "./"), shouldRewrite = typeof window < "u" && window.location && !import_meta.env.PROD, originalPath = pathWithoutRelative.slice(1).replace(/\.[jt]sx?$/, "");
+    const loadRouteFunction = paths[path],
+      pathWithoutRelative = path.replace("/app/", "./"),
+      shouldRewrite = typeof window < "u" && window.location && !import_meta.env.PROD,
+      originalPath = pathWithoutRelative.slice(1).replace(/\.[jt]sx?$/, "");
     options?.routeModes?.[originalPath] === "spa" ? (console.info(`Spa mode: ${originalPath}`), loadedRoutes[pathWithoutRelative] = () => null) : shouldRewrite ? routesSync[pathWithoutRelative] = path.includes("_layout.") || path.includes("+spa") ? loadRouteFunction : () => {
-      const realPath = (globalThis.__vxrntodopath ?? window.location.pathname).trim(), importUrl = (0, import_cleanUrl.getLoaderPath)(realPath);
+      const realPath = (globalThis.__vxrntodopath ?? window.location.pathname).trim(),
+        importUrl = (0, import_cleanUrl.getLoaderPath)(realPath);
       return (0, import_dynamicImport.dynamicImport)(importUrl);
     } : routesSync[pathWithoutRelative] = loadRouteFunction;
   });
   const moduleKeys = Object.keys(routesSync);
   function resolve(id) {
-    if (clearTimeout(clears[id]), loadedRoutes[id])
-      return loadedRoutes[id];
-    if (typeof routesSync[id] != "function")
-      return routesSync[id];
-    throw promises[id] || (promises[id] = routesSync[id]().then((val) => (loadedRoutes[id] = val, delete promises[id], clears[id] = setTimeout(() => {
+    if (clearTimeout(clears[id]), loadedRoutes[id]) return loadedRoutes[id];
+    if (typeof routesSync[id] != "function") return routesSync[id];
+    throw promises[id] || (promises[id] = routesSync[id]().then(val => (loadedRoutes[id] = val, delete promises[id], clears[id] = setTimeout(() => {
       delete loadedRoutes[id];
-    }, 500), val)).catch((err) => {
+    }, 500), val)).catch(err => {
       console.error("Error loading route", id, err, new Error().stack), loadedRoutes[id] = {
         default: () => null
         // <View
@@ -72,6 +85,5 @@ function globbedRoutesToRouteContext(paths, options) {
       }, delete promises[id];
     }), process.env.NODE_ENV === "development" && (promises[id].stack = new Error().stack)), promises[id];
   }
-  return resolve.keys = () => moduleKeys, resolve.id = "", resolve.resolve = (id) => id, resolve;
-}
-//# sourceMappingURL=useViteRoutes.js.map
+  return resolve.keys = () => moduleKeys, resolve.id = "", resolve.resolve = id => id, resolve;
+}

package/dist/cjs/utils/assertIsReady.cjs

@@ -0,0 +1,28 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var assertIsReady_exports = {};
+__export(assertIsReady_exports, {
+  assertIsReady: () => assertIsReady
+});
+module.exports = __toCommonJS(assertIsReady_exports);
+function assertIsReady(navigationRef) {
+  if (!navigationRef.isReady()) throw new Error("Attempted to navigate before mounting the Root Layout component. Ensure the Root Layout component is rendering a Slot, or other navigator on the first render.");
+}

package/dist/cjs/utils/dynamicImport.cjs

@@ -0,0 +1,27 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var dynamicImport_exports = {};
+__export(dynamicImport_exports, {
+  dynamicImport: () => dynamicImport
+});
+module.exports = __toCommonJS(dynamicImport_exports);
+const dynamicImport = path => import(/* @vite-ignore */
+path);

package/dist/cjs/utils/existsAsync.cjs

@@ -0,0 +1,33 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var existsAsync_exports = {};
+__export(existsAsync_exports, {
+  existsAsync: () => existsAsync
+});
+module.exports = __toCommonJS(existsAsync_exports);
+var import_node_fs = require("node:fs");
+const existsAsync = file => new Promise((res, rej) => {
+  try {
+    (0, import_node_fs.exists)(file, res);
+  } catch {
+    return !1;
+  }
+});

package/dist/cjs/utils/getPageExport.cjs

@@ -0,0 +1,32 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var getPageExport_exports = {};
+__export(getPageExport_exports, {
+  getPageExport: () => getPageExport
+});
+module.exports = __toCommonJS(getPageExport_exports);
+const getPageExport = exported => exported.default ||
+// because HMR fails with default exports, allow exporting something else
+// we just find the first non-loader export for now...
+(() => {
+  const nonLoader = Object.keys(exported).find(x => x !== "loader" && x[0].toUpperCase() === x[0]);
+  if (nonLoader) return exported[nonLoader];
+})();