@tanstack/react-router 0.0.1-alpha.1 → 0.0.1-alpha.11

package/build/esm/index.js

@@ -70,23 +70,6 @@ function _extends$1() {
   return _extends$1.apply(this, arguments);
 }
 
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-  return _extends.apply(this, arguments);
-}
-
 /**
  * Actions represent the type of change to a location value.
  *
@@ -230,7 +213,7 @@ function createBrowserHistory(options) {
 
   if (index == null) {
     index = 0;
-    globalHistory.replaceState(_extends({}, globalHistory.state, {
+    globalHistory.replaceState(_extends$1({}, globalHistory.state, {
       idx: index
     }), '');
   }
@@ -245,7 +228,7 @@ function createBrowserHistory(options) {
       state = null;
     }
 
-    return readOnly(_extends({
+    return readOnly(_extends$1({
       pathname: location.pathname,
       hash: '',
       search: ''
@@ -479,7 +462,7 @@ function createHashHistory(options) {
 
   if (index == null) {
     index = 0;
-    globalHistory.replaceState(_extends({}, globalHistory.state, {
+    globalHistory.replaceState(_extends$1({}, globalHistory.state, {
       idx: index
     }), '');
   }
@@ -506,7 +489,7 @@ function createHashHistory(options) {
       state = null;
     }
 
-    return readOnly(_extends({
+    return readOnly(_extends$1({
       pathname: location.pathname,
       hash: '',
       search: ''
@@ -658,7 +641,7 @@ function createMemoryHistory(options) {
       initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,
       initialIndex = _options3.initialIndex;
   var entries = initialEntries.map(function (entry) {
-    var location = readOnly(_extends({
+    var location = readOnly(_extends$1({
       pathname: '/',
       search: '',
       hash: '',
@@ -683,7 +666,7 @@ function createMemoryHistory(options) {
       state = null;
     }
 
-    return readOnly(_extends({
+    return readOnly(_extends$1({
       pathname: location.pathname,
       search: '',
       hash: ''
@@ -880,799 +863,394 @@ function parsePath(path) {
   return parsedPath;
 }
 
-// @ts-nocheck
-// We're inlining qss here for compression's sake, but we've included it as a hard dependency for the MIT license it requires.
-function encode(obj, pfx) {
-  var k,
-      i,
-      tmp,
-      str = '';
-
-  for (k in obj) {
-    if ((tmp = obj[k]) !== void 0) {
-      if (Array.isArray(tmp)) {
-        for (i = 0; i < tmp.length; i++) {
-          str && (str += '&');
-          str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp[i]);
-        }
-      } else {
-        str && (str += '&');
-        str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp);
-      }
+var isProduction = process.env.NODE_ENV === 'production';
+var prefix = 'Invariant failed';
+function invariant(condition, message) {
+    if (condition) {
+        return;
     }
-  }
-
-  return (pfx || '') + str;
-}
-
-function toValue(mix) {
-  if (!mix) return '';
-  var str = decodeURIComponent(mix);
-  if (str === 'false') return false;
-  if (str === 'true') return true;
-  return +str * 0 === 0 ? +str : str;
-}
-
-function decode(str) {
-  var tmp,
-      k,
-      out = {},
-      arr = str.split('&');
-
-  while (tmp = arr.shift()) {
-    tmp = tmp.split('=');
-    k = tmp.shift();
-
-    if (out[k] !== void 0) {
-      out[k] = [].concat(out[k], toValue(tmp.shift()));
-    } else {
-      out[k] = toValue(tmp.shift());
+    if (isProduction) {
+        throw new Error(prefix);
     }
-  }
-
-  return out;
+    var provided = typeof message === 'function' ? message() : message;
+    var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+    throw new Error(value);
 }
 
-const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId) {
-  if (options === void 0) {
-    options = {};
-  }
-
-  if (isRoot === void 0) {
-    isRoot = true;
-  }
-
-  if (isRoot) {
-    options.path = rootRouteId;
-  } else {
-    warning(!options.path, 'Routes must have a path property.');
-  } // Strip the root from parentIds
-
+// type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+//   k: infer I,
+// ) => any
+//   ? I
+//   : never
 
-  if (parentId === rootRouteId) {
-    parentId = '';
+/**
+ * This function returns `a` if `b` is deeply equal.
+ * If not, it will replace any deeply equal children of `b` with those of `a`.
+ * This can be used for structural sharing between JSON values for example.
+ */
+function replaceEqualDeep(prev, next) {
+  if (prev === next) {
+    return prev;
   }
 
-  let path = String(isRoot ? rootRouteId : options.path); // If the path is anything other than an index path, trim it up
+  const array = Array.isArray(prev) && Array.isArray(next);
 
-  if (path !== '/') {
-    path = trimPath(path);
-  }
+  if (array || isPlainObject(prev) && isPlainObject(next)) {
+    const aSize = array ? prev.length : Object.keys(prev).length;
+    const bItems = array ? next : Object.keys(next);
+    const bSize = bItems.length;
+    const copy = array ? [] : {};
+    let equalItems = 0;
 
-  let id = joinPaths([parentId, path]);
+    for (let i = 0; i < bSize; i++) {
+      const key = array ? i : bItems[i];
+      copy[key] = replaceEqualDeep(prev[key], next[key]);
 
-  if (path === rootRouteId) {
-    path = '/';
-  }
+      if (copy[key] === prev[key]) {
+        equalItems++;
+      }
+    }
 
-  if (id !== rootRouteId) {
-    id = joinPaths(['/', id]);
+    return aSize === bSize && equalItems === aSize ? prev : copy;
   }
 
-  const fullPath = id === rootRouteId ? '/' : trimPathRight(id);
-  return {
-    id: id,
-    path: path,
-    fullPath: fullPath,
-    options: options,
-    children,
-    addChildren: cb => createRouteConfig(options, cb(childOptions => createRouteConfig(childOptions, undefined, false, id)), false, parentId)
-  };
-};
-const rootRouteId = '__root__';
-// Source
-// Detect if we're in the DOM
-const isDOM$1 = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement); // This is the default history object if none is defined
-
-const createDefaultHistory = () => isDOM$1 ? createBrowserHistory() : createMemoryHistory();
-
-function createRouter(userOptions) {
-  var _userOptions$stringif, _userOptions$parseSea;
-
-  const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
-
-  const originalOptions = _extends$1({}, userOptions, {
-    stringifySearch: (_userOptions$stringif = userOptions == null ? void 0 : userOptions.stringifySearch) != null ? _userOptions$stringif : defaultStringifySearch,
-    parseSearch: (_userOptions$parseSea = userOptions == null ? void 0 : userOptions.parseSearch) != null ? _userOptions$parseSea : defaultParseSearch
-  });
-
-  let router = {
-    options: originalOptions,
-    listeners: [],
-    // Resolved after construction
-    basepath: '',
-    routeTree: undefined,
-    routesById: {},
-    location: undefined,
-    allRouteInfo: undefined,
-    //
-    navigationPromise: Promise.resolve(),
-    resolveNavigation: () => {},
-    preloadCache: {},
-    state: {
-      status: 'idle',
-      location: null,
-      matches: [],
-      actions: {},
-      loaderData: {},
-      lastUpdated: Date.now()
-    },
-    startedLoadingAt: Date.now(),
-    subscribe: listener => {
-      router.listeners.push(listener);
-      return () => {
-        router.listeners = router.listeners.filter(x => x !== listener);
-      };
-    },
-    getRoute: id => {
-      return router.routesById[id];
-    },
-    notify: () => {
-      router.state = _extends$1({}, router.state);
-      router.listeners.forEach(listener => listener());
-    },
-    mount: () => {
-      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) {
-        return router.commitLocation(next, true);
-      } else {
-        return router.loadLocation();
-      }
-    },
-    update: opts => {
-      Object.assign(router.options, opts);
-      const {
-        basepath,
-        routeConfig
-      } = router.options;
-      router.basepath = cleanPath("/" + (basepath != null ? basepath : ''));
-
-      if (routeConfig) {
-        router.routesById = {};
-        router.routeTree = router.buildRouteTree(routeConfig);
-      }
+  return next;
+} // Copied from: https://github.com/jonschlinkert/is-plain-object
 
-      return router;
-    },
-    destroy: history.listen(event => {
-      router.loadLocation(router.parseLocation(event.location, router.location));
-    }),
-    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) {
-            if (process.env.NODE_ENV !== 'production') {
-              console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
-            }
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  } // If has modified constructor
 
-            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 ctor = o.constructor;
 
-      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 (typeof ctor === 'undefined') {
+    return true;
+  } // If has modified prototype
 
-      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;
+  const prot = ctor.prototype;
 
-      let pathname = _resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  } // If constructor does not have an Object-specific method
 
-      const fromMatches = router.matchRoutes(router.location.pathname, {
-        strictParseParams: true
-      });
-      const toMatches = router.matchRoutes(pathname);
-      const prevParams = (_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));
-        });
-      }
+  if (!prot.hasOwnProperty('isPrototypeOf')) {
+    return false;
+  } // Most likely a plain Object
 
-      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
+  return true;
+}
 
-      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
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === '[object Object]';
+}
 
-      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';
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function warning(cond, message) {
+  if (cond) {
+    if (typeof console !== 'undefined') console.warn(message);
 
-      if (!replace) {
-        nextAction = 'push';
-      }
+    try {
+      throw new Error(message);
+    } catch (_unused) {}
+  }
 
-      const isSameUrl = router.parseLocation(history.location).href === next.href;
+  return true;
+}
 
-      if (isSameUrl && !next.key) {
-        nextAction = 'replace';
-      }
+function isFunction(d) {
+  return typeof d === 'function';
+}
 
-      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
-        });
-      }
+function functionalUpdate(updater, previous) {
+  if (isFunction(updater)) {
+    return updater(previous);
+  }
 
-      router.navigationPromise = new Promise(resolve => {
-        const previousNavigationResolve = router.resolveNavigation;
+  return updater;
+}
 
-        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$1({}, 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 => {
-      const id = Math.random();
-      router.startedLoadingAt = id;
-
-      if (next) {
-        // Ingest the new location
-        router.location = next;
-      } // Cancel any pending matches
-
-
-      router.cancelMatches(); // Match the routes
-
-      const unloadedMatches = router.matchRoutes(location.pathname, {
-        strictParseParams: true
-      });
-      unloadedMatches.forEach((match, index) => {
-        const parent = unloadedMatches[index - 1];
-        const child = unloadedMatches[index + 1];
-        if (parent) match.__.setParentMatch(parent);
-        if (child) match.__.addChildMatch(child);
-      });
-      router.state = _extends$1({}, router.state, {
-        pending: {
-          matches: unloadedMatches,
-          location: router.location
-        }
-      });
-      router.notify(); // Load the matches
-
-      const matches = await router.loadMatches(unloadedMatches, {
-        withPending: true
-      });
-
-      if (router.startedLoadingAt !== id) {
-        // Ignore side-effects of match loading
-        return router.navigationPromise;
-      }
-
-      const previousMatches = router.state.matches;
-      previousMatches.filter(d => {
-        return !matches.find(dd => dd.matchId === d.matchId);
-      }).forEach(d => {
-        d.__.onExit == null ? void 0 : d.__.onExit({
-          params: d.params,
-          search: d.routeSearch
-        });
-      });
-      previousMatches.filter(d => {
-        return matches.find(dd => dd.matchId === d.matchId);
-      }).forEach(d => {
-        d.options.onTransition == null ? void 0 : d.options.onTransition({
-          params: d.params,
-          search: d.routeSearch
-        });
-      });
-      matches.filter(d => {
-        return !previousMatches.find(dd => dd.matchId === d.matchId);
-      }).forEach(d => {
-        d.__.onExit = d.options.onMatch == null ? void 0 : d.options.onMatch({
-          params: d.params,
-          search: d.search
-        });
-      });
-      router.state = _extends$1({}, router.state, {
-        location: router.location,
-        matches,
-        pending: undefined
-      });
-
-      if (matches.some(d => d.status === 'loading')) {
-        router.notify();
-        await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
-      }
-
-      if (router.startedLoadingAt !== id) {
-        // Ignore side-effects of match loading
-        return;
-      }
-
-      router.notify();
-      router.resolveNavigation();
-    },
-    cleanPreloadCache: () => {
-      const now = Date.now();
-      Object.keys(router.preloadCache).forEach(matchId => {
-        const entry = router.preloadCache[matchId]; // Don't remove loading matches
-
-        if (entry.match.status === 'loading') {
-          return;
-        } // Do not remove successful matches that are still valid
-
-
-        if (entry.match.updatedAt && entry.match.updatedAt + entry.maxAge > now) {
-          return;
-        } // Everything else gets removed
-
-
-        delete router.preloadCache[matchId];
-      });
-    },
-    loadRoute: async function loadRoute(navigateOpts, loaderOpts) {
-      if (navigateOpts === void 0) {
-        navigateOpts = router.location;
-      }
-
-      const next = router.buildNext(navigateOpts);
-      const matches = router.matchRoutes(next.pathname, {
-        strictParseParams: true
-      });
-      await router.loadMatches(matches, {
-        preload: true,
-        maxAge: loaderOpts.maxAge
-      });
-      return matches;
-    },
-    matchRoutes: (pathname, opts) => {
-      var _router$state$pending3, _router$state$pending4;
-
-      router.cleanPreloadCache();
-      const matches = [];
+function joinPaths(paths) {
+  return cleanPath(paths.filter(Boolean).join('/'));
+}
+function cleanPath(path) {
+  // remove double slashes
+  return path.replace(/\/{2,}/g, '/');
+}
+function trimPathLeft(path) {
+  return path === '/' ? path : path.replace(/^\/{1,}/, '');
+}
+function trimPathRight(path) {
+  return path === '/' ? path : path.replace(/\/{1,}$/, '');
+}
+function trimPath(path) {
+  return trimPathRight(trimPathLeft(path));
+}
+function resolvePath(basepath, base, to) {
+  base = base.replace(new RegExp("^" + basepath), '/');
+  to = to.replace(new RegExp("^" + basepath), '/');
+  let baseSegments = parsePathname(base);
+  const toSegments = parsePathname(to);
+  toSegments.forEach((toSegment, index) => {
+    if (toSegment.value === '/') {
+      if (!index) {
+        // Leading slash
+        baseSegments = [toSegment];
+      } else if (index === toSegments.length - 1) {
+        // Trailing Slash
+        baseSegments.push(toSegment);
+      } else ;
+    } else if (toSegment.value === '..') {
+      var _last;
 
-      if (!router.routeTree) {
-        return matches;
+      // Extra trailing slash? pop it off
+      if (baseSegments.length > 1 && ((_last = last(baseSegments)) == null ? void 0 : _last.value) === '/') {
+        baseSegments.pop();
       }
 
-      const existingMatches = [...router.state.matches, ...((_router$state$pending3 = (_router$state$pending4 = router.state.pending) == null ? void 0 : _router$state$pending4.matches) != null ? _router$state$pending3 : [])];
-
-      const recurse = async (routes, parentMatch) => {
-        var _parentMatch$params, _router$options$filte, _router$preloadCache$, _route$childRoutes2;
-
-        let params = (_parentMatch$params = parentMatch == null ? void 0 : parentMatch.params) != null ? _parentMatch$params : {};
-        const filteredRoutes = (_router$options$filte = router.options.filterRoutes == null ? void 0 : router.options.filterRoutes(routes)) != null ? _router$options$filte : routes;
-        const route = filteredRoutes == null ? void 0 : filteredRoutes.find(route => {
-          var _route$childRoutes, _route$options$caseSe;
-
-          const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length);
-          const matchParams = matchPathname(pathname, {
-            to: route.fullPath,
-            fuzzy,
-            caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
-          });
-
-          if (matchParams) {
-            let parsedParams;
-
-            try {
-              var _route$options$parseP;
-
-              parsedParams = (_route$options$parseP = route.options.parseParams == null ? void 0 : route.options.parseParams(matchParams)) != null ? _route$options$parseP : matchParams;
-            } catch (err) {
-              if (opts != null && opts.strictParseParams) {
-                throw err;
-              }
-            }
+      baseSegments.pop();
+    } else if (toSegment.value === '.') {
+      return;
+    } else {
+      baseSegments.push(toSegment);
+    }
+  });
+  const joined = joinPaths([basepath, ...baseSegments.map(d => d.value)]);
+  return cleanPath(joined);
+}
+function parsePathname(pathname) {
+  if (!pathname) {
+    return [];
+  }
 
-            params = _extends$1({}, params, parsedParams);
-          }
+  pathname = cleanPath(pathname);
+  const segments = [];
 
-          return !!matchParams;
-        });
+  if (pathname.slice(0, 1) === '/') {
+    pathname = pathname.substring(1);
+    segments.push({
+      type: 'pathname',
+      value: '/'
+    });
+  }
 
-        if (!route) {
-          return;
-        }
+  if (!pathname) {
+    return segments;
+  } // Remove empty segments and '.' segments
 
-        const interpolatedPath = interpolatePath(route.routePath, params);
-        const matchId = interpolatePath(route.routeId, params, true);
-        const match = existingMatches.find(d => d.matchId === matchId) || ((_router$preloadCache$ = router.preloadCache[matchId]) == null ? void 0 : _router$preloadCache$.match) || createRouteMatch(router, route, {
-          matchId,
-          params,
-          pathname: joinPaths([pathname, interpolatedPath])
-        });
-        matches.push(match);
 
-        if ((_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length) {
-          recurse(route.childRoutes, match);
-        }
+  const split = pathname.split('/').filter(Boolean);
+  segments.push(...split.map(part => {
+    if (part.startsWith('*')) {
+      return {
+        type: 'wildcard',
+        value: part
       };
+    }
 
-      recurse([router.routeTree]);
-      return matches;
-    },
-    loadMatches: async (resolvedMatches, loaderOpts) => {
-      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
-
-
-        if (loaderOpts != null && loaderOpts.preload) {
-          router.preloadCache[match.matchId] = {
-            maxAge: loaderOpts == null ? void 0 : loaderOpts.maxAge,
-            match
-          };
-        } // If the match is invalid, errored or idle, trigger it to load
-
-
-        if (match.status === 'success' && match.isInvalid || match.status === 'error' || match.status === 'idle') {
-          match.load();
-        } // 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
-
-        await match.__.loadPromise;
-      });
-      router.notify();
-      await Promise.all(matchPromises);
-      return resolvedMatches;
-    },
-    invalidateRoute: opts => {
-      var _router$state$pending5, _router$state$pending6;
-
-      const next = router.buildNext(opts);
-      const unloadedMatchIds = router.matchRoutes(next.pathname).map(d => d.matchId);
-      [...router.state.matches, ...((_router$state$pending5 = (_router$state$pending6 = router.state.pending) == null ? void 0 : _router$state$pending6.matches) != null ? _router$state$pending5 : [])].forEach(match => {
-        if (unloadedMatchIds.includes(match.matchId)) {
-          match.isInvalid = true;
-        }
-      });
-    },
-    reload: () => router._navigate({
-      fromCurrent: true,
-      replace: true,
-      search: true
-    }),
-    resolvePath: (from, path) => {
-      return _resolvePath(router.basepath, from, cleanPath(path));
-    },
-    matchRoute: (location, opts) => {
-      var _location$from;
-
-      // const location = router.buildNext(opts)
-      location = _extends$1({}, location, {
-        to: location.to ? router.resolvePath((_location$from = location.from) != null ? _location$from : '', location.to) : undefined
-      });
-      const next = router.buildNext(location);
-
-      if (opts != null && opts.pending) {
-        var _router$state$pending7;
-
-        if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
-          return false;
-        }
-
-        return !!matchPathname(router.state.pending.location.pathname, _extends$1({}, opts, {
-          to: next.pathname
-        }));
-      }
-
-      return !!matchPathname(router.state.location.pathname, _extends$1({}, opts, {
-        to: next.pathname
-      }));
-    },
-    _navigate: location => {
-      const next = router.buildNext(location);
-      return router.commitLocation(next, location.replace);
-    },
-    navigate: async _ref => {
-      let {
-        from,
-        to = '.',
-        search,
-        hash,
-        replace
-      } = _ref;
-      // 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
-      // null for LinkUtils
-      const toString = String(to);
-      const fromString = String(from);
-      let isExternal;
-
-      try {
-        new URL("" + toString);
-        isExternal = true;
-      } catch (e) {}
+    if (part.charAt(0) === ':') {
+      return {
+        type: 'param',
+        value: part
+      };
+    }
 
-      if (isExternal) {
-        if (process.env.NODE_ENV !== 'production') {
-          throw new Error('Attempting to navigate to external url with router.navigate!');
-        }
+    return {
+      type: 'pathname',
+      value: part
+    };
+  }));
 
-        return;
-      }
+  if (pathname.slice(-1) === '/') {
+    pathname = pathname.substring(1);
+    segments.push({
+      type: 'pathname',
+      value: '/'
+    });
+  }
 
-      return router._navigate({
-        from: fromString,
-        to: toString,
-        search,
-        hash
-      });
-    },
-    buildLink: _ref2 => {
-      var _preload, _ref3, _ref4;
+  return segments;
+}
+function interpolatePath(path, params, leaveWildcard) {
+  const interpolatedPathSegments = parsePathname(path);
+  return joinPaths(interpolatedPathSegments.map(segment => {
+    if (segment.value === '*' && !leaveWildcard) {
+      return '';
+    }
 
-      let {
-        from,
-        to = '.',
-        search,
-        params,
-        hash,
-        target,
-        replace,
-        activeOptions,
-        preload,
-        preloadMaxAge: userPreloadMaxAge,
-        preloadDelay: userPreloadDelay,
-        disabled
-      } = _ref2;
+    if (segment.type === 'param') {
+      var _segment$value$substr;
 
-      // 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
-      // null for LinkUtils
-      try {
-        new URL("" + to);
-        return {
-          type: 'external',
-          href: to
-        };
-      } catch (e) {}
+      return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
+    }
 
-      const nextOpts = {
-        from,
-        to,
-        search,
-        params,
-        hash,
-        replace
-      };
-      const next = router.buildNext(nextOpts);
-      preload = (_preload = preload) != null ? _preload : router.options.defaultLinkPreload;
-      const preloadMaxAge = (_ref3 = userPreloadMaxAge != null ? userPreloadMaxAge : router.options.defaultLinkPreloadMaxAge) != null ? _ref3 : 2000;
-      const preloadDelay = (_ref4 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultLinkPreloadDelay) != null ? _ref4 : 50; // Compare path/hash for matches
+    return segment.value;
+  }));
+}
+function matchPathname(currentPathname, matchLocation) {
+  const pathParams = matchByPath(currentPathname, matchLocation); // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
 
-      const pathIsEqual = router.state.location.pathname === next.pathname;
-      const currentPathSplit = router.state.location.pathname.split('/');
-      const nextPathSplit = next.pathname.split('/');
-      const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
-      const hashIsEqual = router.state.location.hash === next.hash; // Combine the matches based on user options
+  if (matchLocation.to && !pathParams) {
+    return;
+  } // if (matchLocation.search && !searchMatched) {
+  //   return
+  // }
 
-      const pathTest = activeOptions != null && activeOptions.exact ? pathIsEqual : pathIsFuzzyEqual;
-      const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true; // The final "active" test
 
-      const isActive = pathTest && hashTest; // The click handler
+  return pathParams != null ? pathParams : {};
+}
+function matchByPath(from, matchLocation) {
+  var _matchLocation$to;
 
-      const handleClick = e => {
-        if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
-          e.preventDefault();
+  const baseSegments = parsePathname(from);
+  const routeSegments = parsePathname("" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*'));
+  const params = {};
 
-          if (pathIsEqual && !search && !hash) {
-            router.invalidateRoute(nextOpts);
-          } // All is well? Navigate!)
+  let isMatch = (() => {
+    for (let i = 0; i < Math.max(baseSegments.length, routeSegments.length); i++) {
+      const baseSegment = baseSegments[i];
+      const routeSegment = routeSegments[i];
+      const isLastRouteSegment = i === routeSegments.length - 1;
+      const isLastBaseSegment = i === baseSegments.length - 1;
 
+      if (routeSegment) {
+        if (routeSegment.type === 'wildcard') {
+          if (baseSegment != null && baseSegment.value) {
+            params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
+            return true;
+          }
 
-          router._navigate(nextOpts);
+          return false;
         }
-      }; // The click handler
 
+        if (routeSegment.type === 'pathname') {
+          if (routeSegment.value === '/' && !(baseSegment != null && baseSegment.value)) {
+            return true;
+          }
 
-      const handleFocus = e => {
-        if (preload && preloadMaxAge > 0) {
-          router.loadRoute(nextOpts, {
-            maxAge: preloadMaxAge
-          });
+          if (baseSegment) {
+            if (matchLocation.caseSensitive) {
+              if (routeSegment.value !== baseSegment.value) {
+                return false;
+              }
+            } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
+              return false;
+            }
+          }
         }
-      };
 
-      const handleEnter = e => {
-        const target = e.target || {};
+        if (!baseSegment) {
+          return false;
+        }
 
-        if (preload && preloadMaxAge > 0) {
-          if (target.preloadTimeout) {
-            return;
+        if (routeSegment.type === 'param') {
+          if ((baseSegment == null ? void 0 : baseSegment.value) === '/') {
+            return false;
           }
 
-          target.preloadTimeout = setTimeout(() => {
-            target.preloadTimeout = null;
-            router.loadRoute(nextOpts, {
-              maxAge: preloadMaxAge
-            });
-          }, preloadDelay);
+          if (!baseSegment.value.startsWith(':')) {
+            params[routeSegment.value.substring(1)] = baseSegment.value;
+          }
         }
-      };
+      }
 
-      const handleLeave = e => {
-        const target = e.target || {};
+      if (isLastRouteSegment && !isLastBaseSegment) {
+        return !!matchLocation.fuzzy;
+      }
+    }
 
-        if (target.preloadTimeout) {
-          clearTimeout(target.preloadTimeout);
-          target.preloadTimeout = null;
+    return true;
+  })();
+
+  return isMatch ? params : undefined;
+}
+
+// @ts-nocheck
+// qss has been slightly modified and inlined here for our use cases (and compression's sake). We've included it as a hard dependency for MIT license attribution.
+function encode(obj, pfx) {
+  var k,
+      i,
+      tmp,
+      str = '';
+
+  for (k in obj) {
+    if ((tmp = obj[k]) !== void 0) {
+      if (Array.isArray(tmp)) {
+        for (i = 0; i < tmp.length; i++) {
+          str && (str += '&');
+          str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp[i]);
         }
-      };
+      } else {
+        str && (str += '&');
+        str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp);
+      }
+    }
+  }
 
-      return {
-        type: 'internal',
-        next,
-        handleFocus,
-        handleClick,
-        handleEnter,
-        handleLeave,
-        isActive,
-        disabled
-      };
-    },
-    __experimental__createSnapshot: () => {
-      return _extends$1({}, router.state, {
-        matches: router.state.matches.map(_ref5 => {
-          let {
-            routeLoaderData: loaderData,
-            matchId
-          } = _ref5;
-          return {
-            matchId,
-            loaderData
-          };
-        })
-      });
+  return (pfx || '') + str;
+}
+
+function toValue(mix) {
+  if (!mix) return '';
+  var str = decodeURIComponent(mix);
+  if (str === 'false') return false;
+  if (str === 'true') return true;
+  return +str * 0 === 0 ? +str : str;
+}
+
+function decode(str) {
+  var tmp,
+      k,
+      out = {},
+      arr = str.split('&');
+
+  while (tmp = arr.shift()) {
+    tmp = tmp.split('=');
+    k = tmp.shift();
+
+    if (out[k] !== void 0) {
+      out[k] = [].concat(out[k], toValue(tmp.shift()));
+    } else {
+      out[k] = toValue(tmp.shift());
     }
-  };
-  router.location = router.parseLocation(history.location); // router.state.location = __experimental__snapshot?.location ?? router.location
+  }
 
-  router.state.location = router.location;
-  router.update(userOptions); // Allow frameworks to hook into the router creation
+  return out;
+}
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
 
-  router.options.createRouter == null ? void 0 : router.options.createRouter(router); // router.mount()
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
 
-  return router;
+    return target;
+  };
+  return _extends.apply(this, arguments);
 }
+
 function createRoute(routeConfig, options, parent, router) {
-  // const id = (
-  //   options.path === rootRouteId
-  //     ? rootRouteId
-  //     : joinPaths([
-  //         parent!.id,
-  //         `${options.path?.replace(/(.)\/$/, '$1')}`,
-  //       ]).replace(new RegExp(`^${rootRouteId}`), '')
-  // ) as TRouteInfo['id']
   const {
-    id: routeId,
+    id,
+    routeId,
     path: routePath,
     fullPath
   } = routeConfig;
 
-  const action = router.state.actions[routeId] || (() => {
-    router.state.actions[routeId] = {
+  const action = router.state.actions[id] || (() => {
+    router.state.actions[id] = {
       pending: [],
       submit: async (submission, actionOpts) => {
         var _actionOpts$invalidat;
@@ -1687,10 +1265,12 @@ function createRoute(routeConfig, options, parent, router) {
           status: 'pending',
           submission
         };
+        action.current = actionState;
         action.latest = actionState;
         action.pending.push(actionState);
-        router.state = _extends$1({}, router.state, {
-          action: actionState
+        router.state = _extends({}, router.state, {
+          currentAction: actionState,
+          latestAction: actionState
         });
         router.notify();
 
@@ -1714,20 +1294,54 @@ function createRoute(routeConfig, options, parent, router) {
           actionState.status = 'error';
         } finally {
           action.pending = action.pending.filter(d => d !== actionState);
+          router.removeActionQueue.push({
+            action,
+            actionState
+          });
+          router.notify();
+        }
+      }
+    };
+    return router.state.actions[id];
+  })();
 
-          if (actionState === router.state.action) {
-            router.state.action = undefined;
-          }
+  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.actions[routeId];
+    return router.state.loaders[id];
   })();
 
   let route = {
-    routeId,
+    routeId: id,
+    routeRouteId: routeId,
     routePath,
     fullPath,
     options,
@@ -1735,18 +1349,19 @@ function createRoute(routeConfig, options, parent, router) {
     childRoutes: undefined,
     parentRoute: parent,
     action,
+    loader: loader,
     buildLink: options => {
-      return router.buildLink(_extends$1({}, options, {
+      return router.buildLink(_extends({}, options, {
         from: fullPath
       }));
     },
     navigate: options => {
-      return router.navigate(_extends$1({}, options, {
+      return router.navigate(_extends({}, options, {
         from: fullPath
       }));
     },
     matchRoute: (matchLocation, opts) => {
-      return router.matchRoute(_extends$1({}, matchLocation, {
+      return router.matchRoute(_extends({}, matchLocation, {
         from: fullPath
       }), opts);
     }
@@ -1757,8 +1372,69 @@ function createRoute(routeConfig, options, parent, router) {
   });
   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) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  if (isRoot === void 0) {
+    isRoot = true;
+  }
+
+  if (isRoot) {
+    options.path = rootRouteId;
+  } // Strip the root from parentIds
+
+
+  if (parentId === rootRouteId) {
+    parentId = '';
+  }
+
+  let path = isRoot ? rootRouteId : options.path; // If the path is anything other than an index path, trim it up
+
+  if (path && path !== '/') {
+    path = trimPath(path);
+  }
+
+  const routeId = path || options.id;
+  let id = joinPaths([parentId, routeId]);
+
+  if (path === rootRouteId) {
+    path = '/';
+  }
+
+  if (id !== rootRouteId) {
+    id = joinPaths(['/', id]);
+  }
+
+  const fullPath = id === rootRouteId ? '/' : trimPathRight(joinPaths([parentPath, path]));
+  return {
+    id: id,
+    routeId: routeId,
+    path: path,
+    fullPath: fullPath,
+    options: options,
+    children,
+    createChildren: cb => createRouteConfig(options, cb(childOptions => createRouteConfig(childOptions, undefined, false, id, fullPath)), false, parentId, parentPath),
+    addChildren: children => createRouteConfig(options, children, false, parentId, parentPath),
+    createRoute: childOptions => createRouteConfig(childOptions, undefined, false, id, fullPath)
+  };
+};
+
+const elementTypes = ['element', 'errorElement', 'catchElement', 'pendingElement'];
 function createRouteMatch(router, route, opts) {
-  const routeMatch = _extends$1({}, route, opts, {
+  const routeMatch = _extends({}, route, opts, {
     router,
     routeSearch: {},
     search: {},
@@ -1769,6 +1445,11 @@ function createRouteMatch(router, route, opts) {
     isPending: false,
     isFetching: false,
     isInvalid: false,
+    invalidAt: Infinity,
+    getIsInvalid: () => {
+      const now = Date.now();
+      return routeMatch.isInvalid || routeMatch.invalidAt < now;
+    },
     __: {
       abortController: new AbortController(),
       latestId: '',
@@ -1804,16 +1485,17 @@ function createRouteMatch(router, route, opts) {
         clearTimeout(routeMatch.__.pendingMinTimeout);
         delete routeMatch.__.pendingMinPromise;
       },
-      setParentMatch: parentMatch => {
-        routeMatch.parentMatch = parentMatch;
-      },
-      addChildMatch: childMatch => {
-        if (routeMatch.childMatches.find(d => d.matchId === childMatch.matchId)) {
-          return;
-        }
-
-        routeMatch.childMatches.push(childMatch);
-      },
+      // 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;
 
@@ -1822,14 +1504,15 @@ function createRouteMatch(router, route, opts) {
 
         try {
           const prevSearch = routeMatch.routeSearch;
-          let nextSearch = replaceEqualDeep(prevSearch, routeMatch.options.validateSearch == null ? void 0 : routeMatch.options.validateSearch(parentSearch)); // Invalidate route matches when search param stability changes
+          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
 
           if (prevSearch !== nextSearch) {
             routeMatch.isInvalid = true;
           }
 
           routeMatch.routeSearch = nextSearch;
-          routeMatch.search = replaceEqualDeep(parentSearch, _extends$1({}, parentSearch, nextSearch));
+          routeMatch.search = replaceEqualDeep(parentSearch, _extends({}, parentSearch, nextSearch));
         } catch (err) {
           console.error(err);
           const error = new Error('Invalid search params found', {
@@ -1843,501 +1526,971 @@ function createRouteMatch(router, route, opts) {
         }
       }
     },
-    cancel: () => {
-      var _routeMatch$__$abortC;
-
-      (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
-
-      routeMatch.__.cancelPending();
+    cancel: () => {
+      var _routeMatch$__$abortC;
+
+      (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
+
+      routeMatch.__.cancelPending();
+    },
+    invalidate: () => {
+      routeMatch.isInvalid = true;
+    },
+    hasLoaders: () => {
+      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;
+        routeMatch.fetch({
+          maxAge
+        });
+      }
+    },
+    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
+      // as loading or resolved
+
+      if (routeMatch.status === 'idle') {
+        routeMatch.status = 'loading';
+      } // We started loading the route, so it's no longer invalid
+
+
+      routeMatch.isInvalid = false;
+      routeMatch.__.loadPromise = new Promise(async resolve => {
+        // We are now fetching, even if it's in the background of a
+        // resolved state
+        routeMatch.isFetching = true;
+        routeMatch.__.resolve = resolve;
+
+        const loaderPromise = (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;
+              }
+
+              routeMatch.__[type] = await router.options.createElement(routeElement);
+            }));
+          })();
+
+          routeMatch.__.dataPromise = Promise.resolve().then(async () => {
+            try {
+              var _ref, _ref2, _opts$maxAge;
+
+              if (routeMatch.options.loader) {
+                const data = await routeMatch.options.loader({
+                  params: routeMatch.params,
+                  search: routeMatch.routeSearch,
+                  signal: routeMatch.__.abortController.signal
+                });
+
+                if (id !== routeMatch.__.latestId) {
+                  return routeMatch.__.loaderPromise;
+                }
+
+                routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
+              }
+
+              routeMatch.error = undefined;
+              routeMatch.status = 'success';
+              routeMatch.updatedAt = Date.now();
+              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;
+              }
+
+              if (process.env.NODE_ENV !== 'production') {
+                console.error(err);
+              }
+
+              routeMatch.error = err;
+              routeMatch.status = 'error';
+              routeMatch.updatedAt = Date.now();
+            }
+          });
+
+          try {
+            await Promise.all([routeMatch.__.elementsPromise, routeMatch.__.dataPromise]);
+
+            if (id !== routeMatch.__.latestId) {
+              return routeMatch.__.loaderPromise;
+            }
+
+            if (routeMatch.__.pendingMinPromise) {
+              await routeMatch.__.pendingMinPromise;
+              delete routeMatch.__.pendingMinPromise;
+            }
+          } finally {
+            if (id !== routeMatch.__.latestId) {
+              return routeMatch.__.loaderPromise;
+            }
+
+            routeMatch.__.cancelPending();
+
+            routeMatch.isPending = false;
+            routeMatch.isFetching = false;
+
+            routeMatch.__.notify();
+          }
+        })();
+
+        routeMatch.__.loaderPromise = loaderPromise;
+        await loaderPromise;
+
+        if (id !== routeMatch.__.latestId) {
+          return routeMatch.__.loaderPromise;
+        }
+
+        delete routeMatch.__.loaderPromise;
+      });
+      return await routeMatch.__.loadPromise;
+    }
+  });
+
+  if (!routeMatch.hasLoaders()) {
+    routeMatch.status = 'success';
+  }
+
+  return routeMatch;
+}
+
+const defaultParseSearch = parseSearchWith(JSON.parse);
+const defaultStringifySearch = stringifySearchWith(JSON.stringify);
+function parseSearchWith(parser) {
+  return searchStr => {
+    if (searchStr.substring(0, 1) === '?') {
+      searchStr = searchStr.substring(1);
+    }
+
+    let query = decode(searchStr); // Try to parse any query params that might be json
+
+    for (let key in query) {
+      const value = query[key];
+
+      if (typeof value === 'string') {
+        try {
+          query[key] = parser(value);
+        } catch (err) {//
+        }
+      }
+    }
+
+    return query;
+  };
+}
+function stringifySearchWith(stringify) {
+  return search => {
+    search = _extends({}, search);
+
+    if (search) {
+      Object.keys(search).forEach(key => {
+        const val = search[key];
+
+        if (typeof val === 'undefined' || val === undefined) {
+          delete search[key];
+        } else if (val && typeof val === 'object' && val !== null) {
+          try {
+            search[key] = stringify(val);
+          } catch (err) {// silent
+          }
+        }
+      });
+    }
+
+    const searchStr = encode(search).toString();
+    return searchStr ? "?" + searchStr : '';
+  };
+}
+
+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 createDefaultHistory = () => !isServer ? createBrowserHistory() : createMemoryHistory();
+
+function createRouter(userOptions) {
+  var _userOptions$stringif, _userOptions$parseSea;
+
+  const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
+
+  const originalOptions = _extends({
+    defaultLoaderGcMaxAge: 5 * 60 * 1000,
+    defaultLoaderMaxAge: 0,
+    defaultPreloadMaxAge: 2000,
+    defaultPreloadDelay: 50
+  }, userOptions, {
+    stringifySearch: (_userOptions$stringif = userOptions == null ? void 0 : userOptions.stringifySearch) != null ? _userOptions$stringif : defaultStringifySearch,
+    parseSearch: (_userOptions$parseSea = userOptions == null ? void 0 : userOptions.parseSearch) != null ? _userOptions$parseSea : defaultParseSearch
+  });
+
+  let router = {
+    history,
+    options: originalOptions,
+    listeners: [],
+    removeActionQueue: [],
+    // Resolved after construction
+    basepath: '',
+    routeTree: undefined,
+    routesById: {},
+    location: undefined,
+    allRouteInfo: undefined,
+    //
+    navigationPromise: Promise.resolve(),
+    resolveNavigation: () => {},
+    matchCache: {},
+    state: {
+      status: 'idle',
+      location: null,
+      matches: [],
+      actions: {},
+      loaders: {},
+      loaderData: {},
+      lastUpdated: Date.now(),
+      isFetching: false,
+      isPreloading: false
+    },
+    startedLoadingAt: Date.now(),
+    subscribe: listener => {
+      router.listeners.push(listener);
+      return () => {
+        router.listeners = router.listeners.filter(x => x !== listener);
+      };
+    },
+    getRoute: id => {
+      return router.routesById[id];
+    },
+    notify: () => {
+      router.state = _extends({}, router.state, {
+        isFetching: router.state.status === 'loading' || router.state.matches.some(d => d.isFetching),
+        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());
     },
-    load: async () => {
-      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
-      // as loading or resolved
+    mount: () => {
+      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 (routeMatch.status === 'error' || routeMatch.status === 'idle') {
-        routeMatch.status = 'loading';
-      } // We started loading the route, so it's no longer invalid
 
+      if (next.href !== router.location.href) {
+        router.__.commitLocation(next, true);
+      } else {
+        router.loadLocation();
+      }
 
-      routeMatch.isInvalid = false;
-      routeMatch.__.loadPromise = new Promise(async resolve => {
-        // We are now fetching, even if it's in the background of a
-        // resolved state
-        routeMatch.isFetching = true;
-        routeMatch.__.resolve = resolve;
+      const unsub = history.listen(event => {
+        router.loadLocation(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
 
-        const loaderPromise = (async () => {
-          const importer = routeMatch.options.import; // First, run any importers
+      if (!isServer && window.addEventListener) {
+        // Listen to visibillitychange and focus
+        window.addEventListener('visibilitychange', router.onFocus, false);
+        window.addEventListener('focus', router.onFocus, false);
+      }
 
-          if (importer) {
-            routeMatch.__.importPromise = importer({
-              params: routeMatch.params // search: routeMatch.search,
+      return () => {
+        unsub(); // Be sure to unsubscribe if a new handler is set
 
-            }).then(imported => {
-              routeMatch.__ = _extends$1({}, routeMatch.__, imported);
-            });
-          } // Wait for the importer to finish before
-          // attempting to load elements and data
+        window.removeEventListener('visibilitychange', router.onFocus);
+        window.removeEventListener('focus', router.onFocus);
+      };
+    },
+    onFocus: () => {
+      router.loadLocation();
+    },
+    update: opts => {
+      Object.assign(router.options, opts);
+      const {
+        basepath,
+        routeConfig
+      } = router.options;
+      router.basepath = cleanPath("/" + (basepath != null ? basepath : ''));
 
+      if (routeConfig) {
+        router.routesById = {};
+        router.routeTree = router.__.buildRouteTree(routeConfig);
+      }
 
-          await routeMatch.__.importPromise; // Next, load the elements and data in parallel
+      return router;
+    },
+    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 => {
+      const id = Math.random();
+      router.startedLoadingAt = id;
 
-          routeMatch.__.elementsPromise = (async () => {
-            // then run all element and data loaders in parallel
-            // For each element type, potentially load it asynchronously
-            const elementTypes = ['element', 'errorElement', 'catchElement', 'pendingElement'];
-            await Promise.all(elementTypes.map(async type => {
-              const routeElement = routeMatch.options[type];
+      if (next) {
+        // Ingest the new location
+        router.location = next;
+      } // Clear out old actions
 
-              if (routeMatch.__[type]) {
-                return;
-              }
 
-              if (typeof routeElement === 'function') {
-                const res = await routeElement(routeMatch);
-                routeMatch.__[type] = res;
-              } else {
-                routeMatch.__[type] = routeMatch.options[type];
-              }
-            }));
-          })();
+      router.removeActionQueue.forEach(_ref => {
+        let {
+          action,
+          actionState
+        } = _ref;
 
-          routeMatch.__.dataPromise = Promise.resolve().then(async () => {
-            try {
-              const data = await (routeMatch.options.loader == null ? void 0 : routeMatch.options.loader({
-                params: routeMatch.params,
-                search: routeMatch.routeSearch,
-                signal: routeMatch.__.abortController.signal
-              }));
+        if (router.state.currentAction === actionState) {
+          router.state.currentAction = undefined;
+        }
 
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
-              }
+        if (action.current === actionState) {
+          action.current = undefined;
+        }
+      });
+      router.removeActionQueue = []; // Cancel any pending matches
 
-              routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
-              cascadeLoaderData(routeMatch);
-              routeMatch.error = undefined;
-              routeMatch.status = 'success';
-              routeMatch.updatedAt = Date.now();
-            } catch (err) {
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
-              }
+      router.cancelMatches(); // Match the routes
 
-              if (process.env.NODE_ENV !== 'production') {
-                console.error(err);
-              }
+      const matches = router.matchRoutes(location.pathname, {
+        strictParseParams: true
+      });
+      router.state = _extends({}, router.state, {
+        pending: {
+          matches: matches,
+          location: router.location
+        },
+        status: 'loading'
+      });
+      router.notify(); // Load the matches
 
-              routeMatch.error = err;
-              routeMatch.status = 'error';
-              routeMatch.updatedAt = Date.now();
-            }
-          });
+      await router.loadMatches(matches, {
+        withPending: true
+      });
 
-          try {
-            await Promise.all([routeMatch.__.elementsPromise, routeMatch.__.dataPromise]);
+      if (router.startedLoadingAt !== id) {
+        // Ignore side-effects of match loading
+        return router.navigationPromise;
+      }
 
-            if (id !== routeMatch.__.latestId) {
-              return routeMatch.__.loaderPromise;
-            }
+      const previousMatches = router.state.matches;
+      const exiting = [],
+            staying = [];
+      previousMatches.forEach(d => {
+        if (matches.find(dd => dd.matchId === d.matchId)) {
+          staying.push(d);
+        } else {
+          exiting.push(d);
+        }
+      });
+      const now = Date.now();
+      exiting.forEach(d => {
+        var _ref2, _d$options$loaderGcMa, _ref3, _d$options$loaderMaxA;
 
-            if (routeMatch.__.pendingMinPromise) {
-              await routeMatch.__.pendingMinPromise;
-              delete routeMatch.__.pendingMinPromise;
-            }
-          } finally {
-            if (id !== routeMatch.__.latestId) {
-              return routeMatch.__.loaderPromise;
-            }
+        d.__.onExit == null ? void 0 : d.__.onExit({
+          params: d.params,
+          search: d.routeSearch
+        }); // Clear idle error states when match leaves
 
-            routeMatch.__.cancelPending();
+        if (d.status === 'error' && !d.isFetching) {
+          d.status = 'idle';
+          d.error = undefined;
+        }
 
-            routeMatch.isPending = false;
-            routeMatch.isFetching = false;
+        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);
 
-            routeMatch.__.notify();
-          }
-        })();
+        if (gc > 0) {
+          router.matchCache[d.matchId] = {
+            gc: gc == Infinity ? Number.MAX_SAFE_INTEGER : now + gc,
+            match: d
+          };
+        }
+      });
+      staying.forEach(d => {
+        d.options.onTransition == null ? void 0 : d.options.onTransition({
+          params: d.params,
+          search: d.routeSearch
+        });
+      });
+      const entering = matches.filter(d => {
+        return !previousMatches.find(dd => dd.matchId === d.matchId);
+      });
+      entering.forEach(d => {
+        d.__.onExit = d.options.onMatch == null ? void 0 : d.options.onMatch({
+          params: d.params,
+          search: d.search
+        });
+        delete router.matchCache[d.matchId];
+      });
 
-        routeMatch.__.loaderPromise = loaderPromise;
-        await loaderPromise;
+      if (matches.some(d => d.status === 'loading')) {
+        router.notify();
+        await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
+      }
 
-        if (id !== routeMatch.__.latestId) {
-          return routeMatch.__.loaderPromise;
-        }
+      if (router.startedLoadingAt !== id) {
+        // Ignore side-effects of match loading
+        return;
+      }
 
-        delete routeMatch.__.loaderPromise;
+      router.state = _extends({}, router.state, {
+        location: router.location,
+        matches,
+        pending: undefined,
+        status: 'idle'
       });
-      return await routeMatch.__.loadPromise;
-    }
-  });
-
-  return routeMatch;
-}
+      router.notify();
+      router.resolveNavigation();
+    },
+    cleanMatchCache: () => {
+      const now = Date.now();
+      Object.keys(router.matchCache).forEach(matchId => {
+        const entry = router.matchCache[matchId]; // Don't remove loading matches
 
-function cascadeLoaderData(routeMatch) {
-  if (routeMatch.parentMatch) {
-    routeMatch.loaderData = replaceEqualDeep(routeMatch.loaderData, _extends$1({}, routeMatch.parentMatch.loaderData, routeMatch.routeLoaderData));
-  }
+        if (entry.match.status === 'loading') {
+          return;
+        } // Do not remove successful matches that are still valid
 
-  if (routeMatch.childMatches.length) {
-    routeMatch.childMatches.forEach(childMatch => {
-      cascadeLoaderData(childMatch);
-    });
-  }
-}
 
-function matchPathname(currentPathname, matchLocation) {
-  const pathParams = matchByPath(currentPathname, matchLocation); // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
+        if (entry.gc > 0 && entry.gc > now) {
+          return;
+        } // Everything else gets removed
 
-  if (matchLocation.to && !pathParams) {
-    return;
-  } // if (matchLocation.search && !searchMatched) {
-  //   return
-  // }
 
+        delete router.matchCache[matchId];
+      });
+    },
+    loadRoute: async function loadRoute(navigateOpts) {
+      if (navigateOpts === void 0) {
+        navigateOpts = router.location;
+      }
 
-  return pathParams != null ? pathParams : {};
-}
+      const next = router.buildNext(navigateOpts);
+      const matches = router.matchRoutes(next.pathname, {
+        strictParseParams: true
+      });
+      await router.loadMatches(matches);
+      return matches;
+    },
+    preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
+      var _ref4, _ref5, _loaderOpts$maxAge, _ref6, _ref7, _loaderOpts$gcMaxAge;
 
-function interpolatePath(path, params, leaveWildcard) {
-  const interpolatedPathSegments = parsePathname(path);
-  return joinPaths(interpolatedPathSegments.map(segment => {
-    if (segment.value === '*' && !leaveWildcard) {
-      return '';
-    }
+      if (navigateOpts === void 0) {
+        navigateOpts = router.location;
+      }
 
-    if (segment.type === 'param') {
-      var _segment$value$substr;
+      const next = router.buildNext(navigateOpts);
+      const matches = router.matchRoutes(next.pathname, {
+        strictParseParams: true
+      });
+      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
+      });
+      return matches;
+    },
+    matchRoutes: (pathname, opts) => {
+      var _router$state$pending3, _router$state$pending4;
 
-      return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
-    }
+      router.cleanMatchCache();
+      const matches = [];
 
-    return segment.value;
-  }));
-}
+      if (!router.routeTree) {
+        return matches;
+      }
 
-function warning(cond, message) {
-  if (cond) {
-    if (typeof console !== 'undefined') console.warn(message);
+      const existingMatches = [...router.state.matches, ...((_router$state$pending3 = (_router$state$pending4 = router.state.pending) == null ? void 0 : _router$state$pending4.matches) != null ? _router$state$pending3 : [])];
 
-    try {
-      throw new Error(message);
-    } catch (_unused) {}
-  }
+      const recurse = async routes => {
+        var _parentMatch$params, _router$options$filte, _foundRoute$childRout;
 
-  return true;
-}
+        const parentMatch = last(matches);
+        let params = (_parentMatch$params = parentMatch == null ? void 0 : parentMatch.params) != null ? _parentMatch$params : {};
+        const filteredRoutes = (_router$options$filte = router.options.filterRoutes == null ? void 0 : router.options.filterRoutes(routes)) != null ? _router$options$filte : routes;
+        let foundRoutes = [];
 
-function isFunction(d) {
-  return typeof d === 'function';
-}
+        const findMatchInRoutes = (parentRoutes, routes) => {
+          routes.some(route => {
+            var _route$childRoutes, _route$childRoutes2, _route$options$caseSe;
 
-function functionalUpdate(updater, previous) {
-  if (isFunction(updater)) {
-    return updater(previous);
-  }
+            if (!route.routePath && (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length) {
+              return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
+            }
 
-  return updater;
-}
+            const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length);
+            const matchParams = matchPathname(pathname, {
+              to: route.fullPath,
+              fuzzy,
+              caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
+            });
 
-function joinPaths(paths) {
-  return cleanPath(paths.filter(Boolean).join('/'));
-}
+            if (matchParams) {
+              let parsedParams;
 
-function cleanPath(path) {
-  // remove double slashes
-  return path.replace(/\/{2,}/g, '/');
-}
+              try {
+                var _route$options$parseP;
 
-function trimPathLeft(path) {
-  return path === '/' ? path : path.replace(/^\/{1,}/, '');
-}
+                parsedParams = (_route$options$parseP = route.options.parseParams == null ? void 0 : route.options.parseParams(matchParams)) != null ? _route$options$parseP : matchParams;
+              } catch (err) {
+                if (opts != null && opts.strictParseParams) {
+                  throw err;
+                }
+              }
 
-function trimPathRight(path) {
-  return path === '/' ? path : path.replace(/\/{1,}$/, '');
-}
+              params = _extends({}, params, parsedParams);
+            }
 
-function trimPath(path) {
-  return trimPathRight(trimPathLeft(path));
-}
+            if (!!matchParams) {
+              foundRoutes = [...parentRoutes, route];
+            }
 
-function matchByPath(from, matchLocation) {
-  var _matchLocation$to;
+            return !!foundRoutes.length;
+          });
+          return !!foundRoutes.length;
+        };
 
-  const baseSegments = parsePathname(from);
-  const routeSegments = parsePathname("" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*'));
-  const params = {};
+        findMatchInRoutes([], filteredRoutes);
 
-  let isMatch = (() => {
-    for (let i = 0; i < Math.max(baseSegments.length, routeSegments.length); i++) {
-      const baseSegment = baseSegments[i];
-      const routeSegment = routeSegments[i];
-      const isLastRouteSegment = i === routeSegments.length - 1;
-      const isLastBaseSegment = i === baseSegments.length - 1;
+        if (!foundRoutes.length) {
+          return;
+        }
 
-      if (routeSegment) {
-        if (routeSegment.type === 'wildcard') {
-          if (baseSegment != null && baseSegment.value) {
-            params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
-            return true;
-          }
+        foundRoutes.forEach(foundRoute => {
+          var _router$matchCache$ma;
 
-          return false;
+          const interpolatedPath = interpolatePath(foundRoute.routePath, params);
+          const matchId = interpolatePath(foundRoute.routeId, params, true);
+          const match = existingMatches.find(d => d.matchId === matchId) || ((_router$matchCache$ma = router.matchCache[matchId]) == null ? void 0 : _router$matchCache$ma.match) || createRouteMatch(router, foundRoute, {
+            matchId,
+            params,
+            pathname: joinPaths([pathname, interpolatedPath])
+          });
+          matches.push(match);
+        });
+        const foundRoute = last(foundRoutes);
+
+        if ((_foundRoute$childRout = foundRoute.childRoutes) != null && _foundRoute$childRout.length) {
+          recurse(foundRoute.childRoutes);
         }
+      };
 
-        if (routeSegment.type === 'pathname') {
-          if (routeSegment.value === '/' && !(baseSegment != null && baseSegment.value)) {
-            return true;
-          }
+      recurse([router.routeTree]);
+      cascadeLoaderData(matches);
+      return matches;
+    },
+    loadMatches: async (resolvedMatches, loaderOpts) => {
+      const matchPromises = resolvedMatches.map(async match => {
+        // Validate the match (loads search params etc)
+        match.__.validate();
 
-          if (baseSegment) {
-            if (matchLocation.caseSensitive) {
-              if (routeSegment.value !== baseSegment.value) {
-                return false;
-              }
-            } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
-              return false;
-            }
-          }
+        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
+
+          await match.__.loadPromise;
         }
+      });
+      router.notify();
+      await Promise.all(matchPromises);
+    },
+    invalidateRoute: opts => {
+      var _router$state$pending5, _router$state$pending6;
 
-        if (!baseSegment) {
-          return false;
+      const next = router.buildNext(opts);
+      const unloadedMatchIds = router.matchRoutes(next.pathname).map(d => d.matchId);
+      [...router.state.matches, ...((_router$state$pending5 = (_router$state$pending6 = router.state.pending) == null ? void 0 : _router$state$pending6.matches) != null ? _router$state$pending5 : [])].forEach(match => {
+        if (unloadedMatchIds.includes(match.matchId)) {
+          match.invalidate();
         }
+      });
+    },
+    reload: () => router.__.navigate({
+      fromCurrent: true,
+      replace: true,
+      search: true
+    }),
+    resolvePath: (from, path) => {
+      return resolvePath(router.basepath, from, cleanPath(path));
+    },
+    matchRoute: (location, opts) => {
+      var _location$from;
 
-        if (routeSegment.type === 'param') {
-          if ((baseSegment == null ? void 0 : baseSegment.value) === '/') {
-            return false;
-          }
+      // const location = router.buildNext(opts)
+      location = _extends({}, location, {
+        to: location.to ? router.resolvePath((_location$from = location.from) != null ? _location$from : '', location.to) : undefined
+      });
+      const next = router.buildNext(location);
 
-          if (!baseSegment.value.startsWith(':')) {
-            params[routeSegment.value.substring(1)] = baseSegment.value;
-          }
+      if (opts != null && opts.pending) {
+        var _router$state$pending7;
+
+        if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
+          return false;
         }
-      }
 
-      if (isLastRouteSegment && !isLastBaseSegment) {
-        return !!matchLocation.fuzzy;
+        return !!matchPathname(router.state.pending.location.pathname, _extends({}, opts, {
+          to: next.pathname
+        }));
       }
-    }
 
-    return true;
-  })();
+      return !!matchPathname(router.state.location.pathname, _extends({}, opts, {
+        to: next.pathname
+      }));
+    },
+    navigate: async _ref8 => {
+      let {
+        from,
+        to = '.',
+        search,
+        hash,
+        replace,
+        params
+      } = _ref8;
+      // 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
+      // null for LinkUtils
+      const toString = String(to);
+      const fromString = String(from);
+      let isExternal;
 
-  return isMatch ? params : undefined;
-} // function matchBySearch(
-//   search: SearchSchema,
-//   matchLocation: MatchLocation,
-// ) {
-//   return !!(matchLocation.search && matchLocation.search(search))
-// }
+      try {
+        new URL("" + toString);
+        isExternal = true;
+      } catch (e) {}
 
-function parsePathname(pathname) {
-  if (!pathname) {
-    return [];
-  }
+      invariant(!isExternal, 'Attempting to navigate to external url with router.navigate!');
+      return router.__.navigate({
+        from: fromString,
+        to: toString,
+        search,
+        hash,
+        replace,
+        params
+      });
+    },
+    buildLink: _ref9 => {
+      var _preload, _ref10;
 
-  pathname = cleanPath(pathname);
-  const segments = [];
+      let {
+        from,
+        to = '.',
+        search,
+        params,
+        hash,
+        target,
+        replace,
+        activeOptions,
+        preload,
+        preloadMaxAge: userPreloadMaxAge,
+        preloadGcMaxAge: userPreloadGcMaxAge,
+        preloadDelay: userPreloadDelay,
+        disabled
+      } = _ref9;
 
-  if (pathname.slice(0, 1) === '/') {
-    pathname = pathname.substring(1);
-    segments.push({
-      type: 'pathname',
-      value: '/'
-    });
-  }
+      // 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
+      // null for LinkUtils
+      try {
+        new URL("" + to);
+        return {
+          type: 'external',
+          href: to
+        };
+      } catch (e) {}
 
-  if (!pathname) {
-    return segments;
-  } // Remove empty segments and '.' segments
+      const nextOpts = {
+        from,
+        to,
+        search,
+        params,
+        hash,
+        replace
+      };
+      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 pathIsEqual = router.state.location.pathname === next.pathname;
+      const currentPathSplit = router.state.location.pathname.split('/');
+      const nextPathSplit = next.pathname.split('/');
+      const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
+      const hashIsEqual = router.state.location.hash === next.hash; // Combine the matches based on user options
 
-  const split = pathname.split('/').filter(Boolean);
-  segments.push(...split.map(part => {
-    if (part.startsWith('*')) {
-      return {
-        type: 'wildcard',
-        value: part
-      };
-    }
+      const pathTest = activeOptions != null && activeOptions.exact ? pathIsEqual : pathIsFuzzyEqual;
+      const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true; // The final "active" test
 
-    if (part.charAt(0) === ':') {
-      return {
-        type: 'param',
-        value: part
-      };
-    }
+      const isActive = pathTest && hashTest; // The click handler
 
-    return {
-      type: 'pathname',
-      value: part
-    };
-  }));
+      const handleClick = e => {
+        if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
+          e.preventDefault();
 
-  if (pathname.slice(-1) === '/') {
-    pathname = pathname.substring(1);
-    segments.push({
-      type: 'pathname',
-      value: '/'
-    });
-  }
+          if (pathIsEqual && !search && !hash) {
+            router.invalidateRoute(nextOpts);
+          } // All is well? Navigate!)
 
-  return segments;
-}
 
-function _resolvePath(basepath, base, to) {
-  base = base.replace(new RegExp("^" + basepath), '/');
-  to = to.replace(new RegExp("^" + basepath), '/');
-  let baseSegments = parsePathname(base);
-  const toSegments = parsePathname(to);
-  toSegments.forEach((toSegment, index) => {
-    if (toSegment.value === '/') {
-      if (!index) {
-        // Leading slash
-        baseSegments = [toSegment];
-      } else if (index === toSegments.length - 1) {
-        // Trailing Slash
-        baseSegments.push(toSegment);
-      } else ;
-    } else if (toSegment.value === '..') {
-      var _last2;
+          router.__.navigate(nextOpts);
+        }
+      }; // The click handler
+
+
+      const handleFocus = e => {
+        if (preload) {
+          router.preloadRoute(nextOpts, {
+            maxAge: userPreloadMaxAge,
+            gcMaxAge: userPreloadGcMaxAge
+          });
+        }
+      };
+
+      const handleEnter = e => {
+        const target = e.target || {};
+
+        if (preload) {
+          if (target.preloadTimeout) {
+            return;
+          }
+
+          target.preloadTimeout = setTimeout(() => {
+            target.preloadTimeout = null;
+            router.preloadRoute(nextOpts, {
+              maxAge: userPreloadMaxAge,
+              gcMaxAge: userPreloadGcMaxAge
+            });
+          }, preloadDelay);
+        }
+      };
 
-      // Extra trailing slash? pop it off
-      if (baseSegments.length > 1 && ((_last2 = last(baseSegments)) == null ? void 0 : _last2.value) === '/') {
-        baseSegments.pop();
-      }
+      const handleLeave = e => {
+        const target = e.target || {};
 
-      baseSegments.pop();
-    } else if (toSegment.value === '.') {
-      return;
-    } else {
-      baseSegments.push(toSegment);
-    }
-  });
-  const joined = joinPaths([basepath, ...baseSegments.map(d => d.value)]);
-  return cleanPath(joined);
-}
-function replaceEqualDeep(prev, next) {
-  if (prev === next) {
-    return prev;
-  }
+        if (target.preloadTimeout) {
+          clearTimeout(target.preloadTimeout);
+          target.preloadTimeout = null;
+        }
+      };
 
-  const array = Array.isArray(prev) && Array.isArray(next);
+      return {
+        type: 'internal',
+        next,
+        handleFocus,
+        handleClick,
+        handleEnter,
+        handleLeave,
+        isActive,
+        disabled
+      };
+    },
+    buildNext: opts => {
+      const next = router.__.buildLocation(opts);
 
-  if (array || isPlainObject(prev) && isPlainObject(next)) {
-    const aSize = array ? prev.length : Object.keys(prev).length;
-    const bItems = array ? next : Object.keys(next);
-    const bSize = bItems.length;
-    const copy = array ? [] : {};
-    let equalItems = 0;
+      const matches = router.matchRoutes(next.pathname);
 
-    for (let i = 0; i < bSize; i++) {
-      const key = array ? i : bItems[i];
-      copy[key] = replaceEqualDeep(prev[key], next[key]);
+      const __preSearchFilters = matches.map(match => {
+        var _match$options$preSea;
 
-      if (copy[key] === prev[key]) {
-        equalItems++;
-      }
-    }
+        return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
+      }).flat().filter(Boolean);
 
-    return aSize === bSize && equalItems === aSize ? prev : copy;
-  }
+      const __postSearchFilters = matches.map(match => {
+        var _match$options$postSe;
 
-  return next;
-} // Copied from: https://github.com/jonschlinkert/is-plain-object
+        return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
+      }).flat().filter(Boolean);
 
-function isPlainObject(o) {
-  if (!hasObjectPrototype(o)) {
-    return false;
-  } // If has modified constructor
+      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); // {
+            //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
+            //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
+            // }
+
+            const existingRoute = router.routesById[route.routeId];
+
+            if (existingRoute) {
+              if (process.env.NODE_ENV !== 'production') {
+                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 ctor = o.constructor;
+        const routes = recurseRoutes([rootRouteConfig]);
+        return routes[0];
+      },
+      parseLocation: (location, previousLocation) => {
+        var _location$hash$split$;
 
-  if (typeof ctor === 'undefined') {
-    return true;
-  } // If has modified prototype
+        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 prot = ctor.prototype;
+        // const resolvedFrom: Location = {
+        //   ...router.location,
+        const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
 
-  if (!hasObjectPrototype(prot)) {
-    return false;
-  } // If constructor does not have an Object-specific method
+        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);
 
-  if (!prot.hasOwnProperty('isPrototypeOf')) {
-    return false;
-  } // Most likely a plain Object
+        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);
 
-  return true;
-}
+        if (nextParams) {
+          toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
+            Object.assign({}, nextParams, fn(nextParams));
+          });
+        }
 
-function hasObjectPrototype(o) {
-  return Object.prototype.toString.call(o) === '[object Object]';
-}
+        pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
 
-const defaultParseSearch = parseSearchWith(JSON.parse);
-const defaultStringifySearch = stringifySearchWith(JSON.stringify);
-function parseSearchWith(parser) {
-  return searchStr => {
-    if (searchStr.substring(0, 1) === '?') {
-      searchStr = searchStr.substring(1);
-    }
+        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
 
-    let query = decode(searchStr); // Try to parse any query params that might be json
+        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
 
-    for (let key in query) {
-      const value = query[key];
+        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 (typeof value === 'string') {
-        try {
-          query[key] = parser(value);
-        } catch (err) {//
+        if (!replace) {
+          nextAction = 'push';
         }
-      }
-    }
 
-    return query;
-  };
-}
-function stringifySearchWith(stringify) {
-  return search => {
-    search = _extends$1({}, search);
+        const isSameUrl = router.__.parseLocation(history.location).href === next.href;
 
-    if (search) {
-      Object.keys(search).forEach(key => {
-        const val = search[key];
+        if (isSameUrl && !next.key) {
+          nextAction = 'replace';
+        }
 
-        if (typeof val === 'undefined' || val === undefined) {
-          delete search[key];
-        } else if (val && typeof val === 'object' && val !== null) {
-          try {
-            search[key] = stringify(val);
-          } catch (err) {// silent
-          }
+        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
+          });
         }
-      });
-    }
 
-    const searchStr = encode(search).toString();
-    return searchStr ? "?" + searchStr : '';
+        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);
+  return router;
 }
 
 function isCtrlEvent(e) {
   return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
 }
 
-function last(arr) {
-  return arr[arr.length - 1];
-}
-
 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"];
@@ -2356,152 +2509,166 @@ const useRouterSubscription = router => {
 };
 
 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;
+
+        const {
+          // custom props
+          target,
+          activeProps = () => ({
+            className: 'active'
+          }),
+          inactiveProps = () => ({}),
+          disabled,
+          // element props
+          style,
+          className,
+          onClick,
+          onFocus,
+          onMouseEnter,
+          onMouseLeave
+        } = options,
+              rest = _objectWithoutPropertiesLoose(options, _excluded);
+
+        const linkInfo = route.buildLink(options);
+
+        if (linkInfo.type === 'external') {
+          const {
+            href
+          } = linkInfo;
+          return {
+            href
+          };
+        }
+
+        const {
+          handleClick,
+          handleFocus,
+          handleEnter,
+          handleLeave,
+          isActive,
+          next
+        } = linkInfo;
+
+        const composeHandlers = handlers => e => {
+          e.persist();
+          handlers.forEach(handler => {
+            if (handler) handler(e);
+          });
+        }; // Get the active props
+
+
+        const resolvedActiveProps = isActive ? (_functionalUpdate = functionalUpdate(activeProps, {})) != null ? _functionalUpdate : {} : {}; // Get the inactive props
+
+        const resolvedInactiveProps = isActive ? {} : (_functionalUpdate2 = functionalUpdate(inactiveProps, {})) != null ? _functionalUpdate2 : {};
+        return _extends$2({}, resolvedActiveProps, resolvedInactiveProps, rest, {
+          href: disabled ? undefined : next.href,
+          onClick: composeHandlers([handleClick, onClick]),
+          onFocus: composeHandlers([handleFocus, onFocus]),
+          onMouseEnter: composeHandlers([handleEnter, onMouseEnter]),
+          onMouseLeave: composeHandlers([handleLeave, onMouseLeave]),
+          target,
+          style: _extends$2({}, style, resolvedActiveProps.style, resolvedInactiveProps.style),
+          className: [className, resolvedActiveProps.className, resolvedInactiveProps.className].filter(Boolean).join(' ') || undefined
+        }, disabled ? {
+          role: 'link',
+          'aria-disabled': true
+        } : undefined, {
+          ['data-status']: isActive ? 'active' : undefined
+        });
+      },
+      Link: /*#__PURE__*/React.forwardRef((props, ref) => {
+        const linkProps = route.linkProps(props);
+        useRouterSubscription(router);
+        return /*#__PURE__*/React.createElement("a", _extends$2({
+          ref: ref
+        }, linkProps, {
+          children: typeof props.children === 'function' ? props.children({
+            isActive: linkProps['data-status'] === 'active'
+          }) : props.children
+        }));
+      }),
+      MatchRoute: opts => {
+        const {
+          pending,
+          caseSensitive
+        } = opts,
+              rest = _objectWithoutPropertiesLoose(opts, _excluded2);
+
+        const params = route.matchRoute(rest, {
+          pending,
+          caseSensitive
+        });
+
+        if (!params) {
+          return null;
+        }
+
+        return typeof opts.children === 'function' ? opts.children(params) : opts.children;
+      }
+    };
+  };
+
   const coreRouter = createRouter(_extends$2({}, opts, {
     createRouter: router => {
       const routerExt = {
-        useRoute: routeId => {
-          const route = router.getRoute(routeId);
+        useState: () => {
           useRouterSubscription(router);
-
-          if (!route) {
-            throw new Error("Could not find a route for route \"" + routeId + "\"! Did you forget to add it to your route config?");
-          }
-
-          return route;
+          return router.state;
         },
         useMatch: routeId => {
-          if (routeId === rootRouteId) {
-            throw new Error("\"" + rootRouteId + "\" cannot be used with useMatch! Did you mean to useRoute(\"" + rootRouteId + "\")?");
-          }
+          useRouterSubscription(router);
+          invariant(routeId !== rootRouteId, "\"" + rootRouteId + "\" cannot be used with useMatch! Did you mean to useRoute(\"" + rootRouteId + "\")?");
 
           const runtimeMatch = _useMatch();
 
           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) {
-            throw new Error("Could not find a match for route \"" + routeId + "\" being rendered in this component!");
-          }
-
-          if (runtimeMatch.routeId !== (match == null ? void 0 : match.routeId)) {
-            throw new Error("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?");
-          }
-
-          useRouterSubscription(router);
-
-          if (!match) {
-            throw new Error('Match not found!');
+            invariant('Match not found!');
           }
 
           return match;
         }
       };
-      Object.assign(router, routerExt);
+      const routeExt = makeRouteExt(router.getRoute('/'), router);
+      Object.assign(router, routerExt, routeExt);
     },
     createRoute: _ref => {
       let {
         router,
         route
       } = _ref;
-      const routeExt = {
-        linkProps: options => {
-          var _functionalUpdate, _functionalUpdate2;
-
-          const {
-            // custom props
-            target,
-            activeProps = () => ({
-              className: 'active'
-            }),
-            inactiveProps = () => ({}),
-            disabled,
-            // element props
-            style,
-            className,
-            onClick,
-            onFocus,
-            onMouseEnter,
-            onMouseLeave
-          } = options,
-                rest = _objectWithoutPropertiesLoose(options, _excluded);
-
-          const linkInfo = route.buildLink(options);
-
-          if (linkInfo.type === 'external') {
-            const {
-              href
-            } = linkInfo;
-            return {
-              href
-            };
-          }
-
-          const {
-            handleClick,
-            handleFocus,
-            handleEnter,
-            handleLeave,
-            isActive,
-            next
-          } = linkInfo;
-
-          const composeHandlers = handlers => e => {
-            e.persist();
-            handlers.forEach(handler => {
-              if (handler) handler(e);
-            });
-          }; // Get the active props
-
-
-          const resolvedActiveProps = isActive ? (_functionalUpdate = functionalUpdate(activeProps)) != null ? _functionalUpdate : {} : {}; // Get the inactive props
-
-          const resolvedInactiveProps = isActive ? {} : (_functionalUpdate2 = functionalUpdate(inactiveProps)) != null ? _functionalUpdate2 : {};
-          return _extends$2({}, resolvedActiveProps, resolvedInactiveProps, rest, {
-            href: disabled ? undefined : next.href,
-            onClick: composeHandlers([handleClick, onClick]),
-            onFocus: composeHandlers([handleFocus, onFocus]),
-            onMouseEnter: composeHandlers([handleEnter, onMouseEnter]),
-            onMouseLeave: composeHandlers([handleLeave, onMouseLeave]),
-            target,
-            style: _extends$2({}, style, resolvedActiveProps.style, resolvedInactiveProps.style),
-            className: [className, resolvedActiveProps.className, resolvedInactiveProps.className].filter(Boolean).join(' ') || undefined
-          }, disabled ? {
-            role: 'link',
-            'aria-disabled': true
-          } : undefined, {
-            ['data-status']: isActive ? 'active' : undefined
-          });
-        },
-        Link: /*#__PURE__*/React.forwardRef((props, ref) => {
-          const linkProps = route.linkProps(props);
-          useRouterSubscription(router);
-          return /*#__PURE__*/React.createElement("a", _extends$2({
-            ref: ref
-          }, linkProps, {
-            children: typeof props.children === 'function' ? props.children({
-              isActive: linkProps['data-status'] === 'active'
-            }) : props.children
-          }));
-        }),
-        MatchRoute: opts => {
-          const {
-            pending,
-            caseSensitive
-          } = opts,
-                rest = _objectWithoutPropertiesLoose(opts, _excluded2);
-
-          const params = route.matchRoute(rest, {
-            pending,
-            caseSensitive
-          }); // useRouterSubscription(router)
-
-          if (!params) {
-            return null;
-          }
+      const routeExt = makeRouteExt(route, router);
+      Object.assign(route, routeExt);
+    },
+    createElement: async element => {
+      if (typeof element === 'function') {
+        const res = await element(); // Support direct import() calls
 
-          return typeof opts.children === 'function' ? opts.children(params) : opts.children;
+        if (typeof res === 'object' && res.default) {
+          return /*#__PURE__*/React.createElement(res.default);
+        } else {
+          return res;
         }
-      };
-      Object.assign(route, routeExt);
+      }
+
+      return element;
     }
   }));
   return coreRouter;
@@ -2514,10 +2681,10 @@ function RouterProvider(_ref2) {
       rest = _objectWithoutPropertiesLoose(_ref2, _excluded3);
 
   router.update(rest);
-  useSyncExternalStore(cb => router.subscribe(() => cb()), () => router.state);
+  useRouterSubscription(router);
   useLayoutEffect(() => {
-    router.mount();
-  }, []);
+    return router.mount();
+  }, [router]);
   return /*#__PURE__*/React.createElement(routerContext.Provider, {
     value: {
       router
@@ -2526,38 +2693,43 @@ function RouterProvider(_ref2) {
     value: router.state.matches
   }, children != null ? children : /*#__PURE__*/React.createElement(Outlet, null)));
 }
+
 function useRouter() {
   const value = React.useContext(routerContext);
   warning(!value, 'useRouter must be used inside a <Router> component!');
   useRouterSubscription(value.router);
   return value.router;
 }
+
 function useMatches() {
   return React.useContext(matchesContext);
-}
-function useParentMatches() {
-  const router = useRouter();
-
-  const match = _useMatch();
+} // 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,
+//   )
+// }
 
-  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 _ref3, _childMatch$options$c;
+  var _childMatch$options$c;
 
   const router = useRouter();
   const [, ...matches] = useMatches();
   const childMatch = matches[0];
   if (!childMatch) return null;
-  const element = (_ref3 = (() => {
-    var _childMatch$__$errorE, _ref5;
+
+  const element = (() => {
+    var _childMatch$__$errorE, _ref4;
 
     if (!childMatch) {
       return null;
@@ -2574,7 +2746,7 @@ function Outlet() {
         throw childMatch.error;
       }
 
-      return /*#__PURE__*/React.createElement(DefaultCatchBoundary, {
+      return /*#__PURE__*/React.createElement(DefaultErrorBoundary, {
         error: childMatch.error
       });
     }
@@ -2586,17 +2758,18 @@ function Outlet() {
         const pendingElement = (_childMatch$__$pendin = childMatch.__.pendingElement) != null ? _childMatch$__$pendin : router.options.defaultPendingElement;
 
         if (childMatch.options.pendingMs || pendingElement) {
-          var _ref4;
+          var _ref3;
 
-          return (_ref4 = pendingElement) != null ? _ref4 : null;
+          return (_ref3 = pendingElement) != null ? _ref3 : null;
         }
       }
 
       return null;
     }
 
-    return (_ref5 = childMatch.__.element) != null ? _ref5 : router.options.defaultElement;
-  })()) != null ? _ref3 : /*#__PURE__*/React.createElement(Outlet, null);
+    return (_ref4 = childMatch.__.element) != null ? _ref4 : router.options.defaultElement;
+  })();
+
   const catchElement = (_childMatch$options$c = childMatch == null ? void 0 : childMatch.options.catchElement) != null ? _childMatch$options$c : router.options.defaultCatchElement;
   return /*#__PURE__*/React.createElement(MatchesProvider, {
     value: matches,
@@ -2632,7 +2805,7 @@ class CatchBoundary extends React.Component {
   render() {
     var _this$props$catchElem;
 
-    const catchElement = (_this$props$catchElem = this.props.catchElement) != null ? _this$props$catchElem : DefaultCatchBoundary;
+    const catchElement = (_this$props$catchElem = this.props.catchElement) != null ? _this$props$catchElem : DefaultErrorBoundary;
 
     if (this.state.error) {
       return typeof catchElement === 'function' ? catchElement(this.state) : catchElement;
@@ -2643,10 +2816,10 @@ class CatchBoundary extends React.Component {
 
 }
 
-function DefaultCatchBoundary(_ref6) {
+function DefaultErrorBoundary(_ref5) {
   let {
     error
-  } = _ref6;
+  } = _ref5;
   return /*#__PURE__*/React.createElement("div", {
     style: {
       padding: '.5rem',
@@ -2681,6 +2854,30 @@ function DefaultCatchBoundary(_ref6) {
     }
   }, "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."));
 }
+function usePrompt(message, when) {
+  const router = useRouter();
+  React.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(_ref6) {
+  let {
+    message,
+    when,
+    children
+  } = _ref6;
+  usePrompt(message, when != null ? when : true);
+  return children != null ? children : null;
+}
 
-export { DefaultCatchBoundary, MatchesProvider, Outlet, RouterProvider, createBrowserHistory, createHashHistory, createMemoryHistory, createReactRouter, createRoute, createRouteConfig, createRouteMatch, createRouter, defaultParseSearch, defaultStringifySearch, functionalUpdate, last, matchByPath, matchPathname, parsePathname, parseSearchWith, replaceEqualDeep, _resolvePath as resolvePath, rootRouteId, stringifySearchWith, _useMatch as useMatch, useMatches, useParentMatches, useRouter, warning };
+export { DefaultErrorBoundary, MatchesProvider, Outlet, Prompt, RouterProvider, cascadeLoaderData, cleanPath, createBrowserHistory, createHashHistory, createMemoryHistory, createReactRouter, createRoute, createRouteConfig, createRouteMatch, createRouter, decode, defaultParseSearch, defaultStringifySearch, encode, functionalUpdate, interpolatePath, invariant, joinPaths, last, matchByPath, matchPathname, parsePathname, parseSearchWith, replaceEqualDeep, resolvePath, rootRouteId, stringifySearchWith, trimPath, trimPathLeft, trimPathRight, usePrompt, warning };
 //# sourceMappingURL=index.js.map