@tanstack/router-core 0.0.1-alpha.6 → 0.0.1-alpha.8

package/build/umd/index.development.js

@@ -31,23 +31,6 @@
     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.
    *
@@ -189,7 +172,7 @@
 
     if (index == null) {
       index = 0;
-      globalHistory.replaceState(_extends({}, globalHistory.state, {
+      globalHistory.replaceState(_extends$1({}, globalHistory.state, {
         idx: index
       }), '');
     }
@@ -204,7 +187,7 @@
         state = null;
       }
 
-      return readOnly(_extends({
+      return readOnly(_extends$1({
         pathname: location.pathname,
         hash: '',
         search: ''
@@ -438,7 +421,7 @@
 
     if (index == null) {
       index = 0;
-      globalHistory.replaceState(_extends({}, globalHistory.state, {
+      globalHistory.replaceState(_extends$1({}, globalHistory.state, {
         idx: index
       }), '');
     }
@@ -465,7 +448,7 @@
         state = null;
       }
 
-      return readOnly(_extends({
+      return readOnly(_extends$1({
         pathname: location.pathname,
         hash: '',
         search: ''
@@ -617,7 +600,7 @@
         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: '',
@@ -642,7 +625,7 @@
         state = null;
       }
 
-      return readOnly(_extends({
+      return readOnly(_extends$1({
         pathname: location.pathname,
         search: '',
         hash: ''
@@ -849,1499 +832,1578 @@
       throw new Error(value);
   }
 
-  // @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 = '';
+  // type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  //   k: infer I,
+  // ) => any
+  //   ? I
+  //   : never
 
-    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);
+  /**
+   * 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;
+    }
+
+    const array = Array.isArray(prev) && Array.isArray(next);
+
+    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;
+
+      for (let i = 0; i < bSize; i++) {
+        const key = array ? i : bItems[i];
+        copy[key] = replaceEqualDeep(prev[key], next[key]);
+
+        if (copy[key] === prev[key]) {
+          equalItems++;
         }
       }
+
+      return aSize === bSize && equalItems === aSize ? prev : copy;
     }
 
-    return (pfx || '') + str;
-  }
+    return next;
+  } // Copied from: https://github.com/jonschlinkert/is-plain-object
 
-  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 isPlainObject(o) {
+    if (!hasObjectPrototype(o)) {
+      return false;
+    } // If has modified constructor
 
-  function decode(str) {
-    var tmp,
-        k,
-        out = {},
-        arr = str.split('&');
 
-    while (tmp = arr.shift()) {
-      tmp = tmp.split('=');
-      k = tmp.shift();
+    const ctor = o.constructor;
 
-      if (out[k] !== void 0) {
-        out[k] = [].concat(out[k], toValue(tmp.shift()));
-      } else {
-        out[k] = toValue(tmp.shift());
-      }
-    }
+    if (typeof ctor === 'undefined') {
+      return true;
+    } // If has modified prototype
 
-    return out;
+
+    const prot = ctor.prototype;
+
+    if (!hasObjectPrototype(prot)) {
+      return false;
+    } // If constructor does not have an Object-specific method
+
+
+    if (!prot.hasOwnProperty('isPrototypeOf')) {
+      return false;
+    } // Most likely a plain Object
+
+
+    return true;
   }
 
-  const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId, parentPath) {
-    if (options === void 0) {
-      options = {};
-    }
+  function hasObjectPrototype(o) {
+    return Object.prototype.toString.call(o) === '[object Object]';
+  }
 
-    if (isRoot === void 0) {
-      isRoot = true;
+  function last(arr) {
+    return arr[arr.length - 1];
+  }
+  function warning(cond, message) {
+    if (cond) {
+      if (typeof console !== 'undefined') console.warn(message);
+
+      try {
+        throw new Error(message);
+      } catch (_unused) {}
     }
 
-    if (isRoot) {
-      options.path = rootRouteId;
-    } // Strip the root from parentIds
+    return true;
+  }
 
+  function isFunction(d) {
+    return typeof d === 'function';
+  }
 
-    if (parentId === rootRouteId) {
-      parentId = '';
+  function functionalUpdate(updater, previous) {
+    if (isFunction(updater)) {
+      return updater(previous);
     }
 
-    let path = isRoot ? rootRouteId : options.path; // If the path is anything other than an index path, trim it up
+    return updater;
+  }
 
-    if (path && path !== '/') {
-      path = trimPath(path);
-    }
+  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;
 
-    const routeId = path || options.id;
-    let id = joinPaths([parentId, routeId]);
+        // Extra trailing slash? pop it off
+        if (baseSegments.length > 1 && ((_last = last(baseSegments)) == null ? void 0 : _last.value) === '/') {
+          baseSegments.pop();
+        }
 
-    if (path === rootRouteId) {
-      path = '/';
+        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 [];
     }
 
-    if (id !== rootRouteId) {
-      id = joinPaths(['/', id]);
+    pathname = cleanPath(pathname);
+    const segments = [];
+
+    if (pathname.slice(0, 1) === '/') {
+      pathname = pathname.substring(1);
+      segments.push({
+        type: 'pathname',
+        value: '/'
+      });
     }
 
-    const fullPath = id === rootRouteId ? '/' : trimPathRight(joinPaths([parentPath, path]));
-    return {
-      id: id,
-      routeId: routeId,
-      path: path,
-      fullPath: fullPath,
-      options: options,
-      children,
-      addChildren: cb => createRouteConfig(options, cb(childOptions => createRouteConfig(childOptions, undefined, false, id, fullPath)), false, parentId, parentPath)
-    };
-  };
-  const rootRouteId = '__root__';
-  // Source
-  // Detect if we're in the DOM
-  const isDOM = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement); // This is the default history object if none is defined
+    if (!pathname) {
+      return segments;
+    } // Remove empty segments and '.' segments
 
-  const createDefaultHistory = () => isDOM ? createBrowserHistory() : createMemoryHistory();
 
-  function createRouter(userOptions) {
-    var _userOptions$stringif, _userOptions$parseSea;
+    const split = pathname.split('/').filter(Boolean);
+    segments.push(...split.map(part => {
+      if (part.startsWith('*')) {
+        return {
+          type: 'wildcard',
+          value: part
+        };
+      }
 
-    const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
+      if (part.charAt(0) === ':') {
+        return {
+          type: 'param',
+          value: part
+        };
+      }
 
-    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
-    });
+      return {
+        type: 'pathname',
+        value: part
+      };
+    }));
 
-    let router = {
-      options: originalOptions,
-      listeners: [],
-      removeActionQueue: [],
-      // 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 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,
-            // }
+    if (pathname.slice(-1) === '/') {
+      pathname = pathname.substring(1);
+      segments.push({
+        type: 'pathname',
+        value: '/'
+      });
+    }
 
-            const existingRoute = router.routesById[route.routeId];
+    return segments;
+  }
+  function interpolatePath(path, params, leaveWildcard) {
+    const interpolatedPathSegments = parsePathname(path);
+    return joinPaths(interpolatedPathSegments.map(segment => {
+      if (segment.value === '*' && !leaveWildcard) {
+        return '';
+      }
 
-            if (existingRoute) {
-              {
-                console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
-              }
+      if (segment.type === 'param') {
+        var _segment$value$substr;
 
-              throw new Error();
-            }
-            router.routesById[route.routeId] = route;
-            const children = routeConfig.children;
-            route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
-            return route;
-          });
-        };
+        return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
+      }
 
-        const routes = recurseRoutes([rootRouteConfig]);
-        return routes[0];
-      },
-      parseLocation: (location, previousLocation) => {
-        var _location$hash$split$;
+      return segment.value;
+    }));
+  }
+  function matchPathname(currentPathname, matchLocation) {
+    const pathParams = matchByPath(currentPathname, matchLocation); // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
 
-        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 (matchLocation.to && !pathParams) {
+      return;
+    } // if (matchLocation.search && !searchMatched) {
+    //   return
+    // }
 
-        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;
+    return pathParams != null ? pathParams : {};
+  }
+  function matchByPath(from, matchLocation) {
+    var _matchLocation$to;
 
-        let pathname = _resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
+    const baseSegments = parsePathname(from);
+    const routeSegments = parsePathname("" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*'));
+    const params = {};
 
-        const fromMatches = router.matchRoutes(router.location.pathname, {
-          strictParseParams: true
-        });
-        const toMatches = router.matchRoutes(pathname);
+    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;
 
-        const prevParams = _extends$1({}, (_last = last(fromMatches)) == null ? void 0 : _last.params);
+        if (routeSegment) {
+          if (routeSegment.type === 'wildcard') {
+            if (baseSegment != null && baseSegment.value) {
+              params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
+              return true;
+            }
 
-        let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
+            return false;
+          }
 
-        if (nextParams) {
-          toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
-            Object.assign({}, nextParams, fn(nextParams));
-          });
-        }
+          if (routeSegment.type === 'pathname') {
+            if (routeSegment.value === '/' && !(baseSegment != null && baseSegment.value)) {
+              return true;
+            }
 
-        pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
+            if (baseSegment) {
+              if (matchLocation.caseSensitive) {
+                if (routeSegment.value !== baseSegment.value) {
+                  return false;
+                }
+              } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
+                return false;
+              }
+            }
+          }
 
-        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
+          if (!baseSegment) {
+            return false;
+          }
 
-        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
+          if (routeSegment.type === 'param') {
+            if ((baseSegment == null ? void 0 : baseSegment.value) === '/') {
+              return false;
+            }
 
-        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 (!baseSegment.value.startsWith(':')) {
+              params[routeSegment.value.substring(1)] = baseSegment.value;
+            }
+          }
+        }
 
-        if (!replace) {
-          nextAction = 'push';
+        if (isLastRouteSegment && !isLastBaseSegment) {
+          return !!matchLocation.fuzzy;
         }
+      }
 
-        const isSameUrl = router.parseLocation(history.location).href === next.href;
+      return true;
+    })();
 
-        if (isSameUrl && !next.key) {
-          nextAction = 'replace';
-        }
+    return isMatch ? params : undefined;
+  }
 
-        if (nextAction === 'replace') {
-          history.replace({
-            pathname: next.pathname,
-            hash: next.hash,
-            search: next.searchStr
-          }, {
-            id
-          });
+  // @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 {
-          history.push({
-            pathname: next.pathname,
-            hash: next.hash,
-            search: next.searchStr
-          }, {
-            id
-          });
+          str && (str += '&');
+          str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp);
         }
+      }
+    }
 
-        router.navigationPromise = new Promise(resolve => {
-          const previousNavigationResolve = router.resolveNavigation;
+    return (pfx || '') + str;
+  }
 
-          router.resolveNavigation = () => {
-            previousNavigationResolve();
-            resolve();
-          };
-        });
-        return router.navigationPromise;
-      },
-      buildNext: opts => {
-        const next = router.buildLocation(opts);
-        const matches = router.matchRoutes(next.pathname);
+  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;
+  }
 
-        const __preSearchFilters = matches.map(match => {
-          var _match$options$preSea;
+  function decode(str) {
+    var tmp,
+        k,
+        out = {},
+        arr = str.split('&');
 
-          return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
-        }).flat().filter(Boolean);
+    while (tmp = arr.shift()) {
+      tmp = tmp.split('=');
+      k = tmp.shift();
 
-        const __postSearchFilters = matches.map(match => {
-          var _match$options$postSe;
+      if (out[k] !== void 0) {
+        out[k] = [].concat(out[k], toValue(tmp.shift()));
+      } else {
+        out[k] = toValue(tmp.shift());
+      }
+    }
 
-          return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
-        }).flat().filter(Boolean);
+    return out;
+  }
 
-        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;
+  function _extends() {
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
 
-        if (next) {
-          // Ingest the new location
-          router.location = next;
-        } // Clear out old actions
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
 
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
 
-        router.removeActionQueue.forEach(_ref => {
-          let {
-            action,
-            actionState
-          } = _ref;
+  function createRoute(routeConfig, options, parent, router) {
+    const {
+      id,
+      routeId,
+      path: routePath,
+      fullPath
+    } = routeConfig;
 
-          if (router.state.currentAction === actionState) {
-            router.state.currentAction = undefined;
-          }
+    const action = router.state.actions[id] || (() => {
+      router.state.actions[id] = {
+        pending: [],
+        submit: async (submission, actionOpts) => {
+          var _actionOpts$invalidat;
 
-          if (action.current === actionState) {
-            action.current = undefined;
+          if (!route) {
+            return;
           }
-        });
-        router.removeActionQueue = []; // Cancel any pending matches
 
-        router.cancelMatches(); // Match the routes
+          const invalidate = (_actionOpts$invalidat = actionOpts == null ? void 0 : actionOpts.invalidate) != null ? _actionOpts$invalidat : true;
+          const actionState = {
+            submittedAt: Date.now(),
+            status: 'pending',
+            submission
+          };
+          action.current = actionState;
+          action.latest = actionState;
+          action.pending.push(actionState);
+          router.state = _extends({}, router.state, {
+            currentAction: actionState,
+            latestAction: actionState
+          });
+          router.notify();
 
-        const unloadedMatches = router.matchRoutes(location.pathname, {
-          strictParseParams: true
-        });
-        router.state = _extends$1({}, router.state, {
-          pending: {
-            matches: unloadedMatches,
-            location: router.location
-          }
-        });
-        router.notify(); // Load the matches
+          try {
+            const res = await (route.options.action == null ? void 0 : route.options.action(submission));
+            actionState.data = res;
 
-        const matches = await router.loadMatches(unloadedMatches, {
-          withPending: true
-        });
+            if (invalidate) {
+              router.invalidateRoute({
+                to: '.',
+                fromCurrent: true
+              });
+              await router.reload();
+            }
 
-        if (router.startedLoadingAt !== id) {
-          // Ignore side-effects of match loading
-          return router.navigationPromise;
+            actionState.status = 'success';
+            return res;
+          } catch (err) {
+            console.error(err);
+            actionState.error = err;
+            actionState.status = 'error';
+          } finally {
+            action.pending = action.pending.filter(d => d !== actionState);
+            router.removeActionQueue.push({
+              action,
+              actionState
+            });
+            router.notify();
+          }
         }
+      };
+      return router.state.actions[id];
+    })();
 
-        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
-        });
+    let route = {
+      routeId: id,
+      routeRouteId: routeId,
+      routePath,
+      fullPath,
+      options,
+      router,
+      childRoutes: undefined,
+      parentRoute: parent,
+      action,
+      buildLink: options => {
+        return router.buildLink(_extends({}, options, {
+          from: fullPath
+        }));
+      },
+      navigate: options => {
+        return router.navigate(_extends({}, options, {
+          from: fullPath
+        }));
+      },
+      matchRoute: (matchLocation, opts) => {
+        return router.matchRoute(_extends({}, matchLocation, {
+          from: fullPath
+        }), opts);
+      }
+    };
+    router.options.createRoute == null ? void 0 : router.options.createRoute({
+      router,
+      route
+    });
+    return route;
+  }
+  function cascadeLoaderData(matches) {
+    matches.forEach((match, index) => {
+      const parent = matches[index - 1];
 
-        if (matches.some(d => d.status === 'loading')) {
-          router.notify();
-          await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
-        }
+      if (parent) {
+        match.loaderData = replaceEqualDeep(match.loaderData, _extends({}, parent.loaderData, match.routeLoaderData));
+      }
+    });
+  }
 
-        if (router.startedLoadingAt !== id) {
-          // Ignore side-effects of match loading
-          return;
-        }
+  const rootRouteId = '__root__';
+  const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId, parentPath) {
+    if (options === void 0) {
+      options = {};
+    }
 
-        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 (isRoot === void 0) {
+      isRoot = true;
+    }
 
-          if (entry.match.status === 'loading') {
-            return;
-          } // Do not remove successful matches that are still valid
+    if (isRoot) {
+      options.path = rootRouteId;
+    } // Strip the root from parentIds
 
 
-          if (entry.match.updatedAt && entry.match.updatedAt + entry.maxAge > now) {
-            return;
-          } // Everything else gets removed
+    if (parentId === rootRouteId) {
+      parentId = '';
+    }
 
+    let path = isRoot ? rootRouteId : options.path; // If the path is anything other than an index path, trim it up
 
-          delete router.preloadCache[matchId];
-        });
-      },
-      loadRoute: async function loadRoute(navigateOpts, loaderOpts) {
-        if (navigateOpts === void 0) {
-          navigateOpts = router.location;
-        }
+    if (path && path !== '/') {
+      path = trimPath(path);
+    }
 
-        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;
+    const routeId = path || options.id;
+    let id = joinPaths([parentId, routeId]);
 
-        router.cleanPreloadCache();
-        const matches = [];
+    if (path === rootRouteId) {
+      path = '/';
+    }
 
-        if (!router.routeTree) {
-          return matches;
-        }
+    if (id !== rootRouteId) {
+      id = joinPaths(['/', id]);
+    }
 
-        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 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 recurse = async routes => {
-          var _parentMatch$params, _router$options$filte, _foundRoute$childRout;
+  const elementTypes = ['element', 'errorElement', 'catchElement', 'pendingElement'];
+  function createRouteMatch(router, route, opts) {
+    const routeMatch = _extends({}, route, opts, {
+      router,
+      routeSearch: {},
+      search: {},
+      childMatches: [],
+      status: 'idle',
+      routeLoaderData: {},
+      loaderData: {},
+      isPending: false,
+      isFetching: false,
+      isInvalid: false,
+      getIsInvalid: () => {
+        var _ref, _routeMatch$options$l;
 
-          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 = [];
+        const now = Date.now();
+        const maxAge = (_ref = (_routeMatch$options$l = routeMatch.options.loaderMaxAge) != null ? _routeMatch$options$l : router.options.defaultLoaderMaxAge) != null ? _ref : 0;
+        return routeMatch.isInvalid || routeMatch.updatedAt + maxAge < now;
+      },
+      __: {
+        abortController: new AbortController(),
+        latestId: '',
+        resolve: () => {},
+        notify: () => {
+          routeMatch.__.resolve();
 
-          const findMatchInRoutes = (parentRoutes, routes) => {
-            routes.some(route => {
-              var _route$childRoutes, _route$childRoutes2, _route$options$caseSe;
+          routeMatch.router.notify();
+        },
+        startPending: () => {
+          var _routeMatch$options$p, _routeMatch$options$p2;
 
-              if (!route.routePath && (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length) {
-                return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
-              }
+          const pendingMs = (_routeMatch$options$p = routeMatch.options.pendingMs) != null ? _routeMatch$options$p : router.options.defaultPendingMs;
+          const pendingMinMs = (_routeMatch$options$p2 = routeMatch.options.pendingMinMs) != null ? _routeMatch$options$p2 : router.options.defaultPendingMinMs;
 
-              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
-              });
+          if (routeMatch.__.pendingTimeout || routeMatch.status !== 'loading' || typeof pendingMs === 'undefined') {
+            return;
+          }
 
-              if (matchParams) {
-                let parsedParams;
+          routeMatch.__.pendingTimeout = setTimeout(() => {
+            routeMatch.isPending = true;
 
-                try {
-                  var _route$options$parseP;
+            routeMatch.__.resolve();
 
-                  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;
-                  }
-                }
+            if (typeof pendingMinMs !== 'undefined') {
+              routeMatch.__.pendingMinPromise = new Promise(r => routeMatch.__.pendingMinTimeout = setTimeout(r, pendingMinMs));
+            }
+          }, pendingMs);
+        },
+        cancelPending: () => {
+          routeMatch.isPending = false;
+          clearTimeout(routeMatch.__.pendingTimeout);
+          clearTimeout(routeMatch.__.pendingMinTimeout);
+          delete routeMatch.__.pendingMinPromise;
+        },
+        // setParentMatch: (parentMatch?: RouteMatch) => {
+        //   routeMatch.parentMatch = parentMatch
+        // },
+        // addChildMatch: (childMatch: RouteMatch) => {
+        //   if (
+        //     routeMatch.childMatches.find((d) => d.matchId === childMatch.matchId)
+        //   ) {
+        //     return
+        //   }
+        //   routeMatch.childMatches.push(childMatch)
+        // },
+        validate: () => {
+          var _routeMatch$parentMat, _routeMatch$parentMat2;
 
-                params = _extends$1({}, params, parsedParams);
-              }
+          // Validate the search params and stabilize them
+          const parentSearch = (_routeMatch$parentMat = (_routeMatch$parentMat2 = routeMatch.parentMatch) == null ? void 0 : _routeMatch$parentMat2.search) != null ? _routeMatch$parentMat : router.location.search;
 
-              if (!!matchParams) {
-                foundRoutes = [...parentRoutes, route];
-              }
+          try {
+            const prevSearch = routeMatch.routeSearch;
+            const validator = typeof routeMatch.options.validateSearch === 'object' ? routeMatch.options.validateSearch.parse : routeMatch.options.validateSearch;
+            let nextSearch = replaceEqualDeep(prevSearch, validator == null ? void 0 : validator(parentSearch)); // Invalidate route matches when search param stability changes
 
-              return !!foundRoutes.length;
-            });
-            return !!foundRoutes.length;
-          };
+            if (prevSearch !== nextSearch) {
+              routeMatch.isInvalid = true;
+            }
 
-          findMatchInRoutes([], filteredRoutes);
+            routeMatch.routeSearch = nextSearch;
+            routeMatch.search = replaceEqualDeep(parentSearch, _extends({}, parentSearch, nextSearch));
+          } catch (err) {
+            console.error(err);
+            const error = new Error('Invalid search params found', {
+              cause: err
+            });
+            error.code = 'INVALID_SEARCH_PARAMS';
+            routeMatch.status = 'error';
+            routeMatch.error = error; // Do not proceed with loading the route
 
-          if (!foundRoutes.length) {
             return;
           }
+        }
+      },
+      cancel: () => {
+        var _routeMatch$__$abortC;
 
-          foundRoutes.forEach(foundRoute => {
-            var _router$preloadCache$;
+        (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
 
-            const interpolatedPath = interpolatePath(foundRoute.routePath, params);
-            const matchId = interpolatePath(foundRoute.routeId, params, true);
-            const match = existingMatches.find(d => d.matchId === matchId) || ((_router$preloadCache$ = router.preloadCache[matchId]) == null ? void 0 : _router$preloadCache$.match) || createRouteMatch(router, foundRoute, {
-              matchId,
-              params,
-              pathname: joinPaths([pathname, interpolatedPath])
-            });
-            matches.push(match);
-          });
-          const foundRoute = last(foundRoutes);
+        routeMatch.__.cancelPending();
+      },
+      invalidate: () => {
+        routeMatch.isInvalid = true;
+      },
+      hasLoaders: () => {
+        return !!(route.options.loader || route.options.import || elementTypes.some(d => typeof route.options[d] === 'function'));
+      },
+      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
 
-          if ((_foundRoute$childRout = foundRoute.childRoutes) != null && _foundRoute$childRout.length) {
-            recurse(foundRoute.childRoutes);
-          }
-        };
+        if (routeMatch.status === 'idle') {
+          routeMatch.status = 'loading';
+        } // We started loading the route, so it's no longer invalid
 
-        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 this is a preload, add it to the preload cache
 
+        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;
 
-          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
+          const loaderPromise = (async () => {
+            const importer = routeMatch.options.import; // First, run any importers
 
+            if (importer) {
+              routeMatch.__.importPromise = importer({
+                params: routeMatch.params // search: routeMatch.search,
 
-          if (match.status === 'success' && match.isInvalid || match.status === 'error' || match.status === 'idle') {
-            match.load();
-          } // If requested, start the pending timers
+              }).then(imported => {
+                routeMatch.__ = _extends({}, routeMatch.__, imported);
+              });
+            } // Wait for the importer to finish before
+            // attempting to load elements and data
 
 
-          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 routeMatch.__.importPromise; // Next, load the elements and data in parallel
 
-          await match.__.loadPromise;
-        });
-        router.notify();
-        await Promise.all(matchPromises);
-        return resolvedMatches;
-      },
-      invalidateRoute: opts => {
-        var _router$state$pending5, _router$state$pending6;
+            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];
 
-        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 (routeMatch.__[type]) {
+                  return;
+                }
 
-        // 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 (typeof routeElement === 'function') {
+                  const res = await routeElement(routeMatch);
+                  routeMatch.__[type] = res;
+                } else {
+                  routeMatch.__[type] = routeMatch.options[type];
+                }
+              }));
+            })();
 
-        if (opts != null && opts.pending) {
-          var _router$state$pending7;
+            routeMatch.__.dataPromise = Promise.resolve().then(async () => {
+              try {
+                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;
+                  }
 
-          if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
-            return false;
-          }
+                  routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
+                }
 
-          return !!matchPathname(router.state.pending.location.pathname, _extends$1({}, opts, {
-            to: next.pathname
-          }));
-        }
+                routeMatch.error = undefined;
+                routeMatch.status = 'success';
+                routeMatch.updatedAt = Date.now();
+              } catch (err) {
+                if (id !== routeMatch.__.latestId) {
+                  return routeMatch.__.loaderPromise;
+                }
 
-        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 _ref2 => {
-        let {
-          from,
-          to = '.',
-          search,
-          hash,
-          replace,
-          params
-        } = _ref2;
-        // 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) {}
-
-        invariant(!isExternal, 'Attempting to navigate to external url with router.navigate!');
-        return router._navigate({
-          from: fromString,
-          to: toString,
-          search,
-          hash,
-          replace,
-          params
-        });
-      },
-      buildLink: _ref3 => {
-        var _preload, _ref4, _ref5;
-
-        let {
-          from,
-          to = '.',
-          search,
-          params,
-          hash,
-          target,
-          replace,
-          activeOptions,
-          preload,
-          preloadMaxAge: userPreloadMaxAge,
-          preloadDelay: userPreloadDelay,
-          disabled
-        } = _ref3;
-
-        // 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) {}
-
-        const nextOpts = {
-          from,
-          to,
-          search,
-          params,
-          hash,
-          replace
-        };
-        const next = router.buildNext(nextOpts);
-        preload = (_preload = preload) != null ? _preload : router.options.defaultLinkPreload;
-        const preloadMaxAge = (_ref4 = userPreloadMaxAge != null ? userPreloadMaxAge : router.options.defaultLinkPreloadMaxAge) != null ? _ref4 : 2000;
-        const preloadDelay = (_ref5 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultLinkPreloadDelay) != null ? _ref5 : 50; // 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 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
-
-        const handleClick = e => {
-          if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
-            e.preventDefault();
+                {
+                  console.error(err);
+                }
 
-            if (pathIsEqual && !search && !hash) {
-              router.invalidateRoute(nextOpts);
-            } // All is well? Navigate!)
+                routeMatch.error = err;
+                routeMatch.status = 'error';
+                routeMatch.updatedAt = Date.now();
+              }
+            });
 
+            try {
+              await Promise.all([routeMatch.__.elementsPromise, routeMatch.__.dataPromise]);
 
-            router._navigate(nextOpts);
-          }
-        }; // The click handler
+              if (id !== routeMatch.__.latestId) {
+                return routeMatch.__.loaderPromise;
+              }
 
+              if (routeMatch.__.pendingMinPromise) {
+                await routeMatch.__.pendingMinPromise;
+                delete routeMatch.__.pendingMinPromise;
+              }
+            } finally {
+              if (id !== routeMatch.__.latestId) {
+                return routeMatch.__.loaderPromise;
+              }
 
-        const handleFocus = e => {
-          if (preload && preloadMaxAge > 0) {
-            router.loadRoute(nextOpts, {
-              maxAge: preloadMaxAge
-            });
-          }
-        };
+              routeMatch.__.cancelPending();
 
-        const handleEnter = e => {
-          const target = e.target || {};
+              routeMatch.isPending = false;
+              routeMatch.isFetching = false;
 
-          if (preload && preloadMaxAge > 0) {
-            if (target.preloadTimeout) {
-              return;
+              routeMatch.__.notify();
             }
+          })();
 
-            target.preloadTimeout = setTimeout(() => {
-              target.preloadTimeout = null;
-              router.loadRoute(nextOpts, {
-                maxAge: preloadMaxAge
-              });
-            }, preloadDelay);
-          }
-        };
-
-        const handleLeave = e => {
-          const target = e.target || {};
+          routeMatch.__.loaderPromise = loaderPromise;
+          await loaderPromise;
 
-          if (target.preloadTimeout) {
-            clearTimeout(target.preloadTimeout);
-            target.preloadTimeout = null;
+          if (id !== routeMatch.__.latestId) {
+            return routeMatch.__.loaderPromise;
           }
-        };
 
-        return {
-          type: 'internal',
-          next,
-          handleFocus,
-          handleClick,
-          handleEnter,
-          handleLeave,
-          isActive,
-          disabled
-        };
-      },
-      __experimental__createSnapshot: () => {
-        return _extends$1({}, router.state, {
-          matches: router.state.matches.map(_ref6 => {
-            let {
-              routeLoaderData: loaderData,
-              matchId
-            } = _ref6;
-            return {
-              matchId,
-              loaderData
-            };
-          })
+          delete routeMatch.__.loaderPromise;
         });
+        return await routeMatch.__.loadPromise;
       }
-    };
-    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
+    });
 
-    router.options.createRouter == null ? void 0 : router.options.createRouter(router); // router.mount()
+    if (!routeMatch.hasLoaders()) {
+      routeMatch.status = 'success';
+    }
 
-    return router;
+    return routeMatch;
   }
-  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,
-      path: routePath,
-      fullPath
-    } = routeConfig;
 
-    const action = router.state.actions[id] || (() => {
-      router.state.actions[id] = {
-        pending: [],
-        submit: async (submission, actionOpts) => {
-          var _actionOpts$invalidat;
+  const defaultParseSearch = parseSearchWith(JSON.parse);
+  const defaultStringifySearch = stringifySearchWith(JSON.stringify);
+  function parseSearchWith(parser) {
+    return searchStr => {
+      if (searchStr.substring(0, 1) === '?') {
+        searchStr = searchStr.substring(1);
+      }
 
-          if (!route) {
-            return;
-          }
+      let query = decode(searchStr); // Try to parse any query params that might be json
 
-          const invalidate = (_actionOpts$invalidat = actionOpts == null ? void 0 : actionOpts.invalidate) != null ? _actionOpts$invalidat : true;
-          const actionState = {
-            submittedAt: Date.now(),
-            status: 'pending',
-            submission
-          };
-          action.current = actionState;
-          action.latest = actionState;
-          action.pending.push(actionState);
-          router.state = _extends$1({}, router.state, {
-            currentAction: actionState,
-            latestAction: actionState
-          });
-          router.notify();
+      for (let key in query) {
+        const value = query[key];
 
+        if (typeof value === 'string') {
           try {
-            const res = await (route.options.action == null ? void 0 : route.options.action(submission));
-            actionState.data = res;
-
-            if (invalidate) {
-              router.invalidateRoute({
-                to: '.',
-                fromCurrent: true
-              });
-              await router.reload();
-            }
-
-            actionState.status = 'success';
-            return res;
-          } catch (err) {
-            console.error(err);
-            actionState.error = err;
-            actionState.status = 'error';
-          } finally {
-            action.pending = action.pending.filter(d => d !== actionState);
-            router.removeActionQueue.push({
-              action,
-              actionState
-            });
-            router.notify();
+            query[key] = parser(value);
+          } catch (err) {//
           }
         }
-      };
-      return router.state.actions[id];
-    })();
-
-    let route = {
-      routeId: id,
-      routeRouteId: routeId,
-      routePath,
-      fullPath,
-      options,
-      router,
-      childRoutes: undefined,
-      parentRoute: parent,
-      action,
-      buildLink: options => {
-        return router.buildLink(_extends$1({}, options, {
-          from: fullPath
-        }));
-      },
-      navigate: options => {
-        return router.navigate(_extends$1({}, options, {
-          from: fullPath
-        }));
-      },
-      matchRoute: (matchLocation, opts) => {
-        return router.matchRoute(_extends$1({}, matchLocation, {
-          from: fullPath
-        }), opts);
       }
+
+      return query;
     };
-    router.options.createRoute == null ? void 0 : router.options.createRoute({
-      router,
-      route
-    });
-    return route;
   }
-  function createRouteMatch(router, route, opts) {
-    const routeMatch = _extends$1({}, route, opts, {
-      router,
-      routeSearch: {},
-      search: {},
-      childMatches: [],
-      status: 'idle',
-      routeLoaderData: {},
-      loaderData: {},
-      isPending: false,
-      isFetching: false,
-      isInvalid: false,
-      __: {
-        abortController: new AbortController(),
-        latestId: '',
-        resolve: () => {},
-        notify: () => {
-          routeMatch.__.resolve();
-
-          routeMatch.router.notify();
-        },
-        startPending: () => {
-          var _routeMatch$options$p, _routeMatch$options$p2;
+  function stringifySearchWith(stringify) {
+    return search => {
+      search = _extends({}, search);
 
-          const pendingMs = (_routeMatch$options$p = routeMatch.options.pendingMs) != null ? _routeMatch$options$p : router.options.defaultPendingMs;
-          const pendingMinMs = (_routeMatch$options$p2 = routeMatch.options.pendingMinMs) != null ? _routeMatch$options$p2 : router.options.defaultPendingMinMs;
+      if (search) {
+        Object.keys(search).forEach(key => {
+          const val = search[key];
 
-          if (routeMatch.__.pendingTimeout || routeMatch.status !== 'loading' || typeof pendingMs === 'undefined') {
-            return;
+          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
+            }
           }
+        });
+      }
 
-          routeMatch.__.pendingTimeout = setTimeout(() => {
-            routeMatch.isPending = true;
+      const searchStr = encode(search).toString();
+      return searchStr ? "?" + searchStr : '';
+    };
+  }
 
-            routeMatch.__.resolve();
+  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
 
-            if (typeof pendingMinMs !== 'undefined') {
-              routeMatch.__.pendingMinPromise = new Promise(r => routeMatch.__.pendingMinTimeout = setTimeout(r, pendingMinMs));
-            }
-          }, pendingMs);
-        },
-        cancelPending: () => {
-          routeMatch.isPending = false;
-          clearTimeout(routeMatch.__.pendingTimeout);
-          clearTimeout(routeMatch.__.pendingMinTimeout);
-          delete routeMatch.__.pendingMinPromise;
-        },
-        // setParentMatch: (parentMatch?: RouteMatch) => {
-        //   routeMatch.parentMatch = parentMatch
-        // },
-        // addChildMatch: (childMatch: RouteMatch) => {
-        //   if (
-        //     routeMatch.childMatches.find((d) => d.matchId === childMatch.matchId)
-        //   ) {
-        //     return
-        //   }
-        //   routeMatch.childMatches.push(childMatch)
-        // },
-        validate: () => {
-          var _routeMatch$parentMat, _routeMatch$parentMat2;
+  const createDefaultHistory = () => !isServer ? createBrowserHistory() : createMemoryHistory();
 
-          // Validate the search params and stabilize them
-          const parentSearch = (_routeMatch$parentMat = (_routeMatch$parentMat2 = routeMatch.parentMatch) == null ? void 0 : _routeMatch$parentMat2.search) != null ? _routeMatch$parentMat : router.location.search;
+  function createRouter(userOptions) {
+    var _userOptions$stringif, _userOptions$parseSea;
 
-          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 history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
 
-            if (prevSearch !== nextSearch) {
-              routeMatch.isInvalid = true;
-            }
+    const originalOptions = _extends({
+      defaultLoaderGcMaxAge: 5 * 60 * 1000,
+      defaultLoaderMaxAge: 0,
+      defaultLinkPreloadDelay: 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
+    });
 
-            routeMatch.routeSearch = nextSearch;
-            routeMatch.search = replaceEqualDeep(parentSearch, _extends$1({}, parentSearch, nextSearch));
-          } catch (err) {
-            console.error(err);
-            const error = new Error('Invalid search params found', {
-              cause: err
-            });
-            error.code = 'INVALID_SEARCH_PARAMS';
-            routeMatch.status = 'error';
-            routeMatch.error = error; // Do not proceed with loading the route
+    let router = {
+      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: {},
+        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());
+      },
+      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.
 
-            return;
-          }
+        if (next.href !== router.location.href) {
+          router.commitLocation(next, true);
+        } else {
+          router.loadLocation();
         }
-      },
-      cancel: () => {
-        var _routeMatch$__$abortC;
 
-        (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
+        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
 
-        routeMatch.__.cancelPending();
+        if (!isServer && window.addEventListener) {
+          // Listen to visibillitychange and focus
+          window.addEventListener('visibilitychange', router.onFocus, false);
+          window.addEventListener('focus', router.onFocus, false);
+        }
+
+        return () => {
+          unsub(); // Be sure to unsubscribe if a new handler is set
+
+          window.removeEventListener('visibilitychange', router.onFocus);
+          window.removeEventListener('focus', router.onFocus);
+        };
       },
-      invalidate: () => {
-        routeMatch.isInvalid = true;
+      onFocus: () => {
+        router.loadLocation();
       },
-      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
+      update: opts => {
+        Object.assign(router.options, opts);
+        const {
+          basepath,
+          routeConfig
+        } = router.options;
+        router.basepath = cleanPath("/" + (basepath != null ? basepath : ''));
 
-        if (routeMatch.status === 'error' || routeMatch.status === 'idle') {
-          routeMatch.status = 'loading';
-        } // We started loading the route, so it's no longer invalid
+        if (routeConfig) {
+          router.routesById = {};
+          router.routeTree = router.buildRouteTree(routeConfig);
+        }
 
+        return router;
+      },
+      buildRouteTree: rootRouteConfig => {
+        const recurseRoutes = (routeConfigs, parent) => {
+          return routeConfigs.map(routeConfig => {
+            const routeOptions = routeConfig.options;
+            const route = createRoute(routeConfig, routeOptions, parent, router); // {
+            //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
+            //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
+            // }
 
-        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 existingRoute = router.routesById[route.routeId];
+
+            if (existingRoute) {
+              {
+                console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
+              }
+
+              throw new Error();
+            }
+            router.routesById[route.routeId] = route;
+            const children = routeConfig.children;
+            route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
+            return route;
+          });
+        };
+
+        const routes = recurseRoutes([rootRouteConfig]);
+        return routes[0];
+      },
+      parseLocation: (location, previousLocation) => {
+        var _location$hash$split$;
+
+        const parsedSearch = router.options.parseSearch(location.search);
+        return {
+          pathname: location.pathname,
+          searchStr: location.search,
+          search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
+          hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
+          href: "" + location.pathname + location.search + location.hash,
+          state: location.state,
+          key: location.key
+        };
+      },
+      buildLocation: function buildLocation(dest) {
+        var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
 
-          const loaderPromise = (async () => {
-            const importer = routeMatch.options.import; // First, run any importers
+        if (dest === void 0) {
+          dest = {};
+        }
 
-            if (importer) {
-              routeMatch.__.importPromise = importer({
-                params: routeMatch.params // search: routeMatch.search,
+        // const resolvedFrom: Location = {
+        //   ...router.location,
+        const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
 
-              }).then(imported => {
-                routeMatch.__ = _extends$1({}, routeMatch.__, imported);
-              });
-            } // Wait for the importer to finish before
-            // attempting to load elements and data
+        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);
 
-            await routeMatch.__.importPromise; // Next, load the elements and data in parallel
+        const prevParams = _extends({}, (_last = last(fromMatches)) == null ? void 0 : _last.params);
 
-            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];
+        let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
 
-                if (routeMatch.__[type]) {
-                  return;
-                }
+        if (nextParams) {
+          toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
+            Object.assign({}, nextParams, fn(nextParams));
+          });
+        }
 
-                if (typeof routeElement === 'function') {
-                  const res = await routeElement(routeMatch);
-                  routeMatch.__[type] = res;
-                } else {
-                  routeMatch.__[type] = routeMatch.options[type];
-                }
-              }));
-            })();
+        pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
 
-            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
-                }));
+        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
 
-                if (id !== routeMatch.__.latestId) {
-                  return routeMatch.__.loaderPromise;
-                }
+        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
 
-                routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
-                routeMatch.error = undefined;
-                routeMatch.status = 'success';
-                routeMatch.updatedAt = Date.now();
-              } catch (err) {
-                if (id !== routeMatch.__.latestId) {
-                  return routeMatch.__.loaderPromise;
-                }
+        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';
 
-                {
-                  console.error(err);
-                }
+        if (!replace) {
+          nextAction = 'push';
+        }
 
-                routeMatch.error = err;
-                routeMatch.status = 'error';
-                routeMatch.updatedAt = Date.now();
-              }
-            });
+        const isSameUrl = router.parseLocation(history.location).href === next.href;
 
-            try {
-              await Promise.all([routeMatch.__.elementsPromise, routeMatch.__.dataPromise]);
+        if (isSameUrl && !next.key) {
+          nextAction = 'replace';
+        }
 
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
-              }
+        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
+          });
+        }
 
-              if (routeMatch.__.pendingMinPromise) {
-                await routeMatch.__.pendingMinPromise;
-                delete routeMatch.__.pendingMinPromise;
-              }
-            } finally {
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
-              }
+        router.navigationPromise = new Promise(resolve => {
+          const previousNavigationResolve = router.resolveNavigation;
 
-              routeMatch.__.cancelPending();
+          router.resolveNavigation = () => {
+            previousNavigationResolve();
+            resolve();
+          };
+        });
+        return router.navigationPromise;
+      },
+      buildNext: opts => {
+        const next = router.buildLocation(opts);
+        const matches = router.matchRoutes(next.pathname);
 
-              routeMatch.isPending = false;
-              routeMatch.isFetching = false;
+        const __preSearchFilters = matches.map(match => {
+          var _match$options$preSea;
 
-              routeMatch.__.notify();
-            }
-          })();
+          return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
+        }).flat().filter(Boolean);
 
-          routeMatch.__.loaderPromise = loaderPromise;
-          await loaderPromise;
+        const __postSearchFilters = matches.map(match => {
+          var _match$options$postSe;
 
-          if (id !== routeMatch.__.latestId) {
-            return routeMatch.__.loaderPromise;
-          }
+          return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
+        }).flat().filter(Boolean);
 
-          delete routeMatch.__.loaderPromise;
+        return router.buildLocation(_extends({}, opts, {
+          __preSearchFilters,
+          __postSearchFilters
+        }));
+      },
+      cancelMatches: () => {
+        var _router$state$pending, _router$state$pending2;
+        [...router.state.matches, ...((_router$state$pending = (_router$state$pending2 = router.state.pending) == null ? void 0 : _router$state$pending2.matches) != null ? _router$state$pending : [])].forEach(match => {
+          match.cancel();
         });
-        return await routeMatch.__.loadPromise;
-      }
-    });
+      },
+      loadLocation: async next => {
+        const id = Math.random();
+        router.startedLoadingAt = id;
 
-    return routeMatch;
-  }
+        if (next) {
+          // Ingest the new location
+          router.location = next;
+        } // Clear out old actions
 
-  function cascadeLoaderData(matches) {
-    matches.forEach((match, index) => {
-      const parent = matches[index - 1];
 
-      if (parent) {
-        match.loaderData = replaceEqualDeep(match.loaderData, _extends$1({}, parent.loaderData, match.routeLoaderData));
-      }
-    });
-  }
+        router.removeActionQueue.forEach(_ref => {
+          let {
+            action,
+            actionState
+          } = _ref;
 
-  function matchPathname(currentPathname, matchLocation) {
-    const pathParams = matchByPath(currentPathname, matchLocation); // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
+          if (router.state.currentAction === actionState) {
+            router.state.currentAction = undefined;
+          }
 
-    if (matchLocation.to && !pathParams) {
-      return;
-    } // if (matchLocation.search && !searchMatched) {
-    //   return
-    // }
+          if (action.current === actionState) {
+            action.current = undefined;
+          }
+        });
+        router.removeActionQueue = []; // Cancel any pending matches
 
+        router.cancelMatches(); // Match the routes
 
-    return pathParams != null ? pathParams : {};
-  }
+        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
 
-  function interpolatePath(path, params, leaveWildcard) {
-    const interpolatedPathSegments = parsePathname(path);
-    return joinPaths(interpolatedPathSegments.map(segment => {
-      if (segment.value === '*' && !leaveWildcard) {
-        return '';
-      }
+        await router.loadMatches(matches, {
+          withPending: true
+        });
 
-      if (segment.type === 'param') {
-        var _segment$value$substr;
+        if (router.startedLoadingAt !== id) {
+          // Ignore side-effects of match loading
+          return router.navigationPromise;
+        }
 
-        return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
-      }
+        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;
 
-      return segment.value;
-    }));
-  }
+          d.__.onExit == null ? void 0 : d.__.onExit({
+            params: d.params,
+            search: d.routeSearch
+          }); // Clear idle error states when match leaves
 
-  function warning(cond, message) {
-    if (cond) {
-      if (typeof console !== 'undefined') console.warn(message);
+          if (d.status === 'error' && !d.isFetching) {
+            d.status = 'idle';
+            d.error = undefined;
+          }
 
-      try {
-        throw new Error(message);
-      } catch (_unused) {}
-    }
+          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);
+
+          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
+          });
+        });
 
-    return true;
-  }
+        if (matches.some(d => d.status === 'loading')) {
+          router.notify();
+          await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
+        }
 
-  function isFunction(d) {
-    return typeof d === 'function';
-  }
+        if (router.startedLoadingAt !== id) {
+          // Ignore side-effects of match loading
+          return;
+        }
 
-  function functionalUpdate(updater, previous) {
-    if (isFunction(updater)) {
-      return updater(previous);
-    }
+        router.state = _extends({}, router.state, {
+          location: router.location,
+          matches,
+          pending: undefined,
+          status: 'idle'
+        });
+        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
 
-    return updater;
-  }
+          if (entry.match.status === 'loading') {
+            return;
+          } // Do not remove successful matches that are still valid
 
-  function joinPaths(paths) {
-    return cleanPath(paths.filter(Boolean).join('/'));
-  }
 
-  function cleanPath(path) {
-    // remove double slashes
-    return path.replace(/\/{2,}/g, '/');
-  }
+          if (entry.gc > 0 && entry.gc > now) {
+            return;
+          } // Everything else gets removed
 
-  function trimPathLeft(path) {
-    return path === '/' ? path : path.replace(/^\/{1,}/, '');
-  }
 
-  function trimPathRight(path) {
-    return path === '/' ? path : path.replace(/\/{1,}$/, '');
-  }
+          delete router.matchCache[matchId];
+        });
+      },
+      loadRoute: async function loadRoute(navigateOpts, loaderOpts) {
+        if (navigateOpts === void 0) {
+          navigateOpts = router.location;
+        }
 
-  function trimPath(path) {
-    return trimPathRight(trimPathLeft(path));
-  }
+        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;
 
-  function matchByPath(from, matchLocation) {
-    var _matchLocation$to;
+        router.cleanMatchCache();
+        const matches = [];
 
-    const baseSegments = parsePathname(from);
-    const routeSegments = parsePathname("" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*'));
-    const params = {};
+        if (!router.routeTree) {
+          return matches;
+        }
 
-    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;
+        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 : [])];
 
-        if (routeSegment) {
-          if (routeSegment.type === 'wildcard') {
-            if (baseSegment != null && baseSegment.value) {
-              params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
-              return true;
-            }
+        const recurse = async routes => {
+          var _parentMatch$params, _router$options$filte, _foundRoute$childRout;
 
-            return false;
-          }
+          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 = [];
 
-          if (routeSegment.type === 'pathname') {
-            if (routeSegment.value === '/' && !(baseSegment != null && baseSegment.value)) {
-              return true;
-            }
+          const findMatchInRoutes = (parentRoutes, routes) => {
+            routes.some(route => {
+              var _route$childRoutes, _route$childRoutes2, _route$options$caseSe;
 
-            if (baseSegment) {
-              if (matchLocation.caseSensitive) {
-                if (routeSegment.value !== baseSegment.value) {
-                  return false;
-                }
-              } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
-                return false;
+              if (!route.routePath && (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length) {
+                return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
               }
-            }
-          }
 
-          if (!baseSegment) {
-            return false;
-          }
+              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
+              });
 
-          if (routeSegment.type === 'param') {
-            if ((baseSegment == null ? void 0 : baseSegment.value) === '/') {
-              return false;
-            }
+              if (matchParams) {
+                let parsedParams;
 
-            if (!baseSegment.value.startsWith(':')) {
-              params[routeSegment.value.substring(1)] = baseSegment.value;
-            }
-          }
-        }
+                try {
+                  var _route$options$parseP;
 
-        if (isLastRouteSegment && !isLastBaseSegment) {
-          return !!matchLocation.fuzzy;
-        }
-      }
+                  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;
+                  }
+                }
 
-      return true;
-    })();
+                params = _extends({}, params, parsedParams);
+              }
 
-    return isMatch ? params : undefined;
-  } // function matchBySearch(
-  //   search: SearchSchema,
-  //   matchLocation: MatchLocation,
-  // ) {
-  //   return !!(matchLocation.search && matchLocation.search(search))
-  // }
+              if (!!matchParams) {
+                foundRoutes = [...parentRoutes, route];
+              }
 
-  function parsePathname(pathname) {
-    if (!pathname) {
-      return [];
-    }
+              return !!foundRoutes.length;
+            });
+            return !!foundRoutes.length;
+          };
 
-    pathname = cleanPath(pathname);
-    const segments = [];
+          findMatchInRoutes([], filteredRoutes);
 
-    if (pathname.slice(0, 1) === '/') {
-      pathname = pathname.substring(1);
-      segments.push({
-        type: 'pathname',
-        value: '/'
-      });
-    }
+          if (!foundRoutes.length) {
+            return;
+          }
 
-    if (!pathname) {
-      return segments;
-    } // Remove empty segments and '.' segments
+          foundRoutes.forEach(foundRoute => {
+            var _router$matchCache$ma;
 
+            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);
 
-    const split = pathname.split('/').filter(Boolean);
-    segments.push(...split.map(part => {
-      if (part.startsWith('*')) {
-        return {
-          type: 'wildcard',
-          value: part
+          if ((_foundRoute$childRout = foundRoute.childRoutes) != null && _foundRoute$childRout.length) {
+            recurse(foundRoute.childRoutes);
+          }
         };
-      }
 
-      if (part.charAt(0) === ':') {
-        return {
-          type: 'param',
-          value: part
-        };
-      }
+        recurse([router.routeTree]);
+        cascadeLoaderData(matches);
+        return matches;
+      },
+      loadMatches: async (resolvedMatches, loaderOpts) => {
+        const now = Date.now();
+        const matchPromises = resolvedMatches.map(async match => {
+          // Validate the match (loads search params etc)
+          match.__.validate(); // // If the match doesn't have a loader, don't attempt to load it
+          // if (!match.hasLoaders()) {
+          //   return
+          // }
+          // If this is a preload, add it to the preload cache
 
-      return {
-        type: 'pathname',
-        value: part
-      };
-    }));
 
-    if (pathname.slice(-1) === '/') {
-      pathname = pathname.substring(1);
-      segments.push({
-        type: 'pathname',
-        value: '/'
-      });
-    }
+          if (loaderOpts != null && loaderOpts.preload && (loaderOpts == null ? void 0 : loaderOpts.maxAge) > 0) {
+            // If the match is currently active, don't preload it
+            if (router.state.matches.find(d => d.matchId === match.matchId)) {
+              return;
+            }
 
-    return segments;
-  }
+            router.matchCache[match.matchId] = {
+              gc: now + loaderOpts.maxAge,
+              // TODO: Should this use the route's maxAge?
+              match
+            };
+          } // If the match is invalid, errored or idle, trigger it to load
 
-  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;
 
-        // Extra trailing slash? pop it off
-        if (baseSegments.length > 1 && ((_last2 = last(baseSegments)) == null ? void 0 : _last2.value) === '/') {
-          baseSegments.pop();
-        }
+          if (match.status === 'success' && match.getIsInvalid() || match.status === 'error' || match.status === 'idle') {
+            match.load();
+          }
+
+          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;
 
-        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;
-    }
+        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;
 
-    const array = Array.isArray(prev) && Array.isArray(next);
+        // 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 (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;
+        if (opts != null && opts.pending) {
+          var _router$state$pending7;
 
-      for (let i = 0; i < bSize; i++) {
-        const key = array ? i : bItems[i];
-        copy[key] = replaceEqualDeep(prev[key], next[key]);
+          if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
+            return false;
+          }
 
-        if (copy[key] === prev[key]) {
-          equalItems++;
+          return !!matchPathname(router.state.pending.location.pathname, _extends({}, opts, {
+            to: next.pathname
+          }));
         }
-      }
 
-      return aSize === bSize && equalItems === aSize ? prev : copy;
-    }
+        return !!matchPathname(router.state.location.pathname, _extends({}, opts, {
+          to: next.pathname
+        }));
+      },
+      _navigate: location => {
+        const next = router.buildNext(location);
+        return router.commitLocation(next, location.replace);
+      },
+      navigate: async _ref4 => {
+        let {
+          from,
+          to = '.',
+          search,
+          hash,
+          replace,
+          params
+        } = _ref4;
+        // 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 next;
-  } // Copied from: https://github.com/jonschlinkert/is-plain-object
+        try {
+          new URL("" + toString);
+          isExternal = true;
+        } catch (e) {}
 
-  function isPlainObject(o) {
-    if (!hasObjectPrototype(o)) {
-      return false;
-    } // If has modified constructor
+        invariant(!isExternal, 'Attempting to navigate to external url with router.navigate!');
+        return router._navigate({
+          from: fromString,
+          to: toString,
+          search,
+          hash,
+          replace,
+          params
+        });
+      },
+      buildLink: _ref5 => {
+        var _preload, _ref6, _ref7, _ref8;
 
+        let {
+          from,
+          to = '.',
+          search,
+          params,
+          hash,
+          target,
+          replace,
+          activeOptions,
+          preload,
+          preloadMaxAge: userPreloadMaxAge,
+          preloadDelay: userPreloadDelay,
+          disabled
+        } = _ref5;
 
-    const ctor = o.constructor;
+        // 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 (typeof ctor === 'undefined') {
-      return true;
-    } // If has modified prototype
+        const nextOpts = {
+          from,
+          to,
+          search,
+          params,
+          hash,
+          replace
+        };
+        const next = router.buildNext(nextOpts);
+        preload = (_preload = preload) != null ? _preload : router.options.defaultLinkPreload;
+        const preloadMaxAge = (_ref6 = (_ref7 = userPreloadMaxAge != null ? userPreloadMaxAge : router.options.defaultLinkPreloadMaxAge) != null ? _ref7 : router.options.defaultLoaderGcMaxAge) != null ? _ref6 : 0;
+        const preloadDelay = (_ref8 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultLinkPreloadDelay) != null ? _ref8 : 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 prot = ctor.prototype;
+        const pathTest = activeOptions != null && activeOptions.exact ? pathIsEqual : pathIsFuzzyEqual;
+        const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true; // The final "active" test
 
-    if (!hasObjectPrototype(prot)) {
-      return false;
-    } // If constructor does not have an Object-specific method
+        const isActive = pathTest && hashTest; // The click handler
 
+        const handleClick = e => {
+          if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
+            e.preventDefault();
 
-    if (!prot.hasOwnProperty('isPrototypeOf')) {
-      return false;
-    } // Most likely a plain Object
+            if (pathIsEqual && !search && !hash) {
+              router.invalidateRoute(nextOpts);
+            } // All is well? Navigate!)
 
 
-    return true;
-  }
+            router._navigate(nextOpts);
+          }
+        }; // The click handler
 
-  function hasObjectPrototype(o) {
-    return Object.prototype.toString.call(o) === '[object Object]';
-  }
 
-  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 handleFocus = e => {
+          if (preload && preloadMaxAge > 0) {
+            router.loadRoute(nextOpts, {
+              maxAge: preloadMaxAge
+            });
+          }
+        };
 
-      let query = decode(searchStr); // Try to parse any query params that might be json
+        const handleEnter = e => {
+          const target = e.target || {};
 
-      for (let key in query) {
-        const value = query[key];
+          if (preload && preloadMaxAge > 0) {
+            if (target.preloadTimeout) {
+              return;
+            }
 
-        if (typeof value === 'string') {
-          try {
-            query[key] = parser(value);
-          } catch (err) {//
+            target.preloadTimeout = setTimeout(() => {
+              target.preloadTimeout = null;
+              router.loadRoute(nextOpts, {
+                maxAge: preloadMaxAge
+              });
+            }, preloadDelay);
           }
-        }
-      }
-
-      return query;
-    };
-  }
-  function stringifySearchWith(stringify) {
-    return search => {
-      search = _extends$1({}, search);
+        };
 
-      if (search) {
-        Object.keys(search).forEach(key => {
-          const val = search[key];
+        const handleLeave = e => {
+          const target = e.target || {};
 
-          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 (target.preloadTimeout) {
+            clearTimeout(target.preloadTimeout);
+            target.preloadTimeout = null;
           }
-        });
-      }
+        };
 
-      const searchStr = encode(search).toString();
-      return searchStr ? "?" + searchStr : '';
+        return {
+          type: 'internal',
+          next,
+          handleFocus,
+          handleClick,
+          handleEnter,
+          handleLeave,
+          isActive,
+          disabled
+        };
+      }
     };
+    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];
-  }
-
+  exports.cascadeLoaderData = cascadeLoaderData;
+  exports.cleanPath = cleanPath;
   exports.createBrowserHistory = createBrowserHistory;
   exports.createHashHistory = createHashHistory;
   exports.createMemoryHistory = createMemoryHistory;
@@ -2349,19 +2411,26 @@
   exports.createRouteConfig = createRouteConfig;
   exports.createRouteMatch = createRouteMatch;
   exports.createRouter = createRouter;
+  exports.decode = decode;
   exports.defaultParseSearch = defaultParseSearch;
   exports.defaultStringifySearch = defaultStringifySearch;
+  exports.encode = encode;
   exports.functionalUpdate = functionalUpdate;
+  exports.interpolatePath = interpolatePath;
   exports.invariant = invariant;
+  exports.joinPaths = joinPaths;
   exports.last = last;
   exports.matchByPath = matchByPath;
   exports.matchPathname = matchPathname;
   exports.parsePathname = parsePathname;
   exports.parseSearchWith = parseSearchWith;
   exports.replaceEqualDeep = replaceEqualDeep;
-  exports.resolvePath = _resolvePath;
+  exports.resolvePath = resolvePath;
   exports.rootRouteId = rootRouteId;
   exports.stringifySearchWith = stringifySearchWith;
+  exports.trimPath = trimPath;
+  exports.trimPathLeft = trimPathLeft;
+  exports.trimPathRight = trimPathRight;
   exports.warning = warning;
 
   Object.defineProperty(exports, '__esModule', { value: true });