@tanstack/react-router 0.0.1-alpha.9 → 0.0.1-beta.10

package/build/umd/index.development.js

@@ -11,7 +11,7 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('use-sync-external-store/shim')) :
   typeof define === 'function' && define.amd ? define(['exports', 'react', 'use-sync-external-store/shim'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactLocation = {}, global.React, global.shim));
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactRouter = {}, global.React, global.shim));
 })(this, (function (exports, React, shim) { 'use strict';
 
   function _interopNamespace(e) {
@@ -991,6 +991,12 @@
 
     return updater;
   }
+  function pick(parent, keys) {
+    return keys.reduce((obj, key) => {
+      obj[key] = parent[key];
+      return obj;
+    }, {});
+  }
 
   function joinPaths(paths) {
     return cleanPath(paths.filter(Boolean).join('/'));
@@ -1217,6 +1223,7 @@
     var str = decodeURIComponent(mix);
     if (str === 'false') return false;
     if (str === 'true') return true;
+    if (str.charAt(0) === '0') return str;
     return +str * 0 === 0 ? +str : str;
   }
 
@@ -1267,7 +1274,7 @@
 
     const action = router.state.actions[id] || (() => {
       router.state.actions[id] = {
-        pending: [],
+        submissions: [],
         submit: async (submission, actionOpts) => {
           var _actionOpts$invalidat;
 
@@ -1276,18 +1283,20 @@
           }
 
           const invalidate = (_actionOpts$invalidat = actionOpts == null ? void 0 : actionOpts.invalidate) != null ? _actionOpts$invalidat : true;
+
+          if (!(actionOpts != null && actionOpts.multi)) {
+            action.submissions = action.submissions.filter(d => d.isMulti);
+          }
+
           const actionState = {
             submittedAt: Date.now(),
             status: 'pending',
-            submission
+            submission,
+            isMulti: !!(actionOpts != null && actionOpts.multi)
           };
           action.current = actionState;
           action.latest = actionState;
-          action.pending.push(actionState);
-          router.state = _extends({}, router.state, {
-            currentAction: actionState,
-            latestAction: actionState
-          });
+          action.submissions.push(actionState);
           router.notify();
 
           try {
@@ -1309,11 +1318,6 @@
             actionState.error = err;
             actionState.status = 'error';
           } finally {
-            action.pending = action.pending.filter(d => d !== actionState);
-            router.removeActionQueue.push({
-              action,
-              actionState
-            });
             router.notify();
           }
         }
@@ -1321,6 +1325,40 @@
       return router.state.actions[id];
     })();
 
+    const loader = router.state.loaders[id] || (() => {
+      router.state.loaders[id] = {
+        pending: [],
+        fetch: async loaderContext => {
+          if (!route) {
+            return;
+          }
+
+          const loaderState = {
+            loadedAt: Date.now(),
+            loaderContext
+          };
+          loader.current = loaderState;
+          loader.latest = loaderState;
+          loader.pending.push(loaderState); // router.state = {
+          //   ...router.state,
+          //   currentAction: loaderState,
+          //   latestAction: loaderState,
+          // }
+
+          router.notify();
+
+          try {
+            return await (route.options.loader == null ? void 0 : route.options.loader(loaderContext));
+          } finally {
+            loader.pending = loader.pending.filter(d => d !== loaderState); // router.removeActionQueue.push({ loader, loaderState })
+
+            router.notify();
+          }
+        }
+      };
+      return router.state.loaders[id];
+    })();
+
     let route = {
       routeId: id,
       routeRouteId: routeId,
@@ -1331,6 +1369,7 @@
       childRoutes: undefined,
       parentRoute: parent,
       action,
+      loader: loader,
       buildLink: options => {
         return router.buildLink(_extends({}, options, {
           from: fullPath
@@ -1353,15 +1392,6 @@
     });
     return route;
   }
-  function cascadeLoaderData(matches) {
-    matches.forEach((match, index) => {
-      const parent = matches[index - 1];
-
-      if (parent) {
-        match.loaderData = replaceEqualDeep(match.loaderData, _extends({}, parent.loaderData, match.routeLoaderData));
-      }
-    });
-  }
 
   const rootRouteId = '__root__';
   const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId, parentPath) {
@@ -1427,6 +1457,7 @@
       isFetching: false,
       isInvalid: false,
       invalidAt: Infinity,
+      // pendingActions: [],
       getIsInvalid: () => {
         const now = Date.now();
         return routeMatch.isInvalid || routeMatch.invalidAt < now;
@@ -1466,17 +1497,6 @@
           clearTimeout(routeMatch.__.pendingMinTimeout);
           delete routeMatch.__.pendingMinPromise;
         },
-        // setParentMatch: (parentMatch?: RouteMatch) => {
-        //   routeMatch.parentMatch = parentMatch
-        // },
-        // addChildMatch: (childMatch: RouteMatch) => {
-        //   if (
-        //     routeMatch.childMatches.find((d) => d.matchId === childMatch.matchId)
-        //   ) {
-        //     return
-        //   }
-        //   routeMatch.childMatches.push(childMatch)
-        // },
         validate: () => {
           var _routeMatch$parentMat, _routeMatch$parentMat2;
 
@@ -1484,9 +1504,11 @@
           const parentSearch = (_routeMatch$parentMat = (_routeMatch$parentMat2 = routeMatch.parentMatch) == null ? void 0 : _routeMatch$parentMat2.search) != null ? _routeMatch$parentMat : router.location.search;
 
           try {
+            var _validator;
+
             const prevSearch = routeMatch.routeSearch;
             const validator = typeof routeMatch.options.validateSearch === 'object' ? routeMatch.options.validateSearch.parse : routeMatch.options.validateSearch;
-            let nextSearch = replaceEqualDeep(prevSearch, validator == null ? void 0 : validator(parentSearch)); // Invalidate route matches when search param stability changes
+            let nextSearch = replaceEqualDeep(prevSearch, (_validator = validator == null ? void 0 : validator(parentSearch)) != null ? _validator : {}); // Invalidate route matches when search param stability changes
 
             if (prevSearch !== nextSearch) {
               routeMatch.isInvalid = true;
@@ -1494,6 +1516,13 @@
 
             routeMatch.routeSearch = nextSearch;
             routeMatch.search = replaceEqualDeep(parentSearch, _extends({}, parentSearch, nextSearch));
+            elementTypes.map(async type => {
+              const routeElement = routeMatch.options[type];
+
+              if (typeof routeMatch.__[type] !== 'function') {
+                routeMatch.__[type] = routeElement;
+              }
+            });
           } catch (err) {
             console.error(err);
             const error = new Error('Invalid search params found', {
@@ -1518,9 +1547,33 @@
         routeMatch.isInvalid = true;
       },
       hasLoaders: () => {
-        return !!(route.options.loader || route.options.import || elementTypes.some(d => typeof route.options[d] === 'function'));
+        return !!(route.options.loader || elementTypes.some(d => typeof route.options[d] === 'function'));
+      },
+      load: async loaderOpts => {
+        const now = Date.now();
+        const minMaxAge = loaderOpts != null && loaderOpts.preload ? Math.max(loaderOpts == null ? void 0 : loaderOpts.maxAge, loaderOpts == null ? void 0 : loaderOpts.gcMaxAge) : 0; // If this is a preload, add it to the preload cache
+
+        if (loaderOpts != null && loaderOpts.preload && minMaxAge > 0) {
+          // If the match is currently active, don't preload it
+          if (router.state.matches.find(d => d.matchId === routeMatch.matchId)) {
+            return;
+          }
+
+          router.matchCache[routeMatch.matchId] = {
+            gc: now + loaderOpts.gcMaxAge,
+            match: routeMatch
+          };
+        } // If the match is invalid, errored or idle, trigger it to load
+
+
+        if (routeMatch.status === 'success' && routeMatch.getIsInvalid() || routeMatch.status === 'error' || routeMatch.status === 'idle') {
+          const maxAge = loaderOpts != null && loaderOpts.preload ? loaderOpts == null ? void 0 : loaderOpts.maxAge : undefined;
+          await routeMatch.fetch({
+            maxAge
+          });
+        }
       },
-      load: async opts => {
+      fetch: async opts => {
         const id = '' + Date.now() + Math.random();
         routeMatch.__.latestId = id; // If the match was in an error state, set it
         // to a loading state again. Otherwise, keep it
@@ -1538,37 +1591,16 @@
           routeMatch.isFetching = true;
           routeMatch.__.resolve = resolve;
 
-          const loaderPromise = (async () => {
-            const importer = routeMatch.options.import; // First, run any importers
-
-            if (importer) {
-              routeMatch.__.importPromise = importer({
-                params: routeMatch.params // search: routeMatch.search,
-
-              }).then(imported => {
-                routeMatch.__ = _extends({}, routeMatch.__, imported);
-              });
-            } // Wait for the importer to finish before
-            // attempting to load elements and data
-
-
-            await routeMatch.__.importPromise; // Next, load the elements and data in parallel
-
+          routeMatch.__.loaderDataPromise = (async () => {
+            // Load the elements and data in parallel
             routeMatch.__.elementsPromise = (async () => {
               // then run all element and data loaders in parallel
               // For each element type, potentially load it asynchronously
               await Promise.all(elementTypes.map(async type => {
                 const routeElement = routeMatch.options[type];
 
-                if (routeMatch.__[type]) {
-                  return;
-                }
-
-                if (typeof routeElement === 'function') {
-                  const res = await routeElement(routeMatch);
-                  routeMatch.__[type] = res;
-                } else {
-                  routeMatch.__[type] = routeMatch.options[type];
+                if (typeof routeMatch.__[type] === 'function') {
+                  routeMatch.__[type] = await router.options.createElement(routeElement);
                 }
               }));
             })();
@@ -1585,7 +1617,7 @@
                   });
 
                   if (id !== routeMatch.__.latestId) {
-                    return routeMatch.__.loaderPromise;
+                    return routeMatch.__.loadPromise;
                   }
 
                   routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
@@ -1597,7 +1629,7 @@
                 routeMatch.invalidAt = routeMatch.updatedAt + ((_ref = (_ref2 = (_opts$maxAge = opts == null ? void 0 : opts.maxAge) != null ? _opts$maxAge : routeMatch.options.loaderMaxAge) != null ? _ref2 : router.options.defaultLoaderMaxAge) != null ? _ref : 0);
               } catch (err) {
                 if (id !== routeMatch.__.latestId) {
-                  return routeMatch.__.loaderPromise;
+                  return routeMatch.__.loadPromise;
                 }
 
                 {
@@ -1614,7 +1646,7 @@
               await Promise.all([routeMatch.__.elementsPromise, routeMatch.__.dataPromise]);
 
               if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
+                return routeMatch.__.loadPromise;
               }
 
               if (routeMatch.__.pendingMinPromise) {
@@ -1623,7 +1655,7 @@
               }
             } finally {
               if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
+                return routeMatch.__.loadPromise;
               }
 
               routeMatch.__.cancelPending();
@@ -1635,16 +1667,16 @@
             }
           })();
 
-          routeMatch.__.loaderPromise = loaderPromise;
-          await loaderPromise;
+          await routeMatch.__.loaderDataPromise;
 
           if (id !== routeMatch.__.latestId) {
-            return routeMatch.__.loaderPromise;
+            return routeMatch.__.loadPromise;
           }
 
-          delete routeMatch.__.loaderPromise;
+          delete routeMatch.__.loaderDataPromise;
         });
-        return await routeMatch.__.loadPromise;
+        await routeMatch.__.loadPromise;
+        delete routeMatch.__.loadPromise;
       }
     });
 
@@ -1705,9 +1737,22 @@
 
   var _window$document;
   // Detect if we're in the DOM
-  const isServer = Boolean(typeof window === 'undefined' || !((_window$document = window.document) != null && _window$document.createElement)); // This is the default history object if none is defined
+  const isServer = typeof window === 'undefined' || !((_window$document = window.document) != null && _window$document.createElement); // This is the default history object if none is defined
 
-  const createDefaultHistory = () => !isServer ? createBrowserHistory() : createMemoryHistory();
+  const createDefaultHistory = () => isServer ? createMemoryHistory() : createBrowserHistory();
+
+  function getInitialRouterState() {
+    return {
+      status: 'idle',
+      location: null,
+      matches: [],
+      actions: {},
+      loaders: {},
+      lastUpdated: Date.now(),
+      isFetching: false,
+      isPreloading: false
+    };
+  }
 
   function createRouter(userOptions) {
     var _userOptions$stringif, _userOptions$parseSea;
@@ -1725,9 +1770,9 @@
     });
 
     let router = {
+      history,
       options: originalOptions,
       listeners: [],
-      removeActionQueue: [],
       // Resolved after construction
       basepath: '',
       routeTree: undefined,
@@ -1738,15 +1783,10 @@
       navigationPromise: Promise.resolve(),
       resolveNavigation: () => {},
       matchCache: {},
-      state: {
-        status: 'idle',
-        location: null,
-        matches: [],
-        actions: {},
-        loaderData: {},
-        lastUpdated: Date.now(),
-        isFetching: false,
-        isPreloading: false
+      state: getInitialRouterState(),
+      reset: () => {
+        router.state = getInitialRouterState();
+        router.notify();
       },
       startedLoadingAt: Date.now(),
       subscribe: listener => {
@@ -1764,24 +1804,44 @@
           isPreloading: Object.values(router.matchCache).some(d => d.match.isFetching && !router.state.matches.find(dd => dd.matchId === d.match.matchId))
         });
         cascadeLoaderData(router.state.matches);
-        router.listeners.forEach(listener => listener());
+        router.listeners.forEach(listener => listener(router));
+      },
+      dehydrateState: () => {
+        return _extends({}, pick(router.state, ['status', 'location', 'lastUpdated']), {
+          matches: router.state.matches.map(match => pick(match, ['matchId', 'status', 'routeLoaderData', 'loaderData', 'isInvalid', 'invalidAt']))
+        });
+      },
+      hydrateState: dehydratedState => {
+        // Match the routes
+        const matches = router.matchRoutes(router.location.pathname, {
+          strictParseParams: true
+        });
+        matches.forEach((match, index) => {
+          const dehydratedMatch = dehydratedState.matches[index];
+          invariant(dehydratedMatch, 'Oh no! Dehydrated route matches did not match the active state of the router 😬');
+          Object.assign(match, dehydratedMatch);
+        });
+        router.loadMatches(matches);
+        router.state = _extends({}, router.state, dehydratedState, {
+          matches
+        });
       },
       mount: () => {
-        const next = router.buildLocation({
+        const next = router.__.buildLocation({
           to: '.',
           search: true,
           hash: true
         }); // If the current location isn't updated, trigger a navigation
         // to the current location. Otherwise, load the current location.
 
+
         if (next.href !== router.location.href) {
-          router.commitLocation(next, true);
-        } else {
-          router.loadLocation();
-        }
+          router.__.commitLocation(next, true);
+        } // router.load()
+
 
-        const unsub = history.listen(event => {
-          router.loadLocation(router.parseLocation(event.location, router.location));
+        const unsub = router.history.listen(event => {
+          router.load(router.__.parseLocation(event.location, router.location));
         }); // addEventListener does not exist in React Native, but window does
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
 
@@ -1792,16 +1852,30 @@
         }
 
         return () => {
-          unsub(); // Be sure to unsubscribe if a new handler is set
+          unsub();
 
-          window.removeEventListener('visibilitychange', router.onFocus);
-          window.removeEventListener('focus', router.onFocus);
+          if (!isServer && window.removeEventListener) {
+            // Be sure to unsubscribe if a new handler is set
+            window.removeEventListener('visibilitychange', router.onFocus);
+            window.removeEventListener('focus', router.onFocus);
+          }
         };
       },
       onFocus: () => {
-        router.loadLocation();
+        router.load();
       },
       update: opts => {
+        const newHistory = (opts == null ? void 0 : opts.history) !== router.history;
+
+        if (!router.location || newHistory) {
+          if (opts != null && opts.history) {
+            router.history = opts.history;
+          }
+
+          router.location = router.__.parseLocation(router.history.location);
+          router.state.location = router.location;
+        }
+
         Object.assign(router.options, opts);
         const {
           basepath,
@@ -1811,204 +1885,30 @@
 
         if (routeConfig) {
           router.routesById = {};
-          router.routeTree = router.buildRouteTree(routeConfig);
+          router.routeTree = router.__.buildRouteTree(routeConfig);
         }
 
         return router;
       },
-      buildRouteTree: rootRouteConfig => {
-        const recurseRoutes = (routeConfigs, parent) => {
-          return routeConfigs.map(routeConfig => {
-            const routeOptions = routeConfig.options;
-            const route = createRoute(routeConfig, routeOptions, parent, router); // {
-            //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
-            //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
-            // }
-
-            const existingRoute = router.routesById[route.routeId];
-
-            if (existingRoute) {
-              {
-                console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
-              }
-
-              throw new Error();
-            }
-            router.routesById[route.routeId] = route;
-            const children = routeConfig.children;
-            route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
-            return route;
-          });
-        };
-
-        const routes = recurseRoutes([rootRouteConfig]);
-        return routes[0];
-      },
-      parseLocation: (location, previousLocation) => {
-        var _location$hash$split$;
-
-        const parsedSearch = router.options.parseSearch(location.search);
-        return {
-          pathname: location.pathname,
-          searchStr: location.search,
-          search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
-          hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
-          href: "" + location.pathname + location.search + location.hash,
-          state: location.state,
-          key: location.key
-        };
-      },
-      buildLocation: function buildLocation(dest) {
-        var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
-
-        if (dest === void 0) {
-          dest = {};
-        }
-
-        // const resolvedFrom: Location = {
-        //   ...router.location,
-        const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
-
-        let pathname = resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
-
-        const fromMatches = router.matchRoutes(router.location.pathname, {
-          strictParseParams: true
-        });
-        const toMatches = router.matchRoutes(pathname);
-
-        const prevParams = _extends({}, (_last = last(fromMatches)) == null ? void 0 : _last.params);
-
-        let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
-
-        if (nextParams) {
-          toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
-            Object.assign({}, nextParams, fn(nextParams));
-          });
-        }
-
-        pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
-
-        const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search; // Then the link/navigate function
-
-        const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
-        : dest.search ? (_functionalUpdate = functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
-        : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom filters
-        : {}; // Then post filters
-
-        const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
-        const search = replaceEqualDeep(router.location.search, postFilteredSearch);
-        const searchStr = router.options.stringifySearch(search);
-        let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
-        hash = hash ? "#" + hash : '';
-        return {
-          pathname,
-          search,
-          searchStr,
-          state: router.location.state,
-          hash,
-          href: "" + pathname + searchStr + hash,
-          key: dest.key
-        };
-      },
-      commitLocation: (next, replace) => {
-        const id = '' + Date.now() + Math.random();
-        if (router.navigateTimeout) clearTimeout(router.navigateTimeout);
-        let nextAction = 'replace';
-
-        if (!replace) {
-          nextAction = 'push';
-        }
-
-        const isSameUrl = router.parseLocation(history.location).href === next.href;
-
-        if (isSameUrl && !next.key) {
-          nextAction = 'replace';
-        }
-
-        if (nextAction === 'replace') {
-          history.replace({
-            pathname: next.pathname,
-            hash: next.hash,
-            search: next.searchStr
-          }, {
-            id
-          });
-        } else {
-          history.push({
-            pathname: next.pathname,
-            hash: next.hash,
-            search: next.searchStr
-          }, {
-            id
-          });
-        }
-
-        router.navigationPromise = new Promise(resolve => {
-          const previousNavigationResolve = router.resolveNavigation;
-
-          router.resolveNavigation = () => {
-            previousNavigationResolve();
-            resolve();
-          };
-        });
-        return router.navigationPromise;
-      },
-      buildNext: opts => {
-        const next = router.buildLocation(opts);
-        const matches = router.matchRoutes(next.pathname);
-
-        const __preSearchFilters = matches.map(match => {
-          var _match$options$preSea;
-
-          return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
-        }).flat().filter(Boolean);
-
-        const __postSearchFilters = matches.map(match => {
-          var _match$options$postSe;
-
-          return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
-        }).flat().filter(Boolean);
-
-        return router.buildLocation(_extends({}, opts, {
-          __preSearchFilters,
-          __postSearchFilters
-        }));
-      },
       cancelMatches: () => {
         var _router$state$pending, _router$state$pending2;
         [...router.state.matches, ...((_router$state$pending = (_router$state$pending2 = router.state.pending) == null ? void 0 : _router$state$pending2.matches) != null ? _router$state$pending : [])].forEach(match => {
           match.cancel();
         });
       },
-      loadLocation: async next => {
+      load: async next => {
         const id = Math.random();
         router.startedLoadingAt = id;
 
         if (next) {
           // Ingest the new location
           router.location = next;
-        } // Clear out old actions
-
-
-        router.removeActionQueue.forEach(_ref => {
-          let {
-            action,
-            actionState
-          } = _ref;
-
-          if (router.state.currentAction === actionState) {
-            router.state.currentAction = undefined;
-          }
+        } // Cancel any pending matches
 
-          if (action.current === actionState) {
-            action.current = undefined;
-          }
-        });
-        router.removeActionQueue = []; // Cancel any pending matches
 
         router.cancelMatches(); // Match the routes
 
-        const matches = router.matchRoutes(location.pathname, {
+        const matches = router.matchRoutes(router.location.pathname, {
           strictParseParams: true
         });
         router.state = _extends({}, router.state, {
@@ -2041,19 +1941,24 @@
         });
         const now = Date.now();
         exiting.forEach(d => {
-          var _ref2, _d$options$loaderGcMa, _ref3, _d$options$loaderMaxA;
+          var _ref, _d$options$loaderGcMa, _ref2, _d$options$loaderMaxA;
 
           d.__.onExit == null ? void 0 : d.__.onExit({
             params: d.params,
             search: d.routeSearch
-          }); // Clear idle error states when match leaves
+          }); // // Clear actions
+          // if (d.action) {
+          //   d.action.current = undefined
+          //   d.action.submissions = []
+          // }
+          // Clear idle error states when match leaves
 
           if (d.status === 'error' && !d.isFetching) {
             d.status = 'idle';
             d.error = undefined;
           }
 
-          const gc = Math.max((_ref2 = (_d$options$loaderGcMa = d.options.loaderGcMaxAge) != null ? _d$options$loaderGcMa : router.options.defaultLoaderGcMaxAge) != null ? _ref2 : 0, (_ref3 = (_d$options$loaderMaxA = d.options.loaderMaxAge) != null ? _d$options$loaderMaxA : router.options.defaultLoaderMaxAge) != null ? _ref3 : 0);
+          const gc = Math.max((_ref = (_d$options$loaderGcMa = d.options.loaderGcMaxAge) != null ? _d$options$loaderGcMa : router.options.defaultLoaderGcMaxAge) != null ? _ref : 0, (_ref2 = (_d$options$loaderMaxA = d.options.loaderMaxAge) != null ? _d$options$loaderMaxA : router.options.defaultLoaderMaxAge) != null ? _ref2 : 0);
 
           if (gc > 0) {
             router.matchCache[d.matchId] = {
@@ -2076,18 +1981,21 @@
             params: d.params,
             search: d.search
           });
-        });
-
-        if (matches.some(d => d.status === 'loading')) {
-          router.notify();
-          await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
-        }
+          delete router.matchCache[d.matchId];
+        }); // router.notify()
 
         if (router.startedLoadingAt !== id) {
           // Ignore side-effects of match loading
           return;
         }
 
+        matches.forEach(match => {
+          // Clear actions
+          if (match.action) {
+            match.action.current = undefined;
+            match.action.submissions = [];
+          }
+        });
         router.state = _extends({}, router.state, {
           location: router.location,
           matches,
@@ -2128,7 +2036,7 @@
         return matches;
       },
       preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
-        var _ref4, _ref5, _loaderOpts$maxAge, _ref6, _ref7, _loaderOpts$gcMaxAge;
+        var _ref3, _ref4, _loaderOpts$maxAge, _ref5, _ref6, _loaderOpts$gcMaxAge;
 
         if (navigateOpts === void 0) {
           navigateOpts = router.location;
@@ -2140,8 +2048,8 @@
         });
         await router.loadMatches(matches, {
           preload: true,
-          maxAge: (_ref4 = (_ref5 = (_loaderOpts$maxAge = loaderOpts.maxAge) != null ? _loaderOpts$maxAge : router.options.defaultPreloadMaxAge) != null ? _ref5 : router.options.defaultLoaderMaxAge) != null ? _ref4 : 0,
-          gcMaxAge: (_ref6 = (_ref7 = (_loaderOpts$gcMaxAge = loaderOpts.gcMaxAge) != null ? _loaderOpts$gcMaxAge : router.options.defaultPreloadGcMaxAge) != null ? _ref7 : router.options.defaultLoaderGcMaxAge) != null ? _ref6 : 0
+          maxAge: (_ref3 = (_ref4 = (_loaderOpts$maxAge = loaderOpts.maxAge) != null ? _loaderOpts$maxAge : router.options.defaultPreloadMaxAge) != null ? _ref4 : router.options.defaultLoaderMaxAge) != null ? _ref3 : 0,
+          gcMaxAge: (_ref5 = (_ref6 = (_loaderOpts$gcMaxAge = loaderOpts.gcMaxAge) != null ? _loaderOpts$gcMaxAge : router.options.defaultPreloadGcMaxAge) != null ? _ref6 : router.options.defaultLoaderGcMaxAge) != null ? _ref5 : 0
         });
         return matches;
       },
@@ -2235,38 +2143,20 @@
         return matches;
       },
       loadMatches: async (resolvedMatches, loaderOpts) => {
-        const now = Date.now();
-        const minMaxAge = loaderOpts != null && loaderOpts.preload ? Math.max(loaderOpts == null ? void 0 : loaderOpts.maxAge, loaderOpts == null ? void 0 : loaderOpts.gcMaxAge) : 0;
         const matchPromises = resolvedMatches.map(async match => {
           // Validate the match (loads search params etc)
-          match.__.validate(); // If this is a preload, add it to the preload cache
+          match.__.validate();
 
-
-          if (loaderOpts != null && loaderOpts.preload && minMaxAge > 0) {
-            // If the match is currently active, don't preload it
-            if (router.state.matches.find(d => d.matchId === match.matchId)) {
-              return;
-            }
-
-            router.matchCache[match.matchId] = {
-              gc: now + loaderOpts.gcMaxAge,
-              match
-            };
-          } // If the match is invalid, errored or idle, trigger it to load
-
-
-          if (match.status === 'success' && match.getIsInvalid() || match.status === 'error' || match.status === 'idle') {
-            const maxAge = loaderOpts != null && loaderOpts.preload ? loaderOpts == null ? void 0 : loaderOpts.maxAge : undefined;
-            match.load({
-              maxAge
-            });
-          }
+          match.load(loaderOpts);
 
           if (match.status === 'loading') {
             // If requested, start the pending timers
-            if (loaderOpts != null && loaderOpts.withPending) match.__.startPending(); // Wait for the first sign of activity from the match
-            // This might be completion, error, or a pending state
+            if (loaderOpts != null && loaderOpts.withPending) match.__.startPending();
+          }
 
+          if (match.__.loadPromise) {
+            // Wait for the first sign of activity from the match
+            // This might be completion, error, or a pending state
             await match.__.loadPromise;
           }
         });
@@ -2284,7 +2174,7 @@
           }
         });
       },
-      reload: () => router._navigate({
+      reload: () => router.__.navigate({
         fromCurrent: true,
         replace: true,
         search: true
@@ -2317,11 +2207,7 @@
           to: next.pathname
         }));
       },
-      _navigate: location => {
-        const next = router.buildNext(location);
-        return router.commitLocation(next, location.replace);
-      },
-      navigate: async _ref8 => {
+      navigate: async _ref7 => {
         let {
           from,
           to = '.',
@@ -2329,7 +2215,7 @@
           hash,
           replace,
           params
-        } = _ref8;
+        } = _ref7;
         // If this link simply reloads the current route,
         // make sure it has a new key so it will trigger a data refresh
         // If this `to` is a valid external URL, return
@@ -2344,7 +2230,7 @@
         } catch (e) {}
 
         invariant(!isExternal, 'Attempting to navigate to external url with router.navigate!');
-        return router._navigate({
+        return router.__.navigate({
           from: fromString,
           to: toString,
           search,
@@ -2353,8 +2239,8 @@
           params
         });
       },
-      buildLink: _ref9 => {
-        var _preload, _ref10;
+      buildLink: _ref8 => {
+        var _preload, _ref9;
 
         let {
           from,
@@ -2370,7 +2256,7 @@
           preloadGcMaxAge: userPreloadGcMaxAge,
           preloadDelay: userPreloadDelay,
           disabled
-        } = _ref9;
+        } = _ref8;
 
         // If this link simply reloads the current route,
         // make sure it has a new key so it will trigger a data refresh
@@ -2394,7 +2280,7 @@
         };
         const next = router.buildNext(nextOpts);
         preload = (_preload = preload) != null ? _preload : router.options.defaultPreload;
-        const preloadDelay = (_ref10 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref10 : 0; // Compare path/hash for matches
+        const preloadDelay = (_ref9 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref9 : 0; // Compare path/hash for matches
 
         const pathIsEqual = router.state.location.pathname === next.pathname;
         const currentPathSplit = router.state.location.pathname.split('/');
@@ -2416,7 +2302,7 @@
             } // All is well? Navigate!)
 
 
-            router._navigate(nextOpts);
+            router.__.navigate(nextOpts);
           }
         }; // The click handler
 
@@ -2467,10 +2353,169 @@
           isActive,
           disabled
         };
+      },
+      buildNext: opts => {
+        const next = router.__.buildLocation(opts);
+
+        const matches = router.matchRoutes(next.pathname);
+
+        const __preSearchFilters = matches.map(match => {
+          var _match$options$preSea;
+
+          return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
+        }).flat().filter(Boolean);
+
+        const __postSearchFilters = matches.map(match => {
+          var _match$options$postSe;
+
+          return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
+        }).flat().filter(Boolean);
+
+        return router.__.buildLocation(_extends({}, opts, {
+          __preSearchFilters,
+          __postSearchFilters
+        }));
+      },
+      __: {
+        buildRouteTree: rootRouteConfig => {
+          const recurseRoutes = (routeConfigs, parent) => {
+            return routeConfigs.map(routeConfig => {
+              const routeOptions = routeConfig.options;
+              const route = createRoute(routeConfig, routeOptions, parent, router);
+              const existingRoute = router.routesById[route.routeId];
+
+              if (existingRoute) {
+                {
+                  console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
+                }
+
+                throw new Error();
+              }
+              router.routesById[route.routeId] = route;
+              const children = routeConfig.children;
+              route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
+              return route;
+            });
+          };
+
+          const routes = recurseRoutes([rootRouteConfig]);
+          return routes[0];
+        },
+        parseLocation: (location, previousLocation) => {
+          var _location$hash$split$;
+
+          const parsedSearch = router.options.parseSearch(location.search);
+          return {
+            pathname: location.pathname,
+            searchStr: location.search,
+            search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
+            hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
+            href: "" + location.pathname + location.search + location.hash,
+            state: location.state,
+            key: location.key
+          };
+        },
+        navigate: location => {
+          const next = router.buildNext(location);
+          return router.__.commitLocation(next, location.replace);
+        },
+        buildLocation: function buildLocation(dest) {
+          var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
+
+          if (dest === void 0) {
+            dest = {};
+          }
+
+          // const resolvedFrom: Location = {
+          //   ...router.location,
+          const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
+
+          let pathname = resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
+
+          const fromMatches = router.matchRoutes(router.location.pathname, {
+            strictParseParams: true
+          });
+          const toMatches = router.matchRoutes(pathname);
+
+          const prevParams = _extends({}, (_last = last(fromMatches)) == null ? void 0 : _last.params);
+
+          let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
+
+          if (nextParams) {
+            toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
+              Object.assign({}, nextParams, fn(nextParams));
+            });
+          }
+
+          pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
+
+          const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search; // Then the link/navigate function
+
+          const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
+          : dest.search ? (_functionalUpdate = functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
+          : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom filters
+          : {}; // Then post filters
+
+          const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
+          const search = replaceEqualDeep(router.location.search, postFilteredSearch);
+          const searchStr = router.options.stringifySearch(search);
+          let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
+          hash = hash ? "#" + hash : '';
+          return {
+            pathname,
+            search,
+            searchStr,
+            state: router.location.state,
+            hash,
+            href: "" + pathname + searchStr + hash,
+            key: dest.key
+          };
+        },
+        commitLocation: (next, replace) => {
+          const id = '' + Date.now() + Math.random();
+          if (router.navigateTimeout) clearTimeout(router.navigateTimeout);
+          let nextAction = 'replace';
+
+          if (!replace) {
+            nextAction = 'push';
+          }
+
+          const isSameUrl = router.__.parseLocation(history.location).href === next.href;
+
+          if (isSameUrl && !next.key) {
+            nextAction = 'replace';
+          }
+
+          if (nextAction === 'replace') {
+            history.replace({
+              pathname: next.pathname,
+              hash: next.hash,
+              search: next.searchStr
+            }, {
+              id
+            });
+          } else {
+            history.push({
+              pathname: next.pathname,
+              hash: next.hash,
+              search: next.searchStr
+            }, {
+              id
+            });
+          }
+
+          router.navigationPromise = new Promise(resolve => {
+            const previousNavigationResolve = router.resolveNavigation;
+
+            router.resolveNavigation = () => {
+              previousNavigationResolve();
+              resolve();
+            };
+          });
+          return router.navigationPromise;
+        }
       }
     };
-    router.location = router.parseLocation(history.location);
-    router.state.location = router.location;
     router.update(userOptions); // Allow frameworks to hook into the router creation
 
     router.options.createRouter == null ? void 0 : router.options.createRouter(router);
@@ -2481,6 +2526,16 @@
     return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
   }
 
+  function cascadeLoaderData(matches) {
+    matches.forEach((match, index) => {
+      const parent = matches[index - 1];
+
+      if (parent) {
+        match.loaderData = replaceEqualDeep(match.loaderData, _extends({}, parent.loaderData, match.routeLoaderData));
+      }
+    });
+  }
+
   const _excluded = ["type", "children", "target", "activeProps", "inactiveProps", "activeOptions", "disabled", "hash", "search", "params", "to", "preload", "preloadDelay", "preloadMaxAge", "replace", "style", "className", "onClick", "onFocus", "onMouseEnter", "onMouseLeave", "onTouchStart", "onTouchEnd"],
         _excluded2 = ["pending", "caseSensitive", "children"],
         _excluded3 = ["children", "router"];
@@ -2495,12 +2550,23 @@
   }
 
   const useRouterSubscription = router => {
-    shim.useSyncExternalStore(cb => router.subscribe(() => cb()), () => router.state);
+    shim.useSyncExternalStore(cb => router.subscribe(() => cb()), () => router.state, () => router.state);
   };
 
   function createReactRouter(opts) {
     const makeRouteExt = (route, router) => {
       return {
+        useRoute: function useRoute(subRouteId) {
+          if (subRouteId === void 0) {
+            subRouteId = '.';
+          }
+
+          const resolvedRouteId = router.resolvePath(route.routeId, subRouteId);
+          const resolvedRoute = router.getRoute(resolvedRouteId);
+          useRouterSubscription(router);
+          invariant(resolvedRoute, "Could not find a route for route \"" + resolvedRouteId + "\"! Did you forget to add it to your route config?");
+          return resolvedRoute;
+        },
         linkProps: options => {
           var _functionalUpdate, _functionalUpdate2;
 
@@ -2608,24 +2674,17 @@
             useRouterSubscription(router);
             return router.state;
           },
-          useRoute: routeId => {
-            const route = router.getRoute(routeId);
-            useRouterSubscription(router);
-            invariant(route, "Could not find a route for route \"" + routeId + "\"! Did you forget to add it to your route config?");
-            return route;
-          },
-          useMatch: routeId => {
+          useMatch: (routeId, opts) => {
+            var _useMatches, _opts$strict;
+
             useRouterSubscription(router);
             invariant(routeId !== rootRouteId, "\"" + rootRouteId + "\" cannot be used with useMatch! Did you mean to useRoute(\"" + rootRouteId + "\")?");
-
-            const runtimeMatch = _useMatch();
-
+            const runtimeMatch = (_useMatches = useMatches()) == null ? void 0 : _useMatches[0];
             const match = router.state.matches.find(d => d.routeId === routeId);
-            invariant(match, "Could not find a match for route \"" + routeId + "\" being rendered in this component!");
-            invariant(runtimeMatch.routeId == (match == null ? void 0 : match.routeId), "useMatch('" + (match == null ? void 0 : match.routeId) + "') is being called in a component that is meant to render the '" + runtimeMatch.routeId + "' route. Did you mean to 'useRoute(" + (match == null ? void 0 : match.routeId) + ")' instead?");
 
-            if (!match) {
-              invariant('Match not found!');
+            if ((_opts$strict = opts == null ? void 0 : opts.strict) != null ? _opts$strict : true) {
+              invariant(match, "Could not find an active match for \"" + routeId + "\"!");
+              invariant(runtimeMatch.routeId == (match == null ? void 0 : match.routeId), "useMatch('" + (match == null ? void 0 : match.routeId) + "') is being called in a component that is meant to render the '" + runtimeMatch.routeId + "' route. Did you mean to 'useMatch(" + (match == null ? void 0 : match.routeId) + ", { strict: false })' or 'useRoute(" + (match == null ? void 0 : match.routeId) + ")' instead?");
             }
 
             return match;
@@ -2641,6 +2700,19 @@
         } = _ref;
         const routeExt = makeRouteExt(route, router);
         Object.assign(route, routeExt);
+      },
+      createElement: async element => {
+        if (typeof element === 'function') {
+          const res = await element(); // Support direct import() calls
+
+          if (typeof res === 'object' && res.default) {
+            return /*#__PURE__*/React__namespace.createElement(res.default);
+          } else {
+            return res;
+          }
+        }
+
+        return element;
       }
     }));
     return coreRouter;
@@ -2655,7 +2727,9 @@
     router.update(rest);
     useRouterSubscription(router);
     useLayoutEffect(() => {
-      return router.mount();
+      const unsub = router.mount();
+      router.load();
+      return unsub;
     }, [router]);
     return /*#__PURE__*/React__namespace.createElement(routerContext.Provider, {
       value: {
@@ -2675,61 +2749,49 @@
 
   function useMatches() {
     return React__namespace.useContext(matchesContext);
-  } // function useParentMatches(): RouteMatch[] {
-  //   const router = useRouter()
-  //   const match = useMatch()
-  //   const matches = router.state.matches
-  //   return matches.slice(
-  //     0,
-  //     matches.findIndex((d) => d.matchId === match.matchId) - 1,
-  //   )
-  // }
-
-
-  function _useMatch() {
-    var _useMatches;
-
-    return (_useMatches = useMatches()) == null ? void 0 : _useMatches[0];
   }
 
   function Outlet() {
-    var _childMatch$options$c;
+    var _match$options$catchE;
 
     const router = useRouter();
-    const [, ...matches] = useMatches();
-    const childMatch = matches[0];
-    if (!childMatch) return null;
+    const matches = useMatches().slice(1);
+    const match = matches[0];
+
+    if (!match) {
+      return null;
+    }
 
     const element = (() => {
-      var _childMatch$__$errorE, _ref4;
+      var _match$__$errorElemen, _ref4, _ref5;
 
-      if (!childMatch) {
+      if (!match) {
         return null;
       }
 
-      const errorElement = (_childMatch$__$errorE = childMatch.__.errorElement) != null ? _childMatch$__$errorE : router.options.defaultErrorElement;
+      const errorElement = (_match$__$errorElemen = match.__.errorElement) != null ? _match$__$errorElemen : router.options.defaultErrorElement;
 
-      if (childMatch.status === 'error') {
+      if (match.status === 'error') {
         if (errorElement) {
           return errorElement;
         }
 
-        if (childMatch.options.useErrorBoundary || router.options.useErrorBoundary) {
-          throw childMatch.error;
+        if (match.options.useErrorBoundary || router.options.useErrorBoundary) {
+          throw match.error;
         }
 
         return /*#__PURE__*/React__namespace.createElement(DefaultErrorBoundary, {
-          error: childMatch.error
+          error: match.error
         });
       }
 
-      if (childMatch.status === 'loading' || childMatch.status === 'idle') {
-        if (childMatch.isPending) {
-          var _childMatch$__$pendin;
+      if (match.status === 'loading' || match.status === 'idle') {
+        if (match.isPending) {
+          var _match$__$pendingElem;
 
-          const pendingElement = (_childMatch$__$pendin = childMatch.__.pendingElement) != null ? _childMatch$__$pendin : router.options.defaultPendingElement;
+          const pendingElement = (_match$__$pendingElem = match.__.pendingElement) != null ? _match$__$pendingElem : router.options.defaultPendingElement;
 
-          if (childMatch.options.pendingMs || pendingElement) {
+          if (match.options.pendingMs || pendingElement) {
             var _ref3;
 
             return (_ref3 = pendingElement) != null ? _ref3 : null;
@@ -2739,13 +2801,12 @@
         return null;
       }
 
-      return (_ref4 = childMatch.__.element) != null ? _ref4 : router.options.defaultElement;
+      return (_ref4 = (_ref5 = match.__.element) != null ? _ref5 : router.options.defaultElement) != null ? _ref4 : /*#__PURE__*/React__namespace.createElement(Outlet, null);
     })();
 
-    const catchElement = (_childMatch$options$c = childMatch == null ? void 0 : childMatch.options.catchElement) != null ? _childMatch$options$c : router.options.defaultCatchElement;
+    const catchElement = (_match$options$catchE = match == null ? void 0 : match.options.catchElement) != null ? _match$options$catchE : router.options.defaultCatchElement;
     return /*#__PURE__*/React__namespace.createElement(MatchesProvider, {
-      value: matches,
-      key: childMatch.matchId
+      value: matches
     }, /*#__PURE__*/React__namespace.createElement(CatchBoundary, {
       catchElement: catchElement
     }, element));
@@ -2757,13 +2818,6 @@
       this.state = {
         error: false
       };
-
-      this.reset = () => {
-        this.setState({
-          error: false,
-          info: false
-        });
-      };
     }
 
     componentDidCatch(error, info) {
@@ -2788,10 +2842,10 @@
 
   }
 
-  function DefaultErrorBoundary(_ref5) {
+  function DefaultErrorBoundary(_ref6) {
     let {
       error
-    } = _ref5;
+    } = _ref6;
     return /*#__PURE__*/React__namespace.createElement("div", {
       style: {
         padding: '.5rem',
@@ -2813,25 +2867,38 @@
         padding: '.5rem',
         color: 'red'
       }
-    }, error.message) : null)), /*#__PURE__*/React__namespace.createElement("div", {
-      style: {
-        height: '1rem'
-      }
-    }), /*#__PURE__*/React__namespace.createElement("div", {
-      style: {
-        fontSize: '.8em',
-        borderLeft: '3px solid rgba(127, 127, 127, 1)',
-        paddingLeft: '.5rem',
-        opacity: 0.5
-      }
-    }, "If you are the owner of this website, it's highly recommended that you configure your own custom Catch/Error boundaries for the router. You can optionally configure a boundary for each route."));
-  } // TODO: Add prompt
+    }, error.message) : null)));
+  }
+  function usePrompt(message, when) {
+    const router = useRouter();
+    React__namespace.useEffect(() => {
+      if (!when) return;
+      let unblock = router.history.block(transition => {
+        if (window.confirm(message)) {
+          unblock();
+          transition.retry();
+        } else {
+          router.location.pathname = window.location.pathname;
+        }
+      });
+      return unblock;
+    }, [when, location, message]);
+  }
+  function Prompt(_ref7) {
+    let {
+      message,
+      when,
+      children
+    } = _ref7;
+    usePrompt(message, when != null ? when : true);
+    return children != null ? children : null;
+  }
 
   exports.DefaultErrorBoundary = DefaultErrorBoundary;
   exports.MatchesProvider = MatchesProvider;
   exports.Outlet = Outlet;
+  exports.Prompt = Prompt;
   exports.RouterProvider = RouterProvider;
-  exports.cascadeLoaderData = cascadeLoaderData;
   exports.cleanPath = cleanPath;
   exports.createBrowserHistory = createBrowserHistory;
   exports.createHashHistory = createHashHistory;
@@ -2854,6 +2921,7 @@
   exports.matchPathname = matchPathname;
   exports.parsePathname = parsePathname;
   exports.parseSearchWith = parseSearchWith;
+  exports.pick = pick;
   exports.replaceEqualDeep = replaceEqualDeep;
   exports.resolvePath = resolvePath;
   exports.rootRouteId = rootRouteId;
@@ -2861,6 +2929,7 @@
   exports.trimPath = trimPath;
   exports.trimPathLeft = trimPathLeft;
   exports.trimPathRight = trimPathRight;
+  exports.usePrompt = usePrompt;
   exports.warning = warning;
 
   Object.defineProperty(exports, '__esModule', { value: true });