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

package/build/cjs/router-core/build/esm/index.js

@@ -39,23 +39,6 @@ function _extends$1() {
   return _extends$1.apply(this, arguments);
 }
 
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-  return _extends.apply(this, arguments);
-}
-
 /**
  * Actions represent the type of change to a location value.
  *
@@ -199,7 +182,7 @@ function createBrowserHistory(options) {
 
   if (index == null) {
     index = 0;
-    globalHistory.replaceState(_extends({}, globalHistory.state, {
+    globalHistory.replaceState(_extends$1({}, globalHistory.state, {
       idx: index
     }), '');
   }
@@ -214,7 +197,7 @@ function createBrowserHistory(options) {
       state = null;
     }
 
-    return readOnly(_extends({
+    return readOnly(_extends$1({
       pathname: location.pathname,
       hash: '',
       search: ''
@@ -448,7 +431,7 @@ function createHashHistory(options) {
 
   if (index == null) {
     index = 0;
-    globalHistory.replaceState(_extends({}, globalHistory.state, {
+    globalHistory.replaceState(_extends$1({}, globalHistory.state, {
       idx: index
     }), '');
   }
@@ -475,7 +458,7 @@ function createHashHistory(options) {
       state = null;
     }
 
-    return readOnly(_extends({
+    return readOnly(_extends$1({
       pathname: location.pathname,
       hash: '',
       search: ''
@@ -627,7 +610,7 @@ function createMemoryHistory(options) {
       initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,
       initialIndex = _options3.initialIndex;
   var entries = initialEntries.map(function (entry) {
-    var location = readOnly(_extends({
+    var location = readOnly(_extends$1({
       pathname: '/',
       search: '',
       hash: '',
@@ -652,7 +635,7 @@ function createMemoryHistory(options) {
       state = null;
     }
 
-    return readOnly(_extends({
+    return readOnly(_extends$1({
       pathname: location.pathname,
       search: '',
       hash: ''
@@ -849,1464 +832,1636 @@ function parsePath(path) {
   return parsedPath;
 }
 
-// @ts-nocheck
-// We're inlining qss here for compression's sake, but we've included it as a hard dependency for the MIT license it requires.
-function encode(obj, pfx) {
-  var k,
-      i,
-      tmp,
-      str = '';
-
-  for (k in obj) {
-    if ((tmp = obj[k]) !== void 0) {
-      if (Array.isArray(tmp)) {
-        for (i = 0; i < tmp.length; i++) {
-          str && (str += '&');
-          str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp[i]);
-        }
-      } else {
-        str && (str += '&');
-        str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp);
-      }
+var isProduction = process.env.NODE_ENV === 'production';
+var prefix = 'Invariant failed';
+function invariant(condition, message) {
+    if (condition) {
+        return;
     }
-  }
-
-  return (pfx || '') + str;
-}
-
-function toValue(mix) {
-  if (!mix) return '';
-  var str = decodeURIComponent(mix);
-  if (str === 'false') return false;
-  if (str === 'true') return true;
-  return +str * 0 === 0 ? +str : str;
-}
-
-function decode(str) {
-  var tmp,
-      k,
-      out = {},
-      arr = str.split('&');
-
-  while (tmp = arr.shift()) {
-    tmp = tmp.split('=');
-    k = tmp.shift();
-
-    if (out[k] !== void 0) {
-      out[k] = [].concat(out[k], toValue(tmp.shift()));
-    } else {
-      out[k] = toValue(tmp.shift());
+    if (isProduction) {
+        throw new Error(prefix);
     }
-  }
-
-  return out;
+    var provided = typeof message === 'function' ? message() : message;
+    var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+    throw new Error(value);
 }
 
-const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId) {
-  if (options === void 0) {
-    options = {};
-  }
-
-  if (isRoot === void 0) {
-    isRoot = true;
-  }
-
-  if (isRoot) {
-    options.path = rootRouteId;
-  } else {
-    warning(!options.path, 'Routes must have a path property.');
-  } // Strip the root from parentIds
-
+// type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+//   k: infer I,
+// ) => any
+//   ? I
+//   : never
 
-  if (parentId === rootRouteId) {
-    parentId = '';
+/**
+ * This function returns `a` if `b` is deeply equal.
+ * If not, it will replace any deeply equal children of `b` with those of `a`.
+ * This can be used for structural sharing between JSON values for example.
+ */
+function replaceEqualDeep(prev, next) {
+  if (prev === next) {
+    return prev;
   }
 
-  let path = String(isRoot ? rootRouteId : options.path); // If the path is anything other than an index path, trim it up
+  const array = Array.isArray(prev) && Array.isArray(next);
 
-  if (path !== '/') {
-    path = trimPath(path);
-  }
+  if (array || isPlainObject(prev) && isPlainObject(next)) {
+    const aSize = array ? prev.length : Object.keys(prev).length;
+    const bItems = array ? next : Object.keys(next);
+    const bSize = bItems.length;
+    const copy = array ? [] : {};
+    let equalItems = 0;
 
-  let id = joinPaths([parentId, path]);
+    for (let i = 0; i < bSize; i++) {
+      const key = array ? i : bItems[i];
+      copy[key] = replaceEqualDeep(prev[key], next[key]);
 
-  if (path === rootRouteId) {
-    path = '/';
-  }
+      if (copy[key] === prev[key]) {
+        equalItems++;
+      }
+    }
 
-  if (id !== rootRouteId) {
-    id = joinPaths(['/', id]);
+    return aSize === bSize && equalItems === aSize ? prev : copy;
   }
 
-  const fullPath = id === rootRouteId ? '/' : trimPathRight(id);
-  return {
-    id: id,
-    path: path,
-    fullPath: fullPath,
-    options: options,
-    children,
-    addChildren: cb => createRouteConfig(options, cb(childOptions => createRouteConfig(childOptions, undefined, false, id)), false, parentId)
-  };
-};
-const rootRouteId = '__root__';
-// Source
-// Detect if we're in the DOM
-const isDOM = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement); // This is the default history object if none is defined
-
-const createDefaultHistory = () => isDOM ? createBrowserHistory() : createMemoryHistory();
-
-function createRouter(userOptions) {
-  var _userOptions$stringif, _userOptions$parseSea;
-
-  const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
-
-  const originalOptions = _extends$1({}, userOptions, {
-    stringifySearch: (_userOptions$stringif = userOptions == null ? void 0 : userOptions.stringifySearch) != null ? _userOptions$stringif : defaultStringifySearch,
-    parseSearch: (_userOptions$parseSea = userOptions == null ? void 0 : userOptions.parseSearch) != null ? _userOptions$parseSea : defaultParseSearch
-  });
-
-  let router = {
-    options: originalOptions,
-    listeners: [],
-    // Resolved after construction
-    basepath: '',
-    routeTree: undefined,
-    routesById: {},
-    location: undefined,
-    allRouteInfo: undefined,
-    //
-    navigationPromise: Promise.resolve(),
-    resolveNavigation: () => {},
-    preloadCache: {},
-    state: {
-      status: 'idle',
-      location: null,
-      matches: [],
-      actions: {},
-      loaderData: {},
-      lastUpdated: Date.now()
-    },
-    startedLoadingAt: Date.now(),
-    subscribe: listener => {
-      router.listeners.push(listener);
-      return () => {
-        router.listeners = router.listeners.filter(x => x !== listener);
-      };
-    },
-    getRoute: id => {
-      return router.routesById[id];
-    },
-    notify: () => {
-      router.state = _extends$1({}, router.state);
-      router.listeners.forEach(listener => listener());
-    },
-    mount: () => {
-      const next = router.buildLocation({
-        to: '.',
-        search: true,
-        hash: true
-      }); // If the current location isn't updated, trigger a navigation
-      // to the current location. Otherwise, load the current location.
-
-      if (next.href !== router.location.href) {
-        return router.commitLocation(next, true);
-      } else {
-        return router.loadLocation();
-      }
-    },
-    update: opts => {
-      Object.assign(router.options, opts);
-      const {
-        basepath,
-        routeConfig
-      } = router.options;
-      router.basepath = cleanPath("/" + (basepath != null ? basepath : ''));
-
-      if (routeConfig) {
-        router.routesById = {};
-        router.routeTree = router.buildRouteTree(routeConfig);
-      }
+  return next;
+} // Copied from: https://github.com/jonschlinkert/is-plain-object
 
-      return router;
-    },
-    destroy: history.listen(event => {
-      router.loadLocation(router.parseLocation(event.location, router.location));
-    }),
-    buildRouteTree: rootRouteConfig => {
-      const recurseRoutes = (routeConfigs, parent) => {
-        return routeConfigs.map(routeConfig => {
-          const routeOptions = routeConfig.options;
-          const route = createRoute(routeConfig, routeOptions, parent, router); // {
-          //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
-          //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
-          // }
-
-          const existingRoute = router.routesById[route.routeId];
-
-          if (existingRoute) {
-            if (process.env.NODE_ENV !== 'production') {
-              console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
-            }
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  } // If has modified constructor
 
-            throw new Error();
-          }
-          router.routesById[route.routeId] = route;
-          const children = routeConfig.children;
-          route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
-          return route;
-        });
-      };
 
-      const routes = recurseRoutes([rootRouteConfig]);
-      return routes[0];
-    },
-    parseLocation: (location, previousLocation) => {
-      var _location$hash$split$;
+  const ctor = o.constructor;
 
-      const parsedSearch = router.options.parseSearch(location.search);
-      return {
-        pathname: location.pathname,
-        searchStr: location.search,
-        search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
-        hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
-        href: "" + location.pathname + location.search + location.hash,
-        state: location.state,
-        key: location.key
-      };
-    },
-    buildLocation: function buildLocation(dest) {
-      var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
+  if (typeof ctor === 'undefined') {
+    return true;
+  } // If has modified prototype
 
-      if (dest === void 0) {
-        dest = {};
-      }
 
-      // const resolvedFrom: Location = {
-      //   ...router.location,
-      const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
+  const prot = ctor.prototype;
 
-      let pathname = _resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  } // If constructor does not have an Object-specific method
 
-      const fromMatches = router.matchRoutes(router.location.pathname, {
-        strictParseParams: true
-      });
-      const toMatches = router.matchRoutes(pathname);
-      const prevParams = (_last = last(fromMatches)) == null ? void 0 : _last.params;
-      let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
 
-      if (nextParams) {
-        toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
-          Object.assign(nextParams, fn(nextParams));
-        });
-      }
+  if (!prot.hasOwnProperty('isPrototypeOf')) {
+    return false;
+  } // Most likely a plain Object
 
-      pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
 
-      const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search; // Then the link/navigate function
+  return true;
+}
 
-      const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
-      : dest.search ? (_functionalUpdate = functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
-      : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom filters
-      : {}; // Then post filters
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === '[object Object]';
+}
 
-      const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
-      const search = replaceEqualDeep(router.location.search, postFilteredSearch);
-      const searchStr = router.options.stringifySearch(search);
-      let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
-      hash = hash ? "#" + hash : '';
-      return {
-        pathname,
-        search,
-        searchStr,
-        state: router.location.state,
-        hash,
-        href: "" + pathname + searchStr + hash,
-        key: dest.key
-      };
-    },
-    commitLocation: (next, replace) => {
-      const id = '' + Date.now() + Math.random();
-      if (router.navigateTimeout) clearTimeout(router.navigateTimeout);
-      let nextAction = 'replace';
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function warning(cond, message) {
+  if (cond) {
+    if (typeof console !== 'undefined') console.warn(message);
 
-      if (!replace) {
-        nextAction = 'push';
-      }
+    try {
+      throw new Error(message);
+    } catch (_unused) {}
+  }
 
-      const isSameUrl = router.parseLocation(history.location).href === next.href;
+  return true;
+}
 
-      if (isSameUrl && !next.key) {
-        nextAction = 'replace';
-      }
+function isFunction(d) {
+  return typeof d === 'function';
+}
 
-      if (nextAction === 'replace') {
-        history.replace({
-          pathname: next.pathname,
-          hash: next.hash,
-          search: next.searchStr
-        }, {
-          id
-        });
-      } else {
-        history.push({
-          pathname: next.pathname,
-          hash: next.hash,
-          search: next.searchStr
-        }, {
-          id
-        });
-      }
+function functionalUpdate(updater, previous) {
+  if (isFunction(updater)) {
+    return updater(previous);
+  }
 
-      router.navigationPromise = new Promise(resolve => {
-        const previousNavigationResolve = router.resolveNavigation;
+  return updater;
+}
 
-        router.resolveNavigation = () => {
-          previousNavigationResolve();
-          resolve();
-        };
-      });
-      return router.navigationPromise;
-    },
-    buildNext: opts => {
-      const next = router.buildLocation(opts);
-      const matches = router.matchRoutes(next.pathname);
+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 __preSearchFilters = matches.map(match => {
-        var _match$options$preSea;
+      // Extra trailing slash? pop it off
+      if (baseSegments.length > 1 && ((_last = last(baseSegments)) == null ? void 0 : _last.value) === '/') {
+        baseSegments.pop();
+      }
 
-        return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
-      }).flat().filter(Boolean);
+      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 [];
+  }
 
-      const __postSearchFilters = matches.map(match => {
-        var _match$options$postSe;
+  pathname = cleanPath(pathname);
+  const segments = [];
 
-        return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
-      }).flat().filter(Boolean);
+  if (pathname.slice(0, 1) === '/') {
+    pathname = pathname.substring(1);
+    segments.push({
+      type: 'pathname',
+      value: '/'
+    });
+  }
 
-      return router.buildLocation(_extends$1({}, opts, {
-        __preSearchFilters,
-        __postSearchFilters
-      }));
-    },
-    cancelMatches: () => {
-      var _router$state$pending, _router$state$pending2;
-      [...router.state.matches, ...((_router$state$pending = (_router$state$pending2 = router.state.pending) == null ? void 0 : _router$state$pending2.matches) != null ? _router$state$pending : [])].forEach(match => {
-        match.cancel();
-      });
-    },
-    loadLocation: async next => {
-      const id = Math.random();
-      router.startedLoadingAt = id;
+  if (!pathname) {
+    return segments;
+  } // Remove empty segments and '.' segments
 
-      if (next) {
-        // Ingest the new location
-        router.location = next;
-      } // Cancel any pending matches
 
+  const split = pathname.split('/').filter(Boolean);
+  segments.push(...split.map(part => {
+    if (part.startsWith('*')) {
+      return {
+        type: 'wildcard',
+        value: part
+      };
+    }
 
-      router.cancelMatches(); // Match the routes
+    if (part.charAt(0) === ':') {
+      return {
+        type: 'param',
+        value: part
+      };
+    }
 
-      const unloadedMatches = router.matchRoutes(location.pathname, {
-        strictParseParams: true
-      });
-      unloadedMatches.forEach((match, index) => {
-        const parent = unloadedMatches[index - 1];
-        const child = unloadedMatches[index + 1];
-        if (parent) match.__.setParentMatch(parent);
-        if (child) match.__.addChildMatch(child);
-      });
-      router.state = _extends$1({}, router.state, {
-        pending: {
-          matches: unloadedMatches,
-          location: router.location
+    return {
+      type: 'pathname',
+      value: part
+    };
+  }));
+
+  if (pathname.slice(-1) === '/') {
+    pathname = pathname.substring(1);
+    segments.push({
+      type: 'pathname',
+      value: '/'
+    });
+  }
+
+  return segments;
+}
+function interpolatePath(path, params, leaveWildcard) {
+  const interpolatedPathSegments = parsePathname(path);
+  return joinPaths(interpolatedPathSegments.map(segment => {
+    if (segment.value === '*' && !leaveWildcard) {
+      return '';
+    }
+
+    if (segment.type === 'param') {
+      var _segment$value$substr;
+
+      return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
+    }
+
+    return segment.value;
+  }));
+}
+function matchPathname(currentPathname, matchLocation) {
+  const pathParams = matchByPath(currentPathname, matchLocation); // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
+
+  if (matchLocation.to && !pathParams) {
+    return;
+  } // if (matchLocation.search && !searchMatched) {
+  //   return
+  // }
+
+
+  return pathParams != null ? pathParams : {};
+}
+function matchByPath(from, matchLocation) {
+  var _matchLocation$to;
+
+  const baseSegments = parsePathname(from);
+  const routeSegments = parsePathname("" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*'));
+  const params = {};
+
+  let isMatch = (() => {
+    for (let i = 0; i < Math.max(baseSegments.length, routeSegments.length); i++) {
+      const baseSegment = baseSegments[i];
+      const routeSegment = routeSegments[i];
+      const isLastRouteSegment = i === routeSegments.length - 1;
+      const isLastBaseSegment = i === baseSegments.length - 1;
+
+      if (routeSegment) {
+        if (routeSegment.type === 'wildcard') {
+          if (baseSegment != null && baseSegment.value) {
+            params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
+            return true;
+          }
+
+          return false;
         }
-      });
-      router.notify(); // Load the matches
 
-      const matches = await router.loadMatches(unloadedMatches, {
-        withPending: true
-      });
+        if (routeSegment.type === 'pathname') {
+          if (routeSegment.value === '/' && !(baseSegment != null && baseSegment.value)) {
+            return true;
+          }
 
-      if (router.startedLoadingAt !== id) {
-        // Ignore side-effects of match loading
-        return router.navigationPromise;
+          if (baseSegment) {
+            if (matchLocation.caseSensitive) {
+              if (routeSegment.value !== baseSegment.value) {
+                return false;
+              }
+            } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
+              return false;
+            }
+          }
+        }
+
+        if (!baseSegment) {
+          return false;
+        }
+
+        if (routeSegment.type === 'param') {
+          if ((baseSegment == null ? void 0 : baseSegment.value) === '/') {
+            return false;
+          }
+
+          if (!baseSegment.value.startsWith(':')) {
+            params[routeSegment.value.substring(1)] = baseSegment.value;
+          }
+        }
       }
 
-      const previousMatches = router.state.matches;
-      previousMatches.filter(d => {
-        return !matches.find(dd => dd.matchId === d.matchId);
-      }).forEach(d => {
-        d.__.onExit == null ? void 0 : d.__.onExit({
-          params: d.params,
-          search: d.routeSearch
-        });
-      });
-      previousMatches.filter(d => {
-        return matches.find(dd => dd.matchId === d.matchId);
-      }).forEach(d => {
-        d.options.onTransition == null ? void 0 : d.options.onTransition({
-          params: d.params,
-          search: d.routeSearch
-        });
-      });
-      matches.filter(d => {
-        return !previousMatches.find(dd => dd.matchId === d.matchId);
-      }).forEach(d => {
-        d.__.onExit = d.options.onMatch == null ? void 0 : d.options.onMatch({
-          params: d.params,
-          search: d.search
-        });
-      });
-      router.state = _extends$1({}, router.state, {
-        location: router.location,
-        matches,
-        pending: undefined
-      });
+      if (isLastRouteSegment && !isLastBaseSegment) {
+        return !!matchLocation.fuzzy;
+      }
+    }
 
-      if (matches.some(d => d.status === 'loading')) {
+    return true;
+  })();
+
+  return isMatch ? params : undefined;
+}
+
+// @ts-nocheck
+// qss has been slightly modified and inlined here for our use cases (and compression's sake). We've included it as a hard dependency for MIT license attribution.
+function encode(obj, pfx) {
+  var k,
+      i,
+      tmp,
+      str = '';
+
+  for (k in obj) {
+    if ((tmp = obj[k]) !== void 0) {
+      if (Array.isArray(tmp)) {
+        for (i = 0; i < tmp.length; i++) {
+          str && (str += '&');
+          str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp[i]);
+        }
+      } else {
+        str && (str += '&');
+        str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp);
+      }
+    }
+  }
+
+  return (pfx || '') + str;
+}
+
+function toValue(mix) {
+  if (!mix) return '';
+  var str = decodeURIComponent(mix);
+  if (str === 'false') return false;
+  if (str === 'true') return true;
+  return +str * 0 === 0 ? +str : str;
+}
+
+function decode(str) {
+  var tmp,
+      k,
+      out = {},
+      arr = str.split('&');
+
+  while (tmp = arr.shift()) {
+    tmp = tmp.split('=');
+    k = tmp.shift();
+
+    if (out[k] !== void 0) {
+      out[k] = [].concat(out[k], toValue(tmp.shift()));
+    } else {
+      out[k] = toValue(tmp.shift());
+    }
+  }
+
+  return out;
+}
+
+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);
+}
+
+function createRoute(routeConfig, options, parent, router) {
+  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;
+
+        if (!route) {
+          return;
+        }
+
+        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();
-        await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
+
+        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();
+        }
       }
+    };
+    return router.state.actions[id];
+  })();
 
-      if (router.startedLoadingAt !== id) {
-        // Ignore side-effects of match loading
-        return;
+  const loader = router.state.loaders[id] || (() => {
+    router.state.loaders[id] = {
+      pending: [],
+      fetch: async loaderContext => {
+        if (!route) {
+          return;
+        }
+
+        const loaderState = {
+          loadedAt: Date.now(),
+          loaderContext
+        };
+        loader.current = loaderState;
+        loader.latest = loaderState;
+        loader.pending.push(loaderState); // router.state = {
+        //   ...router.state,
+        //   currentAction: loaderState,
+        //   latestAction: loaderState,
+        // }
+
+        router.notify();
+
+        try {
+          return await (route.options.loader == null ? void 0 : route.options.loader(loaderContext));
+        } finally {
+          loader.pending = loader.pending.filter(d => d !== loaderState); // router.removeActionQueue.push({ loader, loaderState })
+
+          router.notify();
+        }
       }
+    };
+    return router.state.loaders[id];
+  })();
 
-      router.notify();
-      router.resolveNavigation();
+  let route = {
+    routeId: id,
+    routeRouteId: routeId,
+    routePath,
+    fullPath,
+    options,
+    router,
+    childRoutes: undefined,
+    parentRoute: parent,
+    action,
+    loader: loader,
+    buildLink: options => {
+      return router.buildLink(_extends({}, options, {
+        from: fullPath
+      }));
+    },
+    navigate: options => {
+      return router.navigate(_extends({}, options, {
+        from: fullPath
+      }));
     },
-    cleanPreloadCache: () => {
-      const now = Date.now();
-      Object.keys(router.preloadCache).forEach(matchId => {
-        const entry = router.preloadCache[matchId]; // Don't remove loading matches
-
-        if (entry.match.status === 'loading') {
-          return;
-        } // Do not remove successful matches that are still valid
+    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 (parent) {
+      match.loaderData = replaceEqualDeep(match.loaderData, _extends({}, parent.loaderData, match.routeLoaderData));
+    }
+  });
+}
 
-        if (entry.match.updatedAt && entry.match.updatedAt + entry.maxAge > now) {
-          return;
-        } // Everything else gets removed
+const rootRouteId = '__root__';
+const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId, parentPath) {
+  if (options === void 0) {
+    options = {};
+  }
 
+  if (isRoot === void 0) {
+    isRoot = true;
+  }
 
-        delete router.preloadCache[matchId];
-      });
-    },
-    loadRoute: async function loadRoute(navigateOpts, loaderOpts) {
-      if (navigateOpts === void 0) {
-        navigateOpts = router.location;
-      }
+  if (isRoot) {
+    options.path = rootRouteId;
+  } // Strip the root from parentIds
 
-      const next = router.buildNext(navigateOpts);
-      const matches = router.matchRoutes(next.pathname, {
-        strictParseParams: true
-      });
-      await router.loadMatches(matches, {
-        preload: true,
-        maxAge: loaderOpts.maxAge
-      });
-      return matches;
-    },
-    matchRoutes: (pathname, opts) => {
-      var _router$state$pending3, _router$state$pending4;
 
-      router.cleanPreloadCache();
-      const matches = [];
+  if (parentId === rootRouteId) {
+    parentId = '';
+  }
 
-      if (!router.routeTree) {
-        return matches;
-      }
+  let path = isRoot ? rootRouteId : options.path; // If the path is anything other than an index path, trim it up
 
-      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 (path && path !== '/') {
+    path = trimPath(path);
+  }
 
-      const recurse = async (routes, parentMatch) => {
-        var _parentMatch$params, _router$options$filte, _router$preloadCache$, _route$childRoutes2;
+  const routeId = path || options.id;
+  let id = joinPaths([parentId, routeId]);
 
-        let params = (_parentMatch$params = parentMatch == null ? void 0 : parentMatch.params) != null ? _parentMatch$params : {};
-        const filteredRoutes = (_router$options$filte = router.options.filterRoutes == null ? void 0 : router.options.filterRoutes(routes)) != null ? _router$options$filte : routes;
-        const route = filteredRoutes == null ? void 0 : filteredRoutes.find(route => {
-          var _route$childRoutes, _route$options$caseSe;
-
-          const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length);
-          const matchParams = matchPathname(pathname, {
-            to: route.fullPath,
-            fuzzy,
-            caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
-          });
+  if (path === rootRouteId) {
+    path = '/';
+  }
 
-          if (matchParams) {
-            let parsedParams;
+  if (id !== rootRouteId) {
+    id = joinPaths(['/', id]);
+  }
 
-            try {
-              var _route$options$parseP;
+  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)
+  };
+};
 
-              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;
-              }
-            }
+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,
+    invalidAt: Infinity,
+    getIsInvalid: () => {
+      const now = Date.now();
+      return routeMatch.isInvalid || routeMatch.invalidAt < now;
+    },
+    __: {
+      abortController: new AbortController(),
+      latestId: '',
+      resolve: () => {},
+      notify: () => {
+        routeMatch.__.resolve();
 
-            params = _extends$1({}, params, parsedParams);
-          }
+        routeMatch.router.notify();
+      },
+      startPending: () => {
+        var _routeMatch$options$p, _routeMatch$options$p2;
 
-          return !!matchParams;
-        });
+        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 (!route) {
+        if (routeMatch.__.pendingTimeout || routeMatch.status !== 'loading' || typeof pendingMs === 'undefined') {
           return;
         }
 
-        const interpolatedPath = interpolatePath(route.routePath, params);
-        const matchId = interpolatePath(route.routeId, params, true);
-        const match = existingMatches.find(d => d.matchId === matchId) || ((_router$preloadCache$ = router.preloadCache[matchId]) == null ? void 0 : _router$preloadCache$.match) || createRouteMatch(router, route, {
-          matchId,
-          params,
-          pathname: joinPaths([pathname, interpolatedPath])
-        });
-        matches.push(match);
+        routeMatch.__.pendingTimeout = setTimeout(() => {
+          routeMatch.isPending = true;
 
-        if ((_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length) {
-          recurse(route.childRoutes, match);
-        }
-      };
+          routeMatch.__.resolve();
 
-      recurse([router.routeTree]);
-      return matches;
-    },
-    loadMatches: async (resolvedMatches, loaderOpts) => {
-      const matchPromises = resolvedMatches.map(async match => {
-        // Validate the match (loads search params etc)
-        match.__.validate(); // If this is a preload, add it to the preload cache
+          if (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;
 
+        // 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 (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
+        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
 
+          if (prevSearch !== nextSearch) {
+            routeMatch.isInvalid = true;
+          }
 
-        if (match.status === 'success' && match.isInvalid || match.status === 'error' || match.status === 'idle') {
-          match.load();
-        } // If requested, start the pending timers
+          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
 
+          return;
+        }
+      }
+    },
+    cancel: () => {
+      var _routeMatch$__$abortC;
 
-        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
+      (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
 
-        await match.__.loadPromise;
-      });
-      router.notify();
-      await Promise.all(matchPromises);
-      return resolvedMatches;
+      routeMatch.__.cancelPending();
     },
-    invalidateRoute: opts => {
-      var _router$state$pending5, _router$state$pending6;
-
-      const next = router.buildNext(opts);
-      const unloadedMatchIds = router.matchRoutes(next.pathname).map(d => d.matchId);
-      [...router.state.matches, ...((_router$state$pending5 = (_router$state$pending6 = router.state.pending) == null ? void 0 : _router$state$pending6.matches) != null ? _router$state$pending5 : [])].forEach(match => {
-        if (unloadedMatchIds.includes(match.matchId)) {
-          match.isInvalid = true;
-        }
-      });
+    invalidate: () => {
+      routeMatch.isInvalid = true;
     },
-    reload: () => router._navigate({
-      fromCurrent: true,
-      replace: true,
-      search: true
-    }),
-    resolvePath: (from, path) => {
-      return _resolvePath(router.basepath, from, cleanPath(path));
+    hasLoaders: () => {
+      return !!(route.options.loader || elementTypes.some(d => typeof route.options[d] === 'function'));
     },
-    matchRoute: (location, opts) => {
-      var _location$from;
-
-      // const location = router.buildNext(opts)
-      location = _extends$1({}, location, {
-        to: location.to ? router.resolvePath((_location$from = location.from) != null ? _location$from : '', location.to) : undefined
-      });
-      const next = router.buildNext(location);
-
-      if (opts != null && opts.pending) {
-        var _router$state$pending7;
+    load: async loaderOpts => {
+      const now = Date.now();
+      const minMaxAge = loaderOpts != null && loaderOpts.preload ? Math.max(loaderOpts == null ? void 0 : loaderOpts.maxAge, loaderOpts == null ? void 0 : loaderOpts.gcMaxAge) : 0; // If this is a preload, add it to the preload cache
 
-        if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
-          return false;
+      if (loaderOpts != null && loaderOpts.preload && minMaxAge > 0) {
+        // If the match is currently active, don't preload it
+        if (router.state.matches.find(d => d.matchId === routeMatch.matchId)) {
+          return;
         }
 
-        return !!matchPathname(router.state.pending.location.pathname, _extends$1({}, opts, {
-          to: next.pathname
-        }));
-      }
-
-      return !!matchPathname(router.state.location.pathname, _extends$1({}, opts, {
-        to: next.pathname
-      }));
-    },
-    _navigate: location => {
-      const next = router.buildNext(location);
-      return router.commitLocation(next, location.replace);
-    },
-    navigate: async _ref => {
-      let {
-        from,
-        to = '.',
-        search,
-        hash,
-        replace
-      } = _ref;
-      // If this link simply reloads the current route,
-      // make sure it has a new key so it will trigger a data refresh
-      // If this `to` is a valid external URL, return
-      // null for LinkUtils
-      const toString = String(to);
-      const fromString = String(from);
-      let isExternal;
-
-      try {
-        new URL("" + toString);
-        isExternal = true;
-      } catch (e) {}
+        router.matchCache[routeMatch.matchId] = {
+          gc: now + loaderOpts.gcMaxAge,
+          match: routeMatch
+        };
+      } // If the match is invalid, errored or idle, trigger it to load
 
-      if (isExternal) {
-        if (process.env.NODE_ENV !== 'production') {
-          throw new Error('Attempting to navigate to external url with router.navigate!');
-        }
 
-        return;
+      if (routeMatch.status === 'success' && routeMatch.getIsInvalid() || routeMatch.status === 'error' || routeMatch.status === 'idle') {
+        const maxAge = loaderOpts != null && loaderOpts.preload ? loaderOpts == null ? void 0 : loaderOpts.maxAge : undefined;
+        routeMatch.fetch({
+          maxAge
+        });
       }
-
-      return router._navigate({
-        from: fromString,
-        to: toString,
-        search,
-        hash
-      });
     },
-    buildLink: _ref2 => {
-      var _preload, _ref3, _ref4;
+    fetch: async opts => {
+      const id = '' + Date.now() + Math.random();
+      routeMatch.__.latestId = id; // If the match was in an error state, set it
+      // to a loading state again. Otherwise, keep it
+      // as loading or resolved
 
-      let {
-        from,
-        to = '.',
-        search,
-        params,
-        hash,
-        target,
-        replace,
-        activeOptions,
-        preload,
-        preloadMaxAge: userPreloadMaxAge,
-        preloadDelay: userPreloadDelay,
-        disabled
-      } = _ref2;
+      if (routeMatch.status === 'idle') {
+        routeMatch.status = 'loading';
+      } // We started loading the route, so it's no longer invalid
 
-      // 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 = (_ref3 = userPreloadMaxAge != null ? userPreloadMaxAge : router.options.defaultLinkPreloadMaxAge) != null ? _ref3 : 2000;
-      const preloadDelay = (_ref4 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultLinkPreloadDelay) != null ? _ref4 : 50; // Compare path/hash for matches
+      routeMatch.isInvalid = false;
+      routeMatch.__.loadPromise = new Promise(async resolve => {
+        // We are now fetching, even if it's in the background of a
+        // resolved state
+        routeMatch.isFetching = true;
+        routeMatch.__.resolve = resolve;
+
+        const loaderPromise = (async () => {
+          // Load the elements and data in parallel
+          routeMatch.__.elementsPromise = (async () => {
+            // then run all element and data loaders in parallel
+            // For each element type, potentially load it asynchronously
+            await Promise.all(elementTypes.map(async type => {
+              const routeElement = routeMatch.options[type];
 
-      const pathIsEqual = router.state.location.pathname === next.pathname;
-      const currentPathSplit = router.state.location.pathname.split('/');
-      const nextPathSplit = next.pathname.split('/');
-      const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
-      const hashIsEqual = router.state.location.hash === next.hash; // Combine the matches based on user options
+              if (routeMatch.__[type]) {
+                return;
+              }
 
-      const pathTest = activeOptions != null && activeOptions.exact ? pathIsEqual : pathIsFuzzyEqual;
-      const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true; // The final "active" test
+              routeMatch.__[type] = await router.options.createElement(routeElement);
+            }));
+          })();
 
-      const isActive = pathTest && hashTest; // The click handler
+          routeMatch.__.dataPromise = Promise.resolve().then(async () => {
+            try {
+              var _ref, _ref2, _opts$maxAge;
 
-      const handleClick = e => {
-        if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
-          e.preventDefault();
+              if (routeMatch.options.loader) {
+                const data = await routeMatch.options.loader({
+                  params: routeMatch.params,
+                  search: routeMatch.routeSearch,
+                  signal: routeMatch.__.abortController.signal
+                });
 
-          if (pathIsEqual && !search && !hash) {
-            router.invalidateRoute(nextOpts);
-          } // All is well? Navigate!)
+                if (id !== routeMatch.__.latestId) {
+                  return routeMatch.__.loaderPromise;
+                }
 
+                routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
+              }
 
-          router._navigate(nextOpts);
-        }
-      }; // The click handler
+              routeMatch.error = undefined;
+              routeMatch.status = 'success';
+              routeMatch.updatedAt = Date.now();
+              routeMatch.invalidAt = routeMatch.updatedAt + ((_ref = (_ref2 = (_opts$maxAge = opts == null ? void 0 : opts.maxAge) != null ? _opts$maxAge : routeMatch.options.loaderMaxAge) != null ? _ref2 : router.options.defaultLoaderMaxAge) != null ? _ref : 0);
+            } catch (err) {
+              if (id !== routeMatch.__.latestId) {
+                return routeMatch.__.loaderPromise;
+              }
 
+              if (process.env.NODE_ENV !== 'production') {
+                console.error(err);
+              }
 
-      const handleFocus = e => {
-        if (preload && preloadMaxAge > 0) {
-          router.loadRoute(nextOpts, {
-            maxAge: preloadMaxAge
+              routeMatch.error = err;
+              routeMatch.status = 'error';
+              routeMatch.updatedAt = Date.now();
+            }
           });
-        }
-      };
 
-      const handleEnter = e => {
-        const target = e.target || {};
+          try {
+            await Promise.all([routeMatch.__.elementsPromise, routeMatch.__.dataPromise]);
 
-        if (preload && preloadMaxAge > 0) {
-          if (target.preloadTimeout) {
-            return;
-          }
+            if (id !== routeMatch.__.latestId) {
+              return routeMatch.__.loaderPromise;
+            }
 
-          target.preloadTimeout = setTimeout(() => {
-            target.preloadTimeout = null;
-            router.loadRoute(nextOpts, {
-              maxAge: preloadMaxAge
-            });
-          }, preloadDelay);
-        }
-      };
+            if (routeMatch.__.pendingMinPromise) {
+              await routeMatch.__.pendingMinPromise;
+              delete routeMatch.__.pendingMinPromise;
+            }
+          } finally {
+            if (id !== routeMatch.__.latestId) {
+              return routeMatch.__.loaderPromise;
+            }
 
-      const handleLeave = e => {
-        const target = e.target || {};
+            routeMatch.__.cancelPending();
 
-        if (target.preloadTimeout) {
-          clearTimeout(target.preloadTimeout);
-          target.preloadTimeout = null;
+            routeMatch.isPending = false;
+            routeMatch.isFetching = false;
+
+            routeMatch.__.notify();
+          }
+        })();
+
+        routeMatch.__.loaderPromise = loaderPromise;
+        await loaderPromise;
+
+        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(_ref5 => {
-          let {
-            routeLoaderData: loaderData,
-            matchId
-          } = _ref5;
-          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[routeId] || (() => {
-    router.state.actions[routeId] = {
-      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.latest = actionState;
-        action.pending.push(actionState);
-        router.state = _extends$1({}, router.state, {
-          action: 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;
+          query[key] = parser(value);
+        } catch (err) {//
+        }
+      }
+    }
 
-          if (invalidate) {
-            router.invalidateRoute({
-              to: '.',
-              fromCurrent: true
-            });
-            await router.reload();
-          }
+    return query;
+  };
+}
+function stringifySearchWith(stringify) {
+  return search => {
+    search = _extends({}, search);
 
-          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);
+    if (search) {
+      Object.keys(search).forEach(key => {
+        const val = search[key];
 
-          if (actionState === router.state.action) {
-            router.state.action = undefined;
+        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
           }
-
-          router.notify();
         }
-      }
-    };
-    return router.state.actions[routeId];
-  })();
+      });
+    }
 
-  let route = {
-    routeId,
-    routePath,
-    fullPath,
-    options,
-    router,
-    childRoutes: undefined,
-    parentRoute: parent,
-    action,
-    buildLink: options => {
-      return router.buildLink(_extends$1({}, options, {
-        from: fullPath
-      }));
+    const searchStr = encode(search).toString();
+    return searchStr ? "?" + searchStr : '';
+  };
+}
+
+var _window$document;
+// Detect if we're in the DOM
+const isServer = Boolean(typeof window === 'undefined' || !((_window$document = window.document) != null && _window$document.createElement)); // This is the default history object if none is defined
+
+const createDefaultHistory = () => !isServer ? createBrowserHistory() : createMemoryHistory();
+
+function createRouter(userOptions) {
+  var _userOptions$stringif, _userOptions$parseSea;
+
+  const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
+
+  const originalOptions = _extends({
+    defaultLoaderGcMaxAge: 5 * 60 * 1000,
+    defaultLoaderMaxAge: 0,
+    defaultPreloadMaxAge: 2000,
+    defaultPreloadDelay: 50
+  }, userOptions, {
+    stringifySearch: (_userOptions$stringif = userOptions == null ? void 0 : userOptions.stringifySearch) != null ? _userOptions$stringif : defaultStringifySearch,
+    parseSearch: (_userOptions$parseSea = userOptions == null ? void 0 : userOptions.parseSearch) != null ? _userOptions$parseSea : defaultParseSearch
+  });
+
+  let router = {
+    history,
+    options: originalOptions,
+    listeners: [],
+    removeActionQueue: [],
+    // Resolved after construction
+    basepath: '',
+    routeTree: undefined,
+    routesById: {},
+    location: undefined,
+    allRouteInfo: undefined,
+    //
+    navigationPromise: Promise.resolve(),
+    resolveNavigation: () => {},
+    matchCache: {},
+    state: {
+      status: 'idle',
+      location: null,
+      matches: [],
+      actions: {},
+      loaders: {},
+      loaderData: {},
+      lastUpdated: Date.now(),
+      isFetching: false,
+      isPreloading: false
+    },
+    startedLoadingAt: Date.now(),
+    subscribe: listener => {
+      router.listeners.push(listener);
+      return () => {
+        router.listeners = router.listeners.filter(x => x !== listener);
+      };
     },
-    navigate: options => {
-      return router.navigate(_extends$1({}, options, {
-        from: fullPath
-      }));
+    getRoute: id => {
+      return router.routesById[id];
     },
-    matchRoute: (matchLocation, opts) => {
-      return router.matchRoute(_extends$1({}, matchLocation, {
-        from: fullPath
-      }), opts);
-    }
-  };
-  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();
+    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.
 
-        routeMatch.router.notify();
-      },
-      startPending: () => {
-        var _routeMatch$options$p, _routeMatch$options$p2;
 
-        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 (next.href !== router.location.href) {
+        router.__.commitLocation(next, true);
+      } else {
+        router.loadLocation();
+      }
 
-        if (routeMatch.__.pendingTimeout || routeMatch.status !== 'loading' || typeof pendingMs === 'undefined') {
-          return;
-        }
+      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.__.pendingTimeout = setTimeout(() => {
-          routeMatch.isPending = true;
+      if (!isServer && window.addEventListener) {
+        // Listen to visibillitychange and focus
+        window.addEventListener('visibilitychange', router.onFocus, false);
+        window.addEventListener('focus', router.onFocus, false);
+      }
 
-          routeMatch.__.resolve();
+      return () => {
+        unsub(); // Be sure to unsubscribe if a new handler is set
 
-          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.parentMatch = parentMatch;
-      },
-      addChildMatch: childMatch => {
-        if (routeMatch.childMatches.find(d => d.matchId === childMatch.matchId)) {
-          return;
-        }
+        window.removeEventListener('visibilitychange', router.onFocus);
+        window.removeEventListener('focus', router.onFocus);
+      };
+    },
+    onFocus: () => {
+      router.loadLocation();
+    },
+    update: opts => {
+      Object.assign(router.options, opts);
+      const {
+        basepath,
+        routeConfig
+      } = router.options;
+      router.basepath = cleanPath("/" + (basepath != null ? basepath : ''));
 
-        routeMatch.childMatches.push(childMatch);
-      },
-      validate: () => {
-        var _routeMatch$parentMat, _routeMatch$parentMat2;
+      if (routeConfig) {
+        router.routesById = {};
+        router.routeTree = router.__.buildRouteTree(routeConfig);
+      }
 
-        // 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;
+      return router;
+    },
+    cancelMatches: () => {
+      var _router$state$pending, _router$state$pending2;
+      [...router.state.matches, ...((_router$state$pending = (_router$state$pending2 = router.state.pending) == null ? void 0 : _router$state$pending2.matches) != null ? _router$state$pending : [])].forEach(match => {
+        match.cancel();
+      });
+    },
+    loadLocation: async next => {
+      const id = Math.random();
+      router.startedLoadingAt = id;
 
-        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
+      if (next) {
+        // Ingest the new location
+        router.location = next;
+      } // Clear out old actions
 
-          if (prevSearch !== nextSearch) {
-            routeMatch.isInvalid = true;
-          }
 
-          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
+      router.removeActionQueue.forEach(_ref => {
+        let {
+          action,
+          actionState
+        } = _ref;
 
-          return;
+        if (router.state.currentAction === actionState) {
+          router.state.currentAction = undefined;
         }
-      }
-    },
-    cancel: () => {
-      var _routeMatch$__$abortC;
 
-      (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
+        if (action.current === actionState) {
+          action.current = undefined;
+        }
+      });
+      router.removeActionQueue = []; // Cancel any pending matches
 
-      routeMatch.__.cancelPending();
-    },
-    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
+      router.cancelMatches(); // Match the routes
 
-      if (routeMatch.status === 'error' || routeMatch.status === 'idle') {
-        routeMatch.status = 'loading';
-      } // We started loading the route, so it's no longer invalid
+      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
 
+      await router.loadMatches(matches, {
+        withPending: true
+      });
 
-      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 (router.startedLoadingAt !== id) {
+        // Ignore side-effects of match loading
+        return router.navigationPromise;
+      }
 
-        const loaderPromise = (async () => {
-          const importer = routeMatch.options.import; // First, run any importers
+      const previousMatches = router.state.matches;
+      const exiting = [],
+            staying = [];
+      previousMatches.forEach(d => {
+        if (matches.find(dd => dd.matchId === d.matchId)) {
+          staying.push(d);
+        } else {
+          exiting.push(d);
+        }
+      });
+      const now = Date.now();
+      exiting.forEach(d => {
+        var _ref2, _d$options$loaderGcMa, _ref3, _d$options$loaderMaxA;
 
-          if (importer) {
-            routeMatch.__.importPromise = importer({
-              params: routeMatch.params // search: routeMatch.search,
+        d.__.onExit == null ? void 0 : d.__.onExit({
+          params: d.params,
+          search: d.routeSearch
+        }); // Clear idle error states when match leaves
 
-            }).then(imported => {
-              routeMatch.__ = _extends$1({}, routeMatch.__, imported);
-            });
-          } // Wait for the importer to finish before
-          // attempting to load elements and data
+        if (d.status === 'error' && !d.isFetching) {
+          d.status = 'idle';
+          d.error = undefined;
+        }
 
+        const gc = Math.max((_ref2 = (_d$options$loaderGcMa = d.options.loaderGcMaxAge) != null ? _d$options$loaderGcMa : router.options.defaultLoaderGcMaxAge) != null ? _ref2 : 0, (_ref3 = (_d$options$loaderMaxA = d.options.loaderMaxAge) != null ? _d$options$loaderMaxA : router.options.defaultLoaderMaxAge) != null ? _ref3 : 0);
 
-          await routeMatch.__.importPromise; // Next, load the elements and data in parallel
+        if (gc > 0) {
+          router.matchCache[d.matchId] = {
+            gc: gc == Infinity ? Number.MAX_SAFE_INTEGER : now + gc,
+            match: d
+          };
+        }
+      });
+      staying.forEach(d => {
+        d.options.onTransition == null ? void 0 : d.options.onTransition({
+          params: d.params,
+          search: d.routeSearch
+        });
+      });
+      const entering = matches.filter(d => {
+        return !previousMatches.find(dd => dd.matchId === d.matchId);
+      });
+      entering.forEach(d => {
+        d.__.onExit = d.options.onMatch == null ? void 0 : d.options.onMatch({
+          params: d.params,
+          search: d.search
+        });
+        delete router.matchCache[d.matchId];
+      });
 
-          routeMatch.__.elementsPromise = (async () => {
-            // then run all element and data loaders in parallel
-            // For each element type, potentially load it asynchronously
-            const elementTypes = ['element', 'errorElement', 'catchElement', 'pendingElement'];
-            await Promise.all(elementTypes.map(async type => {
-              const routeElement = routeMatch.options[type];
+      if (matches.some(d => d.status === 'loading')) {
+        router.notify();
+        await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
+      }
 
-              if (routeMatch.__[type]) {
-                return;
-              }
+      if (router.startedLoadingAt !== id) {
+        // Ignore side-effects of match loading
+        return;
+      }
 
-              if (typeof routeElement === 'function') {
-                const res = await routeElement(routeMatch);
-                routeMatch.__[type] = res;
-              } else {
-                routeMatch.__[type] = routeMatch.options[type];
-              }
-            }));
-          })();
+      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
 
-          routeMatch.__.dataPromise = Promise.resolve().then(async () => {
-            try {
-              const data = await (routeMatch.options.loader == null ? void 0 : routeMatch.options.loader({
-                params: routeMatch.params,
-                search: routeMatch.routeSearch,
-                signal: routeMatch.__.abortController.signal
-              }));
+        if (entry.match.status === 'loading') {
+          return;
+        } // Do not remove successful matches that are still valid
 
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
-              }
 
-              routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
-              cascadeLoaderData(routeMatch);
-              routeMatch.error = undefined;
-              routeMatch.status = 'success';
-              routeMatch.updatedAt = Date.now();
-            } catch (err) {
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
-              }
+        if (entry.gc > 0 && entry.gc > now) {
+          return;
+        } // Everything else gets removed
 
-              if (process.env.NODE_ENV !== 'production') {
-                console.error(err);
-              }
 
-              routeMatch.error = err;
-              routeMatch.status = 'error';
-              routeMatch.updatedAt = Date.now();
-            }
-          });
+        delete router.matchCache[matchId];
+      });
+    },
+    loadRoute: async function loadRoute(navigateOpts) {
+      if (navigateOpts === void 0) {
+        navigateOpts = router.location;
+      }
 
-          try {
-            await Promise.all([routeMatch.__.elementsPromise, routeMatch.__.dataPromise]);
+      const next = router.buildNext(navigateOpts);
+      const matches = router.matchRoutes(next.pathname, {
+        strictParseParams: true
+      });
+      await router.loadMatches(matches);
+      return matches;
+    },
+    preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
+      var _ref4, _ref5, _loaderOpts$maxAge, _ref6, _ref7, _loaderOpts$gcMaxAge;
 
-            if (id !== routeMatch.__.latestId) {
-              return routeMatch.__.loaderPromise;
-            }
+      if (navigateOpts === void 0) {
+        navigateOpts = router.location;
+      }
+
+      const next = router.buildNext(navigateOpts);
+      const matches = router.matchRoutes(next.pathname, {
+        strictParseParams: true
+      });
+      await router.loadMatches(matches, {
+        preload: true,
+        maxAge: (_ref4 = (_ref5 = (_loaderOpts$maxAge = loaderOpts.maxAge) != null ? _loaderOpts$maxAge : router.options.defaultPreloadMaxAge) != null ? _ref5 : router.options.defaultLoaderMaxAge) != null ? _ref4 : 0,
+        gcMaxAge: (_ref6 = (_ref7 = (_loaderOpts$gcMaxAge = loaderOpts.gcMaxAge) != null ? _loaderOpts$gcMaxAge : router.options.defaultPreloadGcMaxAge) != null ? _ref7 : router.options.defaultLoaderGcMaxAge) != null ? _ref6 : 0
+      });
+      return matches;
+    },
+    matchRoutes: (pathname, opts) => {
+      var _router$state$pending3, _router$state$pending4;
 
-            if (routeMatch.__.pendingMinPromise) {
-              await routeMatch.__.pendingMinPromise;
-              delete routeMatch.__.pendingMinPromise;
-            }
-          } finally {
-            if (id !== routeMatch.__.latestId) {
-              return routeMatch.__.loaderPromise;
-            }
+      router.cleanMatchCache();
+      const matches = [];
 
-            routeMatch.__.cancelPending();
+      if (!router.routeTree) {
+        return matches;
+      }
 
-            routeMatch.isPending = false;
-            routeMatch.isFetching = false;
+      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 : [])];
 
-            routeMatch.__.notify();
-          }
-        })();
+      const recurse = async routes => {
+        var _parentMatch$params, _router$options$filte, _foundRoute$childRout;
 
-        routeMatch.__.loaderPromise = loaderPromise;
-        await loaderPromise;
+        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 (id !== routeMatch.__.latestId) {
-          return routeMatch.__.loaderPromise;
-        }
+        const findMatchInRoutes = (parentRoutes, routes) => {
+          routes.some(route => {
+            var _route$childRoutes, _route$childRoutes2, _route$options$caseSe;
 
-        delete routeMatch.__.loaderPromise;
-      });
-      return await routeMatch.__.loadPromise;
-    }
-  });
+            if (!route.routePath && (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length) {
+              return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
+            }
 
-  return routeMatch;
-}
+            const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length);
+            const matchParams = matchPathname(pathname, {
+              to: route.fullPath,
+              fuzzy,
+              caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
+            });
 
-function cascadeLoaderData(routeMatch) {
-  if (routeMatch.parentMatch) {
-    routeMatch.loaderData = replaceEqualDeep(routeMatch.loaderData, _extends$1({}, routeMatch.parentMatch.loaderData, routeMatch.routeLoaderData));
-  }
+            if (matchParams) {
+              let parsedParams;
 
-  if (routeMatch.childMatches.length) {
-    routeMatch.childMatches.forEach(childMatch => {
-      cascadeLoaderData(childMatch);
-    });
-  }
-}
+              try {
+                var _route$options$parseP;
 
-function matchPathname(currentPathname, matchLocation) {
-  const pathParams = matchByPath(currentPathname, matchLocation); // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
+                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 (matchLocation.to && !pathParams) {
-    return;
-  } // if (matchLocation.search && !searchMatched) {
-  //   return
-  // }
+              params = _extends({}, params, parsedParams);
+            }
 
+            if (!!matchParams) {
+              foundRoutes = [...parentRoutes, route];
+            }
 
-  return pathParams != null ? pathParams : {};
-}
+            return !!foundRoutes.length;
+          });
+          return !!foundRoutes.length;
+        };
 
-function interpolatePath(path, params, leaveWildcard) {
-  const interpolatedPathSegments = parsePathname(path);
-  return joinPaths(interpolatedPathSegments.map(segment => {
-    if (segment.value === '*' && !leaveWildcard) {
-      return '';
-    }
+        findMatchInRoutes([], filteredRoutes);
 
-    if (segment.type === 'param') {
-      var _segment$value$substr;
+        if (!foundRoutes.length) {
+          return;
+        }
 
-      return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
-    }
+        foundRoutes.forEach(foundRoute => {
+          var _router$matchCache$ma;
 
-    return segment.value;
-  }));
-}
+          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);
 
-function warning(cond, message) {
-  if (cond) {
-    if (typeof console !== 'undefined') console.warn(message);
+        if ((_foundRoute$childRout = foundRoute.childRoutes) != null && _foundRoute$childRout.length) {
+          recurse(foundRoute.childRoutes);
+        }
+      };
 
-    try {
-      throw new Error(message);
-    } catch (_unused) {}
-  }
+      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();
 
-  return true;
-}
+        match.load(loaderOpts);
 
-function isFunction(d) {
-  return typeof d === 'function';
-}
+        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
 
-function functionalUpdate(updater, previous) {
-  if (isFunction(updater)) {
-    return updater(previous);
-  }
+          await match.__.loadPromise;
+        }
+      });
+      router.notify();
+      await Promise.all(matchPromises);
+    },
+    invalidateRoute: opts => {
+      var _router$state$pending5, _router$state$pending6;
 
-  return updater;
-}
+      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;
 
-function joinPaths(paths) {
-  return cleanPath(paths.filter(Boolean).join('/'));
-}
+      // 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);
 
-function cleanPath(path) {
-  // remove double slashes
-  return path.replace(/\/{2,}/g, '/');
-}
+      if (opts != null && opts.pending) {
+        var _router$state$pending7;
 
-function trimPathLeft(path) {
-  return path === '/' ? path : path.replace(/^\/{1,}/, '');
-}
+        if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
+          return false;
+        }
 
-function trimPathRight(path) {
-  return path === '/' ? path : path.replace(/\/{1,}$/, '');
-}
+        return !!matchPathname(router.state.pending.location.pathname, _extends({}, opts, {
+          to: next.pathname
+        }));
+      }
 
-function trimPath(path) {
-  return trimPathRight(trimPathLeft(path));
-}
+      return !!matchPathname(router.state.location.pathname, _extends({}, opts, {
+        to: next.pathname
+      }));
+    },
+    navigate: async _ref8 => {
+      let {
+        from,
+        to = '.',
+        search,
+        hash,
+        replace,
+        params
+      } = _ref8;
+      // If this link simply reloads the current route,
+      // make sure it has a new key so it will trigger a data refresh
+      // If this `to` is a valid external URL, return
+      // null for LinkUtils
+      const toString = String(to);
+      const fromString = String(from);
+      let isExternal;
 
-function matchByPath(from, matchLocation) {
-  var _matchLocation$to;
+      try {
+        new URL("" + toString);
+        isExternal = true;
+      } catch (e) {}
 
-  const baseSegments = parsePathname(from);
-  const routeSegments = parsePathname("" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*'));
-  const params = {};
+      invariant(!isExternal, 'Attempting to navigate to external url with router.navigate!');
+      return router.__.navigate({
+        from: fromString,
+        to: toString,
+        search,
+        hash,
+        replace,
+        params
+      });
+    },
+    buildLink: _ref9 => {
+      var _preload, _ref10;
 
-  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;
+      let {
+        from,
+        to = '.',
+        search,
+        params,
+        hash,
+        target,
+        replace,
+        activeOptions,
+        preload,
+        preloadMaxAge: userPreloadMaxAge,
+        preloadGcMaxAge: userPreloadGcMaxAge,
+        preloadDelay: userPreloadDelay,
+        disabled
+      } = _ref9;
 
-      if (routeSegment) {
-        if (routeSegment.type === 'wildcard') {
-          if (baseSegment != null && baseSegment.value) {
-            params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
-            return true;
-          }
+      // If this link simply reloads the current route,
+      // make sure it has a new key so it will trigger a data refresh
+      // If this `to` is a valid external URL, return
+      // null for LinkUtils
+      try {
+        new URL("" + to);
+        return {
+          type: 'external',
+          href: to
+        };
+      } catch (e) {}
 
-          return false;
-        }
+      const nextOpts = {
+        from,
+        to,
+        search,
+        params,
+        hash,
+        replace
+      };
+      const next = router.buildNext(nextOpts);
+      preload = (_preload = preload) != null ? _preload : router.options.defaultPreload;
+      const preloadDelay = (_ref10 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref10 : 0; // Compare path/hash for matches
 
-        if (routeSegment.type === 'pathname') {
-          if (routeSegment.value === '/' && !(baseSegment != null && baseSegment.value)) {
-            return true;
-          }
+      const pathIsEqual = router.state.location.pathname === next.pathname;
+      const currentPathSplit = router.state.location.pathname.split('/');
+      const nextPathSplit = next.pathname.split('/');
+      const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
+      const hashIsEqual = router.state.location.hash === next.hash; // Combine the matches based on user options
 
-          if (baseSegment) {
-            if (matchLocation.caseSensitive) {
-              if (routeSegment.value !== baseSegment.value) {
-                return false;
-              }
-            } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
-              return false;
-            }
-          }
-        }
+      const pathTest = activeOptions != null && activeOptions.exact ? pathIsEqual : pathIsFuzzyEqual;
+      const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true; // The final "active" test
 
-        if (!baseSegment) {
-          return false;
-        }
+      const isActive = pathTest && hashTest; // The click handler
 
-        if (routeSegment.type === 'param') {
-          if ((baseSegment == null ? void 0 : baseSegment.value) === '/') {
-            return false;
-          }
+      const handleClick = e => {
+        if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
+          e.preventDefault();
 
-          if (!baseSegment.value.startsWith(':')) {
-            params[routeSegment.value.substring(1)] = baseSegment.value;
-          }
-        }
-      }
+          if (pathIsEqual && !search && !hash) {
+            router.invalidateRoute(nextOpts);
+          } // All is well? Navigate!)
 
-      if (isLastRouteSegment && !isLastBaseSegment) {
-        return !!matchLocation.fuzzy;
-      }
-    }
 
-    return true;
-  })();
+          router.__.navigate(nextOpts);
+        }
+      }; // The click handler
 
-  return isMatch ? params : undefined;
-} // function matchBySearch(
-//   search: SearchSchema,
-//   matchLocation: MatchLocation,
-// ) {
-//   return !!(matchLocation.search && matchLocation.search(search))
-// }
 
-function parsePathname(pathname) {
-  if (!pathname) {
-    return [];
-  }
+      const handleFocus = e => {
+        if (preload) {
+          router.preloadRoute(nextOpts, {
+            maxAge: userPreloadMaxAge,
+            gcMaxAge: userPreloadGcMaxAge
+          });
+        }
+      };
 
-  pathname = cleanPath(pathname);
-  const segments = [];
+      const handleEnter = e => {
+        const target = e.target || {};
 
-  if (pathname.slice(0, 1) === '/') {
-    pathname = pathname.substring(1);
-    segments.push({
-      type: 'pathname',
-      value: '/'
-    });
-  }
+        if (preload) {
+          if (target.preloadTimeout) {
+            return;
+          }
 
-  if (!pathname) {
-    return segments;
-  } // Remove empty segments and '.' segments
+          target.preloadTimeout = setTimeout(() => {
+            target.preloadTimeout = null;
+            router.preloadRoute(nextOpts, {
+              maxAge: userPreloadMaxAge,
+              gcMaxAge: userPreloadGcMaxAge
+            });
+          }, preloadDelay);
+        }
+      };
 
+      const handleLeave = e => {
+        const target = e.target || {};
 
-  const split = pathname.split('/').filter(Boolean);
-  segments.push(...split.map(part => {
-    if (part.startsWith('*')) {
-      return {
-        type: 'wildcard',
-        value: part
+        if (target.preloadTimeout) {
+          clearTimeout(target.preloadTimeout);
+          target.preloadTimeout = null;
+        }
       };
-    }
 
-    if (part.charAt(0) === ':') {
       return {
-        type: 'param',
-        value: part
+        type: 'internal',
+        next,
+        handleFocus,
+        handleClick,
+        handleEnter,
+        handleLeave,
+        isActive,
+        disabled
       };
-    }
-
-    return {
-      type: 'pathname',
-      value: part
-    };
-  }));
-
-  if (pathname.slice(-1) === '/') {
-    pathname = pathname.substring(1);
-    segments.push({
-      type: 'pathname',
-      value: '/'
-    });
-  }
+    },
+    buildNext: opts => {
+      const next = router.__.buildLocation(opts);
 
-  return segments;
-}
+      const matches = router.matchRoutes(next.pathname);
 
-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;
+      const __preSearchFilters = matches.map(match => {
+        var _match$options$preSea;
 
-      // Extra trailing slash? pop it off
-      if (baseSegments.length > 1 && ((_last2 = last(baseSegments)) == null ? void 0 : _last2.value) === '/') {
-        baseSegments.pop();
-      }
+        return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
+      }).flat().filter(Boolean);
 
-      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 __postSearchFilters = matches.map(match => {
+        var _match$options$postSe;
 
-  const array = Array.isArray(prev) && Array.isArray(next);
+        return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
+      }).flat().filter(Boolean);
 
-  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;
+      return router.__.buildLocation(_extends({}, opts, {
+        __preSearchFilters,
+        __postSearchFilters
+      }));
+    },
+    __: {
+      buildRouteTree: rootRouteConfig => {
+        const recurseRoutes = (routeConfigs, parent) => {
+          return routeConfigs.map(routeConfig => {
+            const routeOptions = routeConfig.options;
+            const route = createRoute(routeConfig, routeOptions, parent, router); // {
+            //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
+            //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
+            // }
+
+            const existingRoute = router.routesById[route.routeId];
+
+            if (existingRoute) {
+              if (process.env.NODE_ENV !== 'production') {
+                console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
+              }
 
-    for (let i = 0; i < bSize; i++) {
-      const key = array ? i : bItems[i];
-      copy[key] = replaceEqualDeep(prev[key], next[key]);
+              throw new Error();
+            }
+            router.routesById[route.routeId] = route;
+            const children = routeConfig.children;
+            route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
+            return route;
+          });
+        };
 
-      if (copy[key] === prev[key]) {
-        equalItems++;
-      }
-    }
+        const routes = recurseRoutes([rootRouteConfig]);
+        return routes[0];
+      },
+      parseLocation: (location, previousLocation) => {
+        var _location$hash$split$;
 
-    return aSize === bSize && equalItems === aSize ? prev : copy;
-  }
+        const parsedSearch = router.options.parseSearch(location.search);
+        return {
+          pathname: location.pathname,
+          searchStr: location.search,
+          search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
+          hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
+          href: "" + location.pathname + location.search + location.hash,
+          state: location.state,
+          key: location.key
+        };
+      },
+      navigate: location => {
+        const next = router.buildNext(location);
+        return router.__.commitLocation(next, location.replace);
+      },
+      buildLocation: function buildLocation(dest) {
+        var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
 
-  return next;
-} // Copied from: https://github.com/jonschlinkert/is-plain-object
+        if (dest === void 0) {
+          dest = {};
+        }
 
-function isPlainObject(o) {
-  if (!hasObjectPrototype(o)) {
-    return false;
-  } // If has modified constructor
+        // const resolvedFrom: Location = {
+        //   ...router.location,
+        const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
 
+        let pathname = resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
 
-  const ctor = o.constructor;
+        const fromMatches = router.matchRoutes(router.location.pathname, {
+          strictParseParams: true
+        });
+        const toMatches = router.matchRoutes(pathname);
 
-  if (typeof ctor === 'undefined') {
-    return true;
-  } // If has modified prototype
+        const prevParams = _extends({}, (_last = last(fromMatches)) == null ? void 0 : _last.params);
 
+        let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
 
-  const prot = ctor.prototype;
+        if (nextParams) {
+          toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
+            Object.assign({}, nextParams, fn(nextParams));
+          });
+        }
 
-  if (!hasObjectPrototype(prot)) {
-    return false;
-  } // If constructor does not have an Object-specific method
+        pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
 
+        const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search; // Then the link/navigate function
 
-  if (!prot.hasOwnProperty('isPrototypeOf')) {
-    return false;
-  } // Most likely a plain Object
+        const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
+        : dest.search ? (_functionalUpdate = functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
+        : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom filters
+        : {}; // Then post filters
 
+        const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
+        const search = replaceEqualDeep(router.location.search, postFilteredSearch);
+        const searchStr = router.options.stringifySearch(search);
+        let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
+        hash = hash ? "#" + hash : '';
+        return {
+          pathname,
+          search,
+          searchStr,
+          state: router.location.state,
+          hash,
+          href: "" + pathname + searchStr + hash,
+          key: dest.key
+        };
+      },
+      commitLocation: (next, replace) => {
+        const id = '' + Date.now() + Math.random();
+        if (router.navigateTimeout) clearTimeout(router.navigateTimeout);
+        let nextAction = 'replace';
 
-  return true;
-}
+        if (!replace) {
+          nextAction = 'push';
+        }
 
-function hasObjectPrototype(o) {
-  return Object.prototype.toString.call(o) === '[object Object]';
-}
+        const isSameUrl = router.__.parseLocation(history.location).href === next.href;
 
-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 (isSameUrl && !next.key) {
+          nextAction = 'replace';
+        }
 
-    let query = decode(searchStr); // Try to parse any query params that might be json
+        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
+          });
+        }
 
-    for (let key in query) {
-      const value = query[key];
+        router.navigationPromise = new Promise(resolve => {
+          const previousNavigationResolve = router.resolveNavigation;
 
-      if (typeof value === 'string') {
-        try {
-          query[key] = parser(value);
-        } catch (err) {//
-        }
+          router.resolveNavigation = () => {
+            previousNavigationResolve();
+            resolve();
+          };
+        });
+        return router.navigationPromise;
       }
     }
-
-    return query;
   };
-}
-function stringifySearchWith(stringify) {
-  return search => {
-    search = _extends$1({}, search);
-
-    if (search) {
-      Object.keys(search).forEach(key => {
-        const val = search[key];
-
-        if (typeof val === 'undefined' || val === undefined) {
-          delete search[key];
-        } else if (val && typeof val === 'object' && val !== null) {
-          try {
-            search[key] = stringify(val);
-          } catch (err) {// silent
-          }
-        }
-      });
-    }
+  router.location = router.__.parseLocation(history.location);
+  router.state.location = router.location;
+  router.update(userOptions); // Allow frameworks to hook into the router creation
 
-    const searchStr = encode(search).toString();
-    return searchStr ? "?" + searchStr : '';
-  };
+  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;
@@ -2314,17 +2469,25 @@ exports.createRoute = createRoute;
 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;
 //# sourceMappingURL=index.js.map