@tanstack/react-router 0.0.1-beta.16 → 0.0.1-beta.161

package/build/umd/index.development.js

@@ -1,5 +1,5 @@
 /**
- * react-router
+ * @tanstack/react-router/src/index.tsx
  *
  * Copyright (c) TanStack
  *
@@ -9,10 +9,10 @@
  * @license MIT
  */
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('use-sync-external-store/shim'), require('react-lazy-with-preload/lib/index')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react', 'use-sync-external-store/shim', 'react-lazy-with-preload/lib/index'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactRouter = {}, global.React, global.shim, global.index));
-})(this, (function (exports, React, shim, index) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('use-sync-external-store/shim/with-selector')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'use-sync-external-store/shim/with-selector'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactRouter = {}, global.React, global.withSelector));
+})(this, (function (exports, React, withSelector) { 'use strict';
 
   function _interopNamespace(e) {
     if (e && e.__esModule) return e;
@@ -34,40 +34,23 @@
 
   var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-  function _extends$2() {
-    _extends$2 = Object.assign ? Object.assign.bind() : function (target) {
+  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$2.apply(this, arguments);
-  }
-
-  function _objectWithoutPropertiesLoose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-
-    for (i = 0; i < sourceKeys.length; i++) {
-      key = sourceKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      target[key] = source[key];
-    }
-
-    return target;
+    return _extends.apply(this, arguments);
   }
 
   /**
-   * router-core
+   * @tanstack/store/src/index.ts
    *
    * Copyright (c) TanStack
    *
@@ -76,927 +59,436 @@
    *
    * @license MIT
    */
-  function _extends$1() {
-    _extends$1 = 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];
-          }
-        }
+  class Store {
+    listeners = new Set();
+    _batching = false;
+    _flushing = 0;
+    _nextPriority = null;
+    constructor(initialState, options) {
+      this.state = initialState;
+      this.options = options;
+    }
+    subscribe = listener => {
+      this.listeners.add(listener);
+      const unsub = this.options?.onSubscribe?.(listener, this);
+      return () => {
+        this.listeners.delete(listener);
+        unsub?.();
+      };
+    };
+    setState = (updater, opts) => {
+      const previous = this.state;
+      this.state = this.options?.updateFn ? this.options.updateFn(previous)(updater) : updater(previous);
+      const priority = opts?.priority ?? this.options?.defaultPriority ?? 'high';
+      if (this._nextPriority === null) {
+        this._nextPriority = priority;
+      } else if (this._nextPriority === 'high') {
+        this._nextPriority = priority;
+      } else {
+        this._nextPriority = this.options?.defaultPriority ?? 'high';
       }
 
-      return target;
+      // Always run onUpdate, regardless of batching
+      this.options?.onUpdate?.({
+        priority: this._nextPriority
+      });
+
+      // Attempt to flush
+      this._flush();
+    };
+    _flush = () => {
+      if (this._batching) return;
+      const flushId = ++this._flushing;
+      this.listeners.forEach(listener => {
+        if (this._flushing !== flushId) return;
+        listener({
+          priority: this._nextPriority ?? 'high'
+        });
+      });
+    };
+    batch = cb => {
+      if (this._batching) return cb();
+      this._batching = true;
+      cb();
+      this._batching = false;
+      this._flush();
     };
-    return _extends$1.apply(this, arguments);
   }
 
-  /**
-   * Actions represent the type of change to a location value.
-   *
-   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#action
+  /**
+   * @tanstack/react-store/src/index.tsx
+   *
+   * Copyright (c) TanStack
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE.md file in the root directory of this source tree.
+   *
+   * @license MIT
    */
-  var Action;
-
-  (function (Action) {
-    /**
-     * A POP indicates a change to an arbitrary index in the history stack, such
-     * as a back or forward navigation. It does not describe the direction of the
-     * navigation, only that the current index changed.
-     *
-     * Note: This is the default action for newly created history objects.
-     */
-    Action["Pop"] = "POP";
-    /**
-     * A PUSH indicates a new entry being added to the history stack, such as when
-     * a link is clicked and a new page loads. When this happens, all subsequent
-     * entries in the stack are lost.
-     */
-
-    Action["Push"] = "PUSH";
-    /**
-     * A REPLACE indicates the entry at the current index in the history stack
-     * being replaced by a new one.
-     */
-
-    Action["Replace"] = "REPLACE";
-  })(Action || (Action = {}));
-
-  var readOnly = function (obj) {
-    return Object.freeze(obj);
-  } ;
-
-  function warning$1(cond, message) {
-    if (!cond) {
-      // eslint-disable-next-line no-console
-      if (typeof console !== 'undefined') console.warn(message);
 
-      try {
-        // Welcome to debugging history!
-        //
-        // This error is thrown as a convenience so you can more easily
-        // find the source for a warning that appears in the console by
-        // enabling "pause on exceptions" in your JavaScript debugger.
-        throw new Error(message); // eslint-disable-next-line no-empty
-      } catch (e) {}
-    }
+  function useStore(store, selector = d => d) {
+    const slice = withSelector.useSyncExternalStoreWithSelector(store.subscribe, () => store.state, () => store.state, selector, shallow$1);
+    return slice;
   }
-
-  var BeforeUnloadEventType = 'beforeunload';
-  var HashChangeEventType = 'hashchange';
-  var PopStateEventType = 'popstate';
-  /**
-   * Browser history stores the location in regular URLs. This is the standard for
-   * most web apps, but it requires some configuration on the server to ensure you
-   * serve the same app at multiple URLs.
-   *
-   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
-   */
-
-  function createBrowserHistory(options) {
-    if (options === void 0) {
-      options = {};
-    }
-
-    var _options = options,
-        _options$window = _options.window,
-        window = _options$window === void 0 ? document.defaultView : _options$window;
-    var globalHistory = window.history;
-
-    function getIndexAndLocation() {
-      var _window$location = window.location,
-          pathname = _window$location.pathname,
-          search = _window$location.search,
-          hash = _window$location.hash;
-      var state = globalHistory.state || {};
-      return [state.idx, readOnly({
-        pathname: pathname,
-        search: search,
-        hash: hash,
-        state: state.usr || null,
-        key: state.key || 'default'
-      })];
+  function shallow$1(objA, objB) {
+    if (Object.is(objA, objB)) {
+      return true;
     }
-
-    var blockedPopTx = null;
-
-    function handlePop() {
-      if (blockedPopTx) {
-        blockers.call(blockedPopTx);
-        blockedPopTx = null;
-      } else {
-        var nextAction = Action.Pop;
-
-        var _getIndexAndLocation = getIndexAndLocation(),
-            nextIndex = _getIndexAndLocation[0],
-            nextLocation = _getIndexAndLocation[1];
-
-        if (blockers.length) {
-          if (nextIndex != null) {
-            var delta = index - nextIndex;
-
-            if (delta) {
-              // Revert the POP
-              blockedPopTx = {
-                action: nextAction,
-                location: nextLocation,
-                retry: function retry() {
-                  go(delta * -1);
-                }
-              };
-              go(delta);
-            }
-          } else {
-            // Trying to POP to a location with no index. We did not create
-            // this location, so we can't effectively block the navigation.
-            warning$1(false, // TODO: Write up a doc that explains our blocking strategy in
-            // detail and link to it here so people can understand better what
-            // is going on and how to avoid it.
-            "You are trying to block a POP navigation to a location that was not " + "created by the history library. The block will fail silently in " + "production, but in general you should do all navigation with the " + "history library (instead of using window.history.pushState directly) " + "to avoid this situation.") ;
-          }
-        } else {
-          applyTx(nextAction);
-        }
-      }
+    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+      return false;
     }
-
-    window.addEventListener(PopStateEventType, handlePop);
-    var action = Action.Pop;
-
-    var _getIndexAndLocation2 = getIndexAndLocation(),
-        index = _getIndexAndLocation2[0],
-        location = _getIndexAndLocation2[1];
-
-    var listeners = createEvents();
-    var blockers = createEvents();
-
-    if (index == null) {
-      index = 0;
-      globalHistory.replaceState(_extends$1({}, globalHistory.state, {
-        idx: index
-      }), '');
+    const keysA = Object.keys(objA);
+    if (keysA.length !== Object.keys(objB).length) {
+      return false;
     }
-
-    function createHref(to) {
-      return typeof to === 'string' ? to : createPath(to);
-    } // state defaults to `null` because `window.history.state` does
-
-
-    function getNextLocation(to, state) {
-      if (state === void 0) {
-        state = null;
+    for (let i = 0; i < keysA.length; i++) {
+      if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) {
+        return false;
       }
-
-      return readOnly(_extends$1({
-        pathname: location.pathname,
-        hash: '',
-        search: ''
-      }, typeof to === 'string' ? parsePath(to) : to, {
-        state: state,
-        key: createKey()
-      }));
-    }
-
-    function getHistoryStateAndUrl(nextLocation, index) {
-      return [{
-        usr: nextLocation.state,
-        key: nextLocation.key,
-        idx: index
-      }, createHref(nextLocation)];
-    }
-
-    function allowTx(action, location, retry) {
-      return !blockers.length || (blockers.call({
-        action: action,
-        location: location,
-        retry: retry
-      }), false);
-    }
-
-    function applyTx(nextAction) {
-      action = nextAction;
-
-      var _getIndexAndLocation3 = getIndexAndLocation();
-
-      index = _getIndexAndLocation3[0];
-      location = _getIndexAndLocation3[1];
-      listeners.call({
-        action: action,
-        location: location
-      });
     }
+    return true;
+  }
 
-    function push(to, state) {
-      var nextAction = Action.Push;
-      var nextLocation = getNextLocation(to, state);
-
-      function retry() {
-        push(to, state);
-      }
-
-      if (allowTx(nextAction, nextLocation, retry)) {
-        var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1),
-            historyState = _getHistoryStateAndUr[0],
-            url = _getHistoryStateAndUr[1]; // TODO: Support forced reloading
-        // try...catch because iOS limits us to 100 pushState calls :/
-
-
-        try {
-          globalHistory.pushState(historyState, '', url);
-        } catch (error) {
-          // They are going to lose state here, but there is no real
-          // way to warn them about it since the page will refresh...
-          window.location.assign(url);
-        }
-
-        applyTx(nextAction);
+  var prefix = 'Invariant failed';
+  function invariant(condition, message) {
+      if (condition) {
+          return;
       }
-    }
-
-    function replace(to, state) {
-      var nextAction = Action.Replace;
-      var nextLocation = getNextLocation(to, state);
+      var provided = typeof message === 'function' ? message() : message;
+      var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+      throw new Error(value);
+  }
 
-      function retry() {
-        replace(to, state);
+  function warning(condition, message) {
+    {
+      if (condition) {
+        return;
       }
 
-      if (allowTx(nextAction, nextLocation, retry)) {
-        var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index),
-            historyState = _getHistoryStateAndUr2[0],
-            url = _getHistoryStateAndUr2[1]; // TODO: Support forced reloading
+      var text = "Warning: " + message;
 
-
-        globalHistory.replaceState(historyState, '', url);
-        applyTx(nextAction);
+      if (typeof console !== 'undefined') {
+        console.warn(text);
       }
-    }
 
-    function go(delta) {
-      globalHistory.go(delta);
+      try {
+        throw Error(text);
+      } catch (x) {}
     }
+  }
 
-    var history = {
-      get action() {
-        return action;
-      },
+  /**
+   * @tanstack/router-core/src/index.ts
+   *
+   * Copyright (c) TanStack
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE.md file in the root directory of this source tree.
+   *
+   * @license MIT
+   */
 
+  // While the public API was clearly inspired by the "history" npm package,
+  // This implementation attempts to be more lightweight by
+  // making assumptions about the way TanStack Router works
+
+  const pushStateEvent = 'pushstate';
+  const popStateEvent = 'popstate';
+  const beforeUnloadEvent = 'beforeunload';
+  const beforeUnloadListener = event => {
+    event.preventDefault();
+    // @ts-ignore
+    return event.returnValue = '';
+  };
+  const stopBlocking = () => {
+    removeEventListener(beforeUnloadEvent, beforeUnloadListener, {
+      capture: true
+    });
+  };
+  function createHistory(opts) {
+    let location = opts.getLocation();
+    let unsub = () => {};
+    let listeners = new Set();
+    let blockers = [];
+    let queue = [];
+    const tryFlush = () => {
+      if (blockers.length) {
+        blockers[0]?.(tryFlush, () => {
+          blockers = [];
+          stopBlocking();
+        });
+        return;
+      }
+      while (queue.length) {
+        queue.shift()?.();
+      }
+      if (!opts.listener) {
+        onUpdate();
+      }
+    };
+    const queueTask = task => {
+      queue.push(task);
+      tryFlush();
+    };
+    const onUpdate = () => {
+      location = opts.getLocation();
+      listeners.forEach(listener => listener());
+    };
+    return {
       get location() {
         return location;
       },
-
-      createHref: createHref,
-      push: push,
-      replace: replace,
-      go: go,
-      back: function back() {
-        go(-1);
+      listen: cb => {
+        if (listeners.size === 0) {
+          unsub = typeof opts.listener === 'function' ? opts.listener(onUpdate) : () => {};
+        }
+        listeners.add(cb);
+        return () => {
+          listeners.delete(cb);
+          if (listeners.size === 0) {
+            unsub();
+          }
+        };
+      },
+      push: (path, state) => {
+        queueTask(() => {
+          opts.pushState(path, state);
+        });
       },
-      forward: function forward() {
-        go(1);
+      replace: (path, state) => {
+        queueTask(() => {
+          opts.replaceState(path, state);
+        });
       },
-      listen: function listen(listener) {
-        return listeners.push(listener);
+      go: index => {
+        queueTask(() => {
+          opts.go(index);
+        });
       },
-      block: function block(blocker) {
-        var unblock = blockers.push(blocker);
-
+      back: () => {
+        queueTask(() => {
+          opts.back();
+        });
+      },
+      forward: () => {
+        queueTask(() => {
+          opts.forward();
+        });
+      },
+      createHref: str => opts.createHref(str),
+      block: cb => {
+        blockers.push(cb);
         if (blockers.length === 1) {
-          window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+          addEventListener(beforeUnloadEvent, beforeUnloadListener, {
+            capture: true
+          });
         }
-
-        return function () {
-          unblock(); // Remove the beforeunload listener so the document may
-          // still be salvageable in the pagehide event.
-          // See https://html.spec.whatwg.org/#unloading-documents
-
+        return () => {
+          blockers = blockers.filter(b => b !== cb);
           if (!blockers.length) {
-            window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+            stopBlocking();
           }
         };
       }
     };
-    return history;
-  }
-  /**
-   * Hash history stores the location in window.location.hash. This makes it ideal
-   * for situations where you don't want to send the location to the server for
-   * some reason, either because you do cannot configure it or the URL space is
-   * reserved for something else.
-   *
-   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
-   */
+  }
+  function createBrowserHistory(opts) {
+    const getHref = opts?.getHref ?? (() => `${window.location.pathname}${window.location.search}${window.location.hash}`);
+    const createHref = opts?.createHref ?? (path => path);
+    const getLocation = () => parseLocation(getHref(), history.state);
+    return createHistory({
+      getLocation,
+      listener: onUpdate => {
+        window.addEventListener(pushStateEvent, onUpdate);
+        window.addEventListener(popStateEvent, onUpdate);
+        var pushState = window.history.pushState;
+        window.history.pushState = function () {
+          let res = pushState.apply(history, arguments);
+          onUpdate();
+          return res;
+        };
+        var replaceState = window.history.replaceState;
+        window.history.replaceState = function () {
+          let res = replaceState.apply(history, arguments);
+          onUpdate();
+          return res;
+        };
+        return () => {
+          window.history.pushState = pushState;
+          window.history.replaceState = replaceState;
+          window.removeEventListener(pushStateEvent, onUpdate);
+          window.removeEventListener(popStateEvent, onUpdate);
+        };
+      },
+      pushState: (path, state) => {
+        window.history.pushState({
+          ...state,
+          key: createRandomKey()
+        }, '', createHref(path));
+      },
+      replaceState: (path, state) => {
+        window.history.replaceState({
+          ...state,
+          key: createRandomKey()
+        }, '', createHref(path));
+      },
+      back: () => window.history.back(),
+      forward: () => window.history.forward(),
+      go: n => window.history.go(n),
+      createHref: path => createHref(path)
+    });
+  }
+  function createHashHistory() {
+    return createBrowserHistory({
+      getHref: () => window.location.hash.substring(1),
+      createHref: path => `#${path}`
+    });
+  }
+  function createMemoryHistory(opts = {
+    initialEntries: ['/']
+  }) {
+    const entries = opts.initialEntries;
+    let index = opts.initialIndex ?? entries.length - 1;
+    let currentState = {};
+    const getLocation = () => parseLocation(entries[index], currentState);
+    return createHistory({
+      getLocation,
+      listener: false,
+      pushState: (path, state) => {
+        currentState = {
+          ...state,
+          key: createRandomKey()
+        };
+        entries.push(path);
+        index++;
+      },
+      replaceState: (path, state) => {
+        currentState = {
+          ...state,
+          key: createRandomKey()
+        };
+        entries[index] = path;
+      },
+      back: () => {
+        index--;
+      },
+      forward: () => {
+        index = Math.min(index + 1, entries.length - 1);
+      },
+      go: n => window.history.go(n),
+      createHref: path => path
+    });
+  }
+  function parseLocation(href, state) {
+    let hashIndex = href.indexOf('#');
+    let searchIndex = href.indexOf('?');
+    return {
+      href,
+      pathname: href.substring(0, hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : href.length),
+      hash: hashIndex > -1 ? href.substring(hashIndex) : '',
+      search: searchIndex > -1 ? href.slice(searchIndex, hashIndex === -1 ? undefined : hashIndex) : '',
+      state
+    };
+  }
 
-  function createHashHistory(options) {
-    if (options === void 0) {
-      options = {};
-    }
+  // Thanks co-pilot!
+  function createRandomKey() {
+    return (Math.random() + 1).toString(36).substring(7);
+  }
 
-    var _options2 = options,
-        _options2$window = _options2.window,
-        window = _options2$window === void 0 ? document.defaultView : _options2$window;
-    var globalHistory = window.history;
-
-    function getIndexAndLocation() {
-      var _parsePath = parsePath(window.location.hash.substr(1)),
-          _parsePath$pathname = _parsePath.pathname,
-          pathname = _parsePath$pathname === void 0 ? '/' : _parsePath$pathname,
-          _parsePath$search = _parsePath.search,
-          search = _parsePath$search === void 0 ? '' : _parsePath$search,
-          _parsePath$hash = _parsePath.hash,
-          hash = _parsePath$hash === void 0 ? '' : _parsePath$hash;
-
-      var state = globalHistory.state || {};
-      return [state.idx, readOnly({
-        pathname: pathname,
-        search: search,
-        hash: hash,
-        state: state.usr || null,
-        key: state.key || 'default'
-      })];
+  function last(arr) {
+    return arr[arr.length - 1];
+  }
+  function isFunction(d) {
+    return typeof d === 'function';
+  }
+  function functionalUpdate(updater, previous) {
+    if (isFunction(updater)) {
+      return updater(previous);
     }
+    return updater;
+  }
+  function pick(parent, keys) {
+    return keys.reduce((obj, key) => {
+      obj[key] = parent[key];
+      return obj;
+    }, {});
+  }
 
-    var blockedPopTx = null;
-
-    function handlePop() {
-      if (blockedPopTx) {
-        blockers.call(blockedPopTx);
-        blockedPopTx = null;
-      } else {
-        var nextAction = Action.Pop;
-
-        var _getIndexAndLocation4 = getIndexAndLocation(),
-            nextIndex = _getIndexAndLocation4[0],
-            nextLocation = _getIndexAndLocation4[1];
-
-        if (blockers.length) {
-          if (nextIndex != null) {
-            var delta = index - nextIndex;
-
-            if (delta) {
-              // Revert the POP
-              blockedPopTx = {
-                action: nextAction,
-                location: nextLocation,
-                retry: function retry() {
-                  go(delta * -1);
-                }
-              };
-              go(delta);
-            }
-          } else {
-            // Trying to POP to a location with no index. We did not create
-            // this location, so we can't effectively block the navigation.
-            warning$1(false, // TODO: Write up a doc that explains our blocking strategy in
-            // detail and link to it here so people can understand better
-            // what is going on and how to avoid it.
-            "You are trying to block a POP navigation to a location that was not " + "created by the history library. The block will fail silently in " + "production, but in general you should do all navigation with the " + "history library (instead of using window.history.pushState directly) " + "to avoid this situation.") ;
-          }
-        } else {
-          applyTx(nextAction);
+  /**
+   * 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 immutable JSON values for example.
+   * Do not use this with signals
+   */
+  function replaceEqualDeep(prev, _next) {
+    if (prev === _next) {
+      return prev;
+    }
+    const next = _next;
+    const array = Array.isArray(prev) && Array.isArray(next);
+    if (array || isPlainObject(prev) && isPlainObject(next)) {
+      const prevSize = array ? prev.length : Object.keys(prev).length;
+      const nextItems = array ? next : Object.keys(next);
+      const nextSize = nextItems.length;
+      const copy = array ? [] : {};
+      let equalItems = 0;
+      for (let i = 0; i < nextSize; i++) {
+        const key = array ? i : nextItems[i];
+        copy[key] = replaceEqualDeep(prev[key], next[key]);
+        if (copy[key] === prev[key]) {
+          equalItems++;
         }
       }
+      return prevSize === nextSize && equalItems === prevSize ? prev : copy;
     }
+    return next;
+  }
 
-    window.addEventListener(PopStateEventType, handlePop); // popstate does not fire on hashchange in IE 11 and old (trident) Edge
-    // https://developer.mozilla.org/de/docs/Web/API/Window/popstate_event
-
-    window.addEventListener(HashChangeEventType, function () {
-      var _getIndexAndLocation5 = getIndexAndLocation(),
-          nextLocation = _getIndexAndLocation5[1]; // Ignore extraneous hashchange events.
-
-
-      if (createPath(nextLocation) !== createPath(location)) {
-        handlePop();
-      }
-    });
-    var action = Action.Pop;
-
-    var _getIndexAndLocation6 = getIndexAndLocation(),
-        index = _getIndexAndLocation6[0],
-        location = _getIndexAndLocation6[1];
-
-    var listeners = createEvents();
-    var blockers = createEvents();
-
-    if (index == null) {
-      index = 0;
-      globalHistory.replaceState(_extends$1({}, globalHistory.state, {
-        idx: index
-      }), '');
+  // Copied from: https://github.com/jonschlinkert/is-plain-object
+  function isPlainObject(o) {
+    if (!hasObjectPrototype(o)) {
+      return false;
     }
 
-    function getBaseHref() {
-      var base = document.querySelector('base');
-      var href = '';
-
-      if (base && base.getAttribute('href')) {
-        var url = window.location.href;
-        var hashIndex = url.indexOf('#');
-        href = hashIndex === -1 ? url : url.slice(0, hashIndex);
-      }
-
-      return href;
+    // If has modified constructor
+    const ctor = o.constructor;
+    if (typeof ctor === 'undefined') {
+      return true;
     }
 
-    function createHref(to) {
-      return getBaseHref() + '#' + (typeof to === 'string' ? to : createPath(to));
+    // If has modified prototype
+    const prot = ctor.prototype;
+    if (!hasObjectPrototype(prot)) {
+      return false;
     }
 
-    function getNextLocation(to, state) {
-      if (state === void 0) {
-        state = null;
-      }
-
-      return readOnly(_extends$1({
-        pathname: location.pathname,
-        hash: '',
-        search: ''
-      }, typeof to === 'string' ? parsePath(to) : to, {
-        state: state,
-        key: createKey()
-      }));
+    // If constructor does not have an Object-specific method
+    if (!prot.hasOwnProperty('isPrototypeOf')) {
+      return false;
     }
 
-    function getHistoryStateAndUrl(nextLocation, index) {
-      return [{
-        usr: nextLocation.state,
-        key: nextLocation.key,
-        idx: index
-      }, createHref(nextLocation)];
+    // Most likely a plain Object
+    return true;
+  }
+  function hasObjectPrototype(o) {
+    return Object.prototype.toString.call(o) === '[object Object]';
+  }
+  function partialDeepEqual(a, b) {
+    if (a === b) {
+      return true;
     }
-
-    function allowTx(action, location, retry) {
-      return !blockers.length || (blockers.call({
-        action: action,
-        location: location,
-        retry: retry
-      }), false);
+    if (typeof a !== typeof b) {
+      return false;
     }
-
-    function applyTx(nextAction) {
-      action = nextAction;
-
-      var _getIndexAndLocation7 = getIndexAndLocation();
-
-      index = _getIndexAndLocation7[0];
-      location = _getIndexAndLocation7[1];
-      listeners.call({
-        action: action,
-        location: location
-      });
+    if (isPlainObject(a) && isPlainObject(b)) {
+      return !Object.keys(b).some(key => !partialDeepEqual(a[key], b[key]));
     }
-
-    function push(to, state) {
-      var nextAction = Action.Push;
-      var nextLocation = getNextLocation(to, state);
-
-      function retry() {
-        push(to, state);
-      }
-
-      warning$1(nextLocation.pathname.charAt(0) === '/', "Relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")") ;
-
-      if (allowTx(nextAction, nextLocation, retry)) {
-        var _getHistoryStateAndUr3 = getHistoryStateAndUrl(nextLocation, index + 1),
-            historyState = _getHistoryStateAndUr3[0],
-            url = _getHistoryStateAndUr3[1]; // TODO: Support forced reloading
-        // try...catch because iOS limits us to 100 pushState calls :/
-
-
-        try {
-          globalHistory.pushState(historyState, '', url);
-        } catch (error) {
-          // They are going to lose state here, but there is no real
-          // way to warn them about it since the page will refresh...
-          window.location.assign(url);
-        }
-
-        applyTx(nextAction);
-      }
-    }
-
-    function replace(to, state) {
-      var nextAction = Action.Replace;
-      var nextLocation = getNextLocation(to, state);
-
-      function retry() {
-        replace(to, state);
-      }
-
-      warning$1(nextLocation.pathname.charAt(0) === '/', "Relative pathnames are not supported in hash history.replace(" + JSON.stringify(to) + ")") ;
-
-      if (allowTx(nextAction, nextLocation, retry)) {
-        var _getHistoryStateAndUr4 = getHistoryStateAndUrl(nextLocation, index),
-            historyState = _getHistoryStateAndUr4[0],
-            url = _getHistoryStateAndUr4[1]; // TODO: Support forced reloading
-
-
-        globalHistory.replaceState(historyState, '', url);
-        applyTx(nextAction);
-      }
-    }
-
-    function go(delta) {
-      globalHistory.go(delta);
-    }
-
-    var history = {
-      get action() {
-        return action;
-      },
-
-      get location() {
-        return location;
-      },
-
-      createHref: createHref,
-      push: push,
-      replace: replace,
-      go: go,
-      back: function back() {
-        go(-1);
-      },
-      forward: function forward() {
-        go(1);
-      },
-      listen: function listen(listener) {
-        return listeners.push(listener);
-      },
-      block: function block(blocker) {
-        var unblock = blockers.push(blocker);
-
-        if (blockers.length === 1) {
-          window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
-        }
-
-        return function () {
-          unblock(); // Remove the beforeunload listener so the document may
-          // still be salvageable in the pagehide event.
-          // See https://html.spec.whatwg.org/#unloading-documents
-
-          if (!blockers.length) {
-            window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
-          }
-        };
-      }
-    };
-    return history;
-  }
-  /**
-   * Memory history stores the current location in memory. It is designed for use
-   * in stateful non-browser environments like tests and React Native.
-   *
-   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#creatememoryhistory
-   */
-
-  function createMemoryHistory(options) {
-    if (options === void 0) {
-      options = {};
-    }
-
-    var _options3 = options,
-        _options3$initialEntr = _options3.initialEntries,
-        initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,
-        initialIndex = _options3.initialIndex;
-    var entries = initialEntries.map(function (entry) {
-      var location = readOnly(_extends$1({
-        pathname: '/',
-        search: '',
-        hash: '',
-        state: null,
-        key: createKey()
-      }, typeof entry === 'string' ? parsePath(entry) : entry));
-      warning$1(location.pathname.charAt(0) === '/', "Relative pathnames are not supported in createMemoryHistory({ initialEntries }) (invalid entry: " + JSON.stringify(entry) + ")") ;
-      return location;
-    });
-    var index = clamp(initialIndex == null ? entries.length - 1 : initialIndex, 0, entries.length - 1);
-    var action = Action.Pop;
-    var location = entries[index];
-    var listeners = createEvents();
-    var blockers = createEvents();
-
-    function createHref(to) {
-      return typeof to === 'string' ? to : createPath(to);
-    }
-
-    function getNextLocation(to, state) {
-      if (state === void 0) {
-        state = null;
-      }
-
-      return readOnly(_extends$1({
-        pathname: location.pathname,
-        search: '',
-        hash: ''
-      }, typeof to === 'string' ? parsePath(to) : to, {
-        state: state,
-        key: createKey()
-      }));
-    }
-
-    function allowTx(action, location, retry) {
-      return !blockers.length || (blockers.call({
-        action: action,
-        location: location,
-        retry: retry
-      }), false);
-    }
-
-    function applyTx(nextAction, nextLocation) {
-      action = nextAction;
-      location = nextLocation;
-      listeners.call({
-        action: action,
-        location: location
-      });
-    }
-
-    function push(to, state) {
-      var nextAction = Action.Push;
-      var nextLocation = getNextLocation(to, state);
-
-      function retry() {
-        push(to, state);
-      }
-
-      warning$1(location.pathname.charAt(0) === '/', "Relative pathnames are not supported in memory history.push(" + JSON.stringify(to) + ")") ;
-
-      if (allowTx(nextAction, nextLocation, retry)) {
-        index += 1;
-        entries.splice(index, entries.length, nextLocation);
-        applyTx(nextAction, nextLocation);
-      }
-    }
-
-    function replace(to, state) {
-      var nextAction = Action.Replace;
-      var nextLocation = getNextLocation(to, state);
-
-      function retry() {
-        replace(to, state);
-      }
-
-      warning$1(location.pathname.charAt(0) === '/', "Relative pathnames are not supported in memory history.replace(" + JSON.stringify(to) + ")") ;
-
-      if (allowTx(nextAction, nextLocation, retry)) {
-        entries[index] = nextLocation;
-        applyTx(nextAction, nextLocation);
-      }
-    }
-
-    function go(delta) {
-      var nextIndex = clamp(index + delta, 0, entries.length - 1);
-      var nextAction = Action.Pop;
-      var nextLocation = entries[nextIndex];
-
-      function retry() {
-        go(delta);
-      }
-
-      if (allowTx(nextAction, nextLocation, retry)) {
-        index = nextIndex;
-        applyTx(nextAction, nextLocation);
-      }
-    }
-
-    var history = {
-      get index() {
-        return index;
-      },
-
-      get action() {
-        return action;
-      },
-
-      get location() {
-        return location;
-      },
-
-      createHref: createHref,
-      push: push,
-      replace: replace,
-      go: go,
-      back: function back() {
-        go(-1);
-      },
-      forward: function forward() {
-        go(1);
-      },
-      listen: function listen(listener) {
-        return listeners.push(listener);
-      },
-      block: function block(blocker) {
-        return blockers.push(blocker);
-      }
-    };
-    return history;
-  } ////////////////////////////////////////////////////////////////////////////////
-  // UTILS
-  ////////////////////////////////////////////////////////////////////////////////
-
-  function clamp(n, lowerBound, upperBound) {
-    return Math.min(Math.max(n, lowerBound), upperBound);
-  }
-
-  function promptBeforeUnload(event) {
-    // Cancel the event.
-    event.preventDefault(); // Chrome (and legacy IE) requires returnValue to be set.
-
-    event.returnValue = '';
-  }
-
-  function createEvents() {
-    var handlers = [];
-    return {
-      get length() {
-        return handlers.length;
-      },
-
-      push: function push(fn) {
-        handlers.push(fn);
-        return function () {
-          handlers = handlers.filter(function (handler) {
-            return handler !== fn;
-          });
-        };
-      },
-      call: function call(arg) {
-        handlers.forEach(function (fn) {
-          return fn && fn(arg);
-        });
-      }
-    };
-  }
-
-  function createKey() {
-    return Math.random().toString(36).substr(2, 8);
-  }
-  /**
-   * Creates a string URL path from the given pathname, search, and hash components.
-   *
-   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createpath
-   */
-
-
-  function createPath(_ref) {
-    var _ref$pathname = _ref.pathname,
-        pathname = _ref$pathname === void 0 ? '/' : _ref$pathname,
-        _ref$search = _ref.search,
-        search = _ref$search === void 0 ? '' : _ref$search,
-        _ref$hash = _ref.hash,
-        hash = _ref$hash === void 0 ? '' : _ref$hash;
-    if (search && search !== '?') pathname += search.charAt(0) === '?' ? search : '?' + search;
-    if (hash && hash !== '#') pathname += hash.charAt(0) === '#' ? hash : '#' + hash;
-    return pathname;
-  }
-  /**
-   * Parses a string URL path into its separate pathname, search, and hash components.
-   *
-   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#parsepath
-   */
-
-  function parsePath(path) {
-    var parsedPath = {};
-
-    if (path) {
-      var hashIndex = path.indexOf('#');
-
-      if (hashIndex >= 0) {
-        parsedPath.hash = path.substr(hashIndex);
-        path = path.substr(0, hashIndex);
-      }
-
-      var searchIndex = path.indexOf('?');
-
-      if (searchIndex >= 0) {
-        parsedPath.search = path.substr(searchIndex);
-        path = path.substr(0, searchIndex);
-      }
-
-      if (path) {
-        parsedPath.pathname = path;
-      }
-    }
-
-    return parsedPath;
-  }
-  var prefix = 'Invariant failed';
-  function invariant(condition, message) {
-      if (condition) {
-          return;
-      }
-      var provided = typeof message === 'function' ? message() : message;
-      var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
-      throw new Error(value);
-  }
-
-  // type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-  //   k: infer I,
-  // ) => any
-  //   ? I
-  //   : never
-
-  /**
-   * This function returns `a` if `b` is deeply equal.
-   * If not, it will replace any deeply equal children of `b` with those of `a`.
-   * This can be used for structural sharing between JSON values for example.
-   */
-  function replaceEqualDeep(prev, next) {
-    if (prev === next) {
-      return prev;
-    }
-
-    const array = Array.isArray(prev) && Array.isArray(next);
-
-    if (array || isPlainObject(prev) && isPlainObject(next)) {
-      const aSize = array ? prev.length : Object.keys(prev).length;
-      const bItems = array ? next : Object.keys(next);
-      const bSize = bItems.length;
-      const copy = array ? [] : {};
-      let equalItems = 0;
-
-      for (let i = 0; i < bSize; i++) {
-        const key = array ? i : bItems[i];
-        copy[key] = replaceEqualDeep(prev[key], next[key]);
-
-        if (copy[key] === prev[key]) {
-          equalItems++;
-        }
-      }
-
-      return aSize === bSize && equalItems === aSize ? prev : copy;
-    }
-
-    return next;
-  } // Copied from: https://github.com/jonschlinkert/is-plain-object
-
-  function isPlainObject(o) {
-    if (!hasObjectPrototype(o)) {
-      return false;
-    } // If has modified constructor
-
-
-    const ctor = o.constructor;
-
-    if (typeof ctor === 'undefined') {
-      return true;
-    } // If has modified prototype
-
-
-    const prot = ctor.prototype;
-
-    if (!hasObjectPrototype(prot)) {
-      return false;
-    } // If constructor does not have an Object-specific method
-
-
-    if (!prot.hasOwnProperty('isPrototypeOf')) {
-      return false;
-    } // Most likely a plain Object
-
-
-    return true;
-  }
-
-  function hasObjectPrototype(o) {
-    return Object.prototype.toString.call(o) === '[object Object]';
-  }
-
-  function last(arr) {
-    return arr[arr.length - 1];
-  }
-  function warning(cond, message) {
-    if (cond) {
-      if (typeof console !== 'undefined') console.warn(message);
-
-      try {
-        throw new Error(message);
-      } catch (_unused) {}
-    }
-
-    return true;
-  }
-
-  function isFunction(d) {
-    return typeof d === 'function';
-  }
-
-  function functionalUpdate(updater, previous) {
-    if (isFunction(updater)) {
-      return updater(previous);
-    }
-
-    return updater;
-  }
-  function pick(parent, keys) {
-    return keys.reduce((obj, key) => {
-      obj[key] = parent[key];
-      return obj;
-    }, {});
-  }
+    if (Array.isArray(a) && Array.isArray(b)) {
+      return a.length === b.length && a.every((item, index) => partialDeepEqual(item, b[index]));
+    }
+    return false;
+  }
 
   function joinPaths(paths) {
     return cleanPath(paths.filter(Boolean).join('/'));
@@ -1015,8 +507,8 @@
     return trimPathRight(trimPathLeft(path));
   }
   function resolvePath(basepath, base, to) {
-    base = base.replace(new RegExp("^" + basepath), '/');
-    to = to.replace(new RegExp("^" + basepath), '/');
+    base = base.replace(new RegExp(`^${basepath}`), '/');
+    to = to.replace(new RegExp(`^${basepath}`), '/');
     let baseSegments = parsePathname(base);
     const toSegments = parsePathname(to);
     toSegments.forEach((toSegment, index) => {
@@ -1029,13 +521,10 @@
           baseSegments.push(toSegment);
         } else ;
       } else if (toSegment.value === '..') {
-        var _last;
-
         // Extra trailing slash? pop it off
-        if (baseSegments.length > 1 && ((_last = last(baseSegments)) == null ? void 0 : _last.value) === '/') {
+        if (baseSegments.length > 1 && last(baseSegments)?.value === '/') {
           baseSegments.pop();
         }
-
         baseSegments.pop();
       } else if (toSegment.value === '.') {
         return;
@@ -1050,10 +539,8 @@
     if (!pathname) {
       return [];
     }
-
     pathname = cleanPath(pathname);
     const segments = [];
-
     if (pathname.slice(0, 1) === '/') {
       pathname = pathname.substring(1);
       segments.push({
@@ -1061,34 +548,30 @@
         value: '/'
       });
     }
-
     if (!pathname) {
       return segments;
-    } // Remove empty segments and '.' segments
-
+    }
 
+    // Remove empty segments and '.' segments
     const split = pathname.split('/').filter(Boolean);
     segments.push(...split.map(part => {
-      if (part.startsWith('*')) {
+      if (part === '$' || part === '*') {
         return {
           type: 'wildcard',
           value: part
         };
       }
-
-      if (part.charAt(0) === ':') {
+      if (part.charAt(0) === '$') {
         return {
           type: 'param',
           value: part
         };
       }
-
       return {
         type: 'pathname',
         value: part
       };
     }));
-
     if (pathname.slice(-1) === '/') {
       pathname = pathname.substring(1);
       segments.push({
@@ -1096,66 +579,70 @@
         value: '/'
       });
     }
-
     return segments;
   }
-  function interpolatePath(path, params, leaveWildcard) {
+  function interpolatePath(path, params, leaveWildcards = false) {
     const interpolatedPathSegments = parsePathname(path);
     return joinPaths(interpolatedPathSegments.map(segment => {
-      if (segment.value === '*' && !leaveWildcard) {
-        return '';
+      if (segment.type === 'wildcard') {
+        const value = params[segment.value];
+        if (leaveWildcards) return `${segment.value}${value ?? ''}`;
+        return value;
       }
-
       if (segment.type === 'param') {
-        var _segment$value$substr;
-
-        return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
+        return params[segment.value.substring(1)] ?? '';
       }
-
       return segment.value;
     }));
   }
-  function matchPathname(currentPathname, matchLocation) {
-    const pathParams = matchByPath(currentPathname, matchLocation); // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
+  function matchPathname(basepath, currentPathname, matchLocation) {
+    const pathParams = matchByPath(basepath, currentPathname, matchLocation);
+    // const searchMatched = matchBySearch(location.search, matchLocation)
 
     if (matchLocation.to && !pathParams) {
       return;
-    } // if (matchLocation.search && !searchMatched) {
-    //   return
-    // }
-
-
-    return pathParams != null ? pathParams : {};
+    }
+    return pathParams ?? {};
   }
-  function matchByPath(from, matchLocation) {
-    var _matchLocation$to;
-
+  function matchByPath(basepath, from, matchLocation) {
+    // Remove the base path from the pathname
+    from = basepath != '/' ? from.substring(basepath.length) : from;
+    // Default to to $ (wildcard)
+    const to = `${matchLocation.to ?? '$'}`;
+    // Parse the from and to
     const baseSegments = parsePathname(from);
-    const routeSegments = parsePathname("" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*'));
+    const routeSegments = parsePathname(to);
+    if (!from.startsWith('/')) {
+      baseSegments.unshift({
+        type: 'pathname',
+        value: '/'
+      });
+    }
+    if (!to.startsWith('/')) {
+      routeSegments.unshift({
+        type: 'pathname',
+        value: '/'
+      });
+    }
     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;
-
+        const isLastBaseSegment = i >= baseSegments.length - 1;
+        const isLastRouteSegment = i >= routeSegments.length - 1;
         if (routeSegment) {
           if (routeSegment.type === 'wildcard') {
-            if (baseSegment != null && baseSegment.value) {
+            if (baseSegment?.value) {
               params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
               return true;
             }
-
             return false;
           }
-
           if (routeSegment.type === 'pathname') {
-            if (routeSegment.value === '/' && !(baseSegment != null && baseSegment.value)) {
+            if (routeSegment.value === '/' && !baseSegment?.value) {
               return true;
             }
-
             if (baseSegment) {
               if (matchLocation.caseSensitive) {
                 if (routeSegment.value !== baseSegment.value) {
@@ -1166,41 +653,36 @@
               }
             }
           }
-
           if (!baseSegment) {
             return false;
           }
-
           if (routeSegment.type === 'param') {
-            if ((baseSegment == null ? void 0 : baseSegment.value) === '/') {
+            if (baseSegment?.value === '/') {
               return false;
             }
-
-            if (!baseSegment.value.startsWith(':')) {
+            if (baseSegment.value.charAt(0) !== '$') {
               params[routeSegment.value.substring(1)] = baseSegment.value;
             }
           }
         }
-
-        if (isLastRouteSegment && !isLastBaseSegment) {
+        if (!isLastBaseSegment && isLastRouteSegment) {
           return !!matchLocation.fuzzy;
         }
       }
-
       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 = '';
-
+      i,
+      tmp,
+      str = '';
     for (k in obj) {
       if ((tmp = obj[k]) !== void 0) {
         if (Array.isArray(tmp)) {
@@ -1214,1650 +696,1867 @@
         }
       }
     }
-
     return (pfx || '') + str;
   }
-
   function toValue(mix) {
     if (!mix) return '';
     var str = decodeURIComponent(mix);
     if (str === 'false') return false;
     if (str === 'true') return true;
-    if (str.charAt(0) === '0') return str;
-    return +str * 0 === 0 ? +str : str;
+    return +str * 0 === 0 && +str + '' === str ? +str : str;
   }
-
   function decode(str) {
     var tmp,
-        k,
-        out = {},
-        arr = str.split('&');
-
+      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] = {
-        submissions: [],
-        submit: async (submission, actionOpts) => {
-          var _actionOpts$invalidat;
-
-          if (!route) {
-            return;
-          }
-
-          const invalidate = (_actionOpts$invalidat = actionOpts == null ? void 0 : actionOpts.invalidate) != null ? _actionOpts$invalidat : true;
-
-          if (!(actionOpts != null && actionOpts.multi)) {
-            action.submissions = action.submissions.filter(d => d.isMulti);
-          }
-
-          const actionState = {
-            submittedAt: Date.now(),
-            status: 'pending',
-            submission,
-            isMulti: !!(actionOpts != null && actionOpts.multi)
-          };
-          action.current = actionState;
-          action.latest = actionState;
-          action.submissions.push(actionState);
-          router.notify();
-
-          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();
-            }
+  const rootRouteId = '__root__';
 
-            actionState.status = 'success';
-            return res;
-          } catch (err) {
-            console.error(err);
-            actionState.error = err;
-            actionState.status = 'error';
-          } finally {
-            router.notify();
-          }
-        }
-      };
-      return router.state.actions[id];
-    })();
+  // The parse type here allows a zod schema to be passed directly to the validator
 
-    const loader = router.state.loaders[id] || (() => {
-      router.state.loaders[id] = {
-        pending: [],
-        fetch: async loaderContext => {
-          if (!route) {
-            return;
-          }
+  class Route {
+    // Set up in this.init()
 
-          const loaderState = {
-            loadedAt: Date.now(),
-            loaderContext
-          };
-          loader.current = loaderState;
-          loader.latest = loaderState;
-          loader.pending.push(loaderState); // router.state = {
-          //   ...router.state,
-          //   currentAction: loaderState,
-          //   latestAction: loaderState,
-          // }
+    // customId!: TCustomId
 
-          router.notify();
+    // Optional
 
-          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 })
+    constructor(options) {
+      this.options = options || {};
+      this.isRoot = !options?.getParentRoute;
+      Route.__onInit(this);
+    }
+    init = opts => {
+      this.originalIndex = opts.originalIndex;
+      this.router = opts.router;
+      const options = this.options;
+      const isRoot = !options?.path && !options?.id;
+      this.parentRoute = this.options?.getParentRoute?.();
+      if (isRoot) {
+        this.path = rootRouteId;
+      } else {
+        invariant(this.parentRoute, `Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a Route instance.`);
+      }
+      let path = isRoot ? rootRouteId : options.path;
 
-            router.notify();
-          }
-        }
-      };
-      return router.state.loaders[id];
-    })();
+      // If the path is anything other than an index path, trim it up
+      if (path && path !== '/') {
+        path = trimPath(path);
+      }
+      const customId = options?.id || path;
 
-    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
-        }));
-      },
-      matchRoute: (matchLocation, opts) => {
-        return router.matchRoute(_extends({}, matchLocation, {
-          from: fullPath
-        }), opts);
+      // Strip the parentId prefix from the first level of children
+      let id = isRoot ? rootRouteId : joinPaths([this.parentRoute.id === rootRouteId ? '' : this.parentRoute.id, customId]);
+      if (path === rootRouteId) {
+        path = '/';
+      }
+      if (id !== rootRouteId) {
+        id = joinPaths(['/', id]);
       }
+      const fullPath = id === rootRouteId ? '/' : joinPaths([this.parentRoute.fullPath, path]);
+      this.path = path;
+      this.id = id;
+      // this.customId = customId as TCustomId
+      this.fullPath = fullPath;
+      this.to = fullPath;
+    };
+    addChildren = children => {
+      this.children = children;
+      return this;
+    };
+    update = options => {
+      Object.assign(this.options, options);
+      return this;
+    };
+    static __onInit = route => {
+      // This is a dummy static method that should get
+      // replaced by a framework specific implementation if necessary
     };
-    router.options.createRoute == null ? void 0 : router.options.createRoute({
-      router,
-      route
-    });
-    return route;
   }
-
-  const rootRouteId = '__root__';
-  const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId, parentPath) {
-    if (options === void 0) {
-      options = {};
-    }
-
-    if (isRoot === void 0) {
-      isRoot = true;
-    }
-
-    if (isRoot) {
-      options.path = rootRouteId;
-    } // Strip the root from parentIds
-
-
-    if (parentId === rootRouteId) {
-      parentId = '';
-    }
-
-    let path = isRoot ? rootRouteId : options.path; // If the path is anything other than an index path, trim it up
-
-    if (path && path !== '/') {
-      path = trimPath(path);
-    }
-
-    const routeId = path || options.id;
-    let id = joinPaths([parentId, routeId]);
-
-    if (path === rootRouteId) {
-      path = '/';
+  class RouterContext {
+    constructor() {}
+    createRootRoute = options => {
+      return new RootRoute(options);
+    };
+  }
+  class RootRoute extends Route {
+    constructor(options) {
+      super(options);
     }
+  }
 
-    if (id !== rootRouteId) {
-      id = joinPaths(['/', id]);
+  class FileRoute {
+    constructor(path) {
+      this.path = path;
     }
-
-    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)
+    createRoute = options => {
+      const route = new Route(options);
+      route.isRoot = false;
+      return route;
     };
-  };
-
-  const componentTypes = ['component', 'errorComponent', 'pendingComponent'];
-  function createRouteMatch(router, route, opts) {
-    const routeMatch = _extends({}, route, opts, {
-      router,
-      routeSearch: {},
-      search: {},
-      childMatches: [],
-      status: 'idle',
-      routeLoaderData: {},
-      loaderData: {},
-      isFetching: false,
-      isInvalid: false,
-      invalidAt: Infinity,
-      // pendingActions: [],
-      getIsInvalid: () => {
-        const now = Date.now();
-        return routeMatch.isInvalid || routeMatch.invalidAt < now;
-      },
-      __: {
-        abortController: new AbortController(),
-        latestId: '',
-        resolve: () => {},
-        notify: () => {
-          routeMatch.__.resolve();
-
-          routeMatch.router.notify();
-        },
-        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;
-
-          try {
-            var _validator;
-
-            const prevSearch = routeMatch.routeSearch;
-            const validator = typeof routeMatch.options.validateSearch === 'object' ? routeMatch.options.validateSearch.parse : routeMatch.options.validateSearch;
-            let nextSearch = replaceEqualDeep(prevSearch, (_validator = validator == null ? void 0 : validator(parentSearch)) != null ? _validator : {}); // Invalidate route matches when search param stability changes
-
-            if (prevSearch !== nextSearch) {
-              routeMatch.isInvalid = true;
-            }
-
-            routeMatch.routeSearch = nextSearch;
-            routeMatch.search = replaceEqualDeep(parentSearch, _extends({}, parentSearch, nextSearch));
-            componentTypes.map(async type => {
-              const component = routeMatch.options[type];
-
-              if (typeof routeMatch.__[type] !== 'function') {
-                routeMatch.__[type] = component;
-              }
-            });
-          } 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;
-
-        (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
-      },
-      invalidate: () => {
-        routeMatch.isInvalid = true;
-      },
-      hasLoaders: () => {
-        return !!(route.options.loader || componentTypes.some(d => {
-          var _route$options$d;
-
-          return (_route$options$d = route.options[d]) == null ? void 0 : _route$options$d.preload;
-        }));
-      },
-      load: async loaderOpts => {
-        const now = Date.now();
-        const minMaxAge = loaderOpts != null && loaderOpts.preload ? Math.max(loaderOpts == null ? void 0 : loaderOpts.maxAge, loaderOpts == null ? void 0 : loaderOpts.gcMaxAge) : 0; // If this is a preload, add it to the preload cache
-
-        if (loaderOpts != null && loaderOpts.preload && minMaxAge > 0) {
-          // If the match is currently active, don't preload it
-          if (router.state.matches.find(d => d.matchId === routeMatch.matchId)) {
-            return;
-          }
-
-          router.matchCache[routeMatch.matchId] = {
-            gc: now + loaderOpts.gcMaxAge,
-            match: routeMatch
-          };
-        } // If the match is invalid, errored or idle, trigger it to load
-
-
-        if (routeMatch.status === 'success' && routeMatch.getIsInvalid() || routeMatch.status === 'error' || routeMatch.status === 'idle') {
-          const maxAge = loaderOpts != null && loaderOpts.preload ? loaderOpts == null ? void 0 : loaderOpts.maxAge : undefined;
-          await routeMatch.fetch({
-            maxAge
-          });
-        }
-      },
-      fetch: async opts => {
-        const id = '' + Date.now() + Math.random();
-        routeMatch.__.latestId = id; // If the match was in an error state, set it
-        // to a loading state again. Otherwise, keep it
-        // as loading or resolved
-
-        if (routeMatch.status === 'idle') {
-          routeMatch.status = 'loading';
-        } // We started loading the route, so it's no longer invalid
-
-
-        routeMatch.isInvalid = false;
-        routeMatch.__.loadPromise = new Promise(async resolve => {
-          // We are now fetching, even if it's in the background of a
-          // resolved state
-          routeMatch.isFetching = true;
-          routeMatch.__.resolve = resolve;
-
-          routeMatch.__.componentsPromise = (async () => {
-            // then run all component and data loaders in parallel
-            // For each component type, potentially load it asynchronously
-            await Promise.all(componentTypes.map(async type => {
-              var _routeMatch$__$type;
-
-              const component = routeMatch.options[type];
-
-              if ((_routeMatch$__$type = routeMatch.__[type]) != null && _routeMatch$__$type.preload) {
-                routeMatch.__[type] = await router.options.loadComponent(component);
-              }
-            }));
-          })();
-
-          routeMatch.__.dataPromise = Promise.resolve().then(async () => {
-            try {
-              var _ref, _ref2, _opts$maxAge;
-
-              if (routeMatch.options.loader) {
-                var _routeMatch$parentMat3;
-
-                const data = await routeMatch.options.loader({
-                  parentLoaderPromise: (_routeMatch$parentMat3 = routeMatch.parentMatch) == null ? void 0 : _routeMatch$parentMat3.__.dataPromise,
-                  params: routeMatch.params,
-                  search: routeMatch.routeSearch,
-                  signal: routeMatch.__.abortController.signal
-                });
-
-                if (id !== routeMatch.__.latestId) {
-                  return routeMatch.__.loadPromise;
-                }
-
-                routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
-              }
-
-              routeMatch.error = undefined;
-              routeMatch.status = 'success';
-              routeMatch.updatedAt = Date.now();
-              routeMatch.invalidAt = routeMatch.updatedAt + ((_ref = (_ref2 = (_opts$maxAge = opts == null ? void 0 : opts.maxAge) != null ? _opts$maxAge : routeMatch.options.loaderMaxAge) != null ? _ref2 : router.options.defaultLoaderMaxAge) != null ? _ref : 0);
-              return routeMatch.routeLoaderData;
-            } catch (err) {
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loadPromise;
-              }
-
-              {
-                console.error(err);
-              }
-
-              routeMatch.error = err;
-              routeMatch.status = 'error';
-              routeMatch.updatedAt = Date.now();
-              throw err;
-            }
-          });
-
-          try {
-            await Promise.all([routeMatch.__.componentsPromise, routeMatch.__.dataPromise.catch(() => {})]);
-
-            if (id !== routeMatch.__.latestId) {
-              return routeMatch.__.loadPromise;
-            }
-          } finally {
-            if (id !== routeMatch.__.latestId) {
-              return routeMatch.__.loadPromise;
-            }
-
-            routeMatch.isFetching = false;
-
-            routeMatch.__.notify();
-          }
-        });
-        await routeMatch.__.loadPromise;
-
-        if (id !== routeMatch.__.latestId) {
-          return routeMatch.__.loadPromise;
-        }
-
-        delete routeMatch.__.loadPromise;
-      }
-    });
-
-    if (!routeMatch.hasLoaders()) {
-      routeMatch.status = 'success';
-    }
-
-    return routeMatch;
   }
 
   const defaultParseSearch = parseSearchWith(JSON.parse);
-  const defaultStringifySearch = stringifySearchWith(JSON.stringify);
+  const defaultStringifySearch = stringifySearchWith(JSON.stringify, JSON.parse);
   function parseSearchWith(parser) {
     return searchStr => {
       if (searchStr.substring(0, 1) === '?') {
         searchStr = searchStr.substring(1);
       }
+      let query = decode(searchStr);
 
-      let query = decode(searchStr); // Try to parse any query params that might be json
-
+      // Try to parse any query params that might be json
       for (let key in query) {
         const value = query[key];
-
         if (typeof value === 'string') {
           try {
             query[key] = parser(value);
-          } catch (err) {//
+          } catch (err) {
+            //
           }
         }
       }
-
       return query;
     };
   }
-  function stringifySearchWith(stringify) {
+  function stringifySearchWith(stringify, parser) {
+    function stringifyValue(val) {
+      if (typeof val === 'object' && val !== null) {
+        try {
+          return stringify(val);
+        } catch (err) {
+          // silent
+        }
+      } else if (typeof val === 'string' && typeof parser === 'function') {
+        try {
+          // Check if it's a valid parseable string.
+          // If it is, then stringify it again.
+          parser(val);
+          return stringify(val);
+        } catch (err) {
+          // silent
+        }
+      }
+      return val;
+    }
     return search => {
-      search = _extends({}, search);
-
+      search = {
+        ...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
-            }
+          } else if (Array.isArray(val)) {
+            search[key] = val.map(stringifyValue);
+          } else {
+            search[key] = stringifyValue(val);
           }
         });
       }
-
       const searchStr = encode(search).toString();
-      return searchStr ? "?" + searchStr : '';
+      return searchStr ? `?${searchStr}` : '';
     };
   }
 
-  var _window$document;
-  // Detect if we're in the DOM
-  const isServer = typeof window === 'undefined' || !((_window$document = window.document) != null && _window$document.createElement); // This is the default history object if none is defined
-
-  const createDefaultHistory = () => isServer ? createMemoryHistory() : createBrowserHistory();
-
-  function getInitialRouterState() {
-    return {
-      status: 'idle',
-      location: null,
-      matches: [],
-      actions: {},
-      loaders: {},
-      lastUpdated: Date.now(),
-      isFetching: false,
-      isPreloading: false
-    };
-  }
-
-  function createRouter(userOptions) {
-    var _userOptions$stringif, _userOptions$parseSea;
-
-    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: [],
-      // Resolved after construction
-      basepath: '',
-      routeTree: undefined,
-      routesById: {},
-      location: undefined,
-      allRouteInfo: undefined,
-      //
-      navigationPromise: Promise.resolve(),
-      resolveNavigation: () => {},
-      matchCache: {},
-      state: getInitialRouterState(),
-      reset: () => {
-        router.state = getInitialRouterState();
-        router.notify();
-      },
-      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: () => {
-        const isFetching = router.state.status === 'loading' || router.state.matches.some(d => d.isFetching);
-        const isPreloading = Object.values(router.matchCache).some(d => d.match.isFetching && !router.state.matches.find(dd => dd.matchId === d.match.matchId));
-
-        if (router.state.isFetching !== isFetching || router.state.isPreloading !== isPreloading) {
-          router.state = _extends({}, router.state, {
-            isFetching,
-            isPreloading
-          });
-        }
+  const componentTypes = ['component', 'errorComponent', 'pendingComponent'];
+  class Router {
+    #unsubHistory;
+    constructor(options) {
+      this.options = {
+        defaultPreloadDelay: 50,
+        context: undefined,
+        ...options,
+        stringifySearch: options?.stringifySearch ?? defaultStringifySearch,
+        parseSearch: options?.parseSearch ?? defaultParseSearch
+        // fetchServerDataFn: options?.fetchServerDataFn ?? defaultFetchServerDataFn,
+      };
 
-        cascadeLoaderData(router.state.matches);
-        router.listeners.forEach(listener => listener(router));
-      },
-      dehydrateState: () => {
-        return _extends({}, pick(router.state, ['status', 'location', 'lastUpdated']), {
-          matches: router.state.matches.map(match => pick(match, ['matchId', 'status', 'routeLoaderData', 'loaderData', 'isInvalid', 'invalidAt']))
-        });
-      },
-      hydrateState: dehydratedState => {
-        // Match the routes
-        const matches = router.matchRoutes(router.location.pathname, {
-          strictParseParams: true
-        });
-        matches.forEach((match, index) => {
-          const dehydratedMatch = dehydratedState.matches[index];
-          invariant(dehydratedMatch, 'Oh no! Dehydrated route matches did not match the active state of the router 😬');
-          Object.assign(match, dehydratedMatch);
-        });
-        matches.forEach(match => match.__.validate());
-        router.state = _extends({}, router.state, dehydratedState, {
-          matches
+      this.__store = new Store(getInitialRouterState(), {
+        onUpdate: () => {
+          const prev = this.state;
+          const next = this.__store.state;
+          const matchesByIdChanged = prev.matchesById !== next.matchesById;
+          let matchesChanged;
+          let pendingMatchesChanged;
+          if (!matchesByIdChanged) {
+            matchesChanged = prev.matchIds.length !== next.matchIds.length || prev.matchIds.some((d, i) => d !== next.matchIds[i]);
+            pendingMatchesChanged = prev.pendingMatchIds.length !== next.pendingMatchIds.length || prev.pendingMatchIds.some((d, i) => d !== next.pendingMatchIds[i]);
+          }
+          if (matchesByIdChanged || matchesChanged) {
+            next.matches = next.matchIds.map(id => {
+              return next.matchesById[id];
+            });
+          }
+          if (matchesByIdChanged || pendingMatchesChanged) {
+            next.pendingMatches = next.pendingMatchIds.map(id => {
+              return next.matchesById[id];
+            });
+          }
+          next.isFetching = [...next.matches, ...next.pendingMatches].some(d => d.isFetching);
+          this.state = next;
+        },
+        defaultPriority: 'low'
+      });
+      this.state = this.__store.state;
+      this.update(options);
+      const next = this.buildNext({
+        hash: true,
+        fromCurrent: true,
+        search: true,
+        state: true
+      });
+      if (this.state.location.href !== next.href) {
+        this.#commitLocation({
+          ...next,
+          replace: true
         });
-      },
-      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) {
-          router.__.commitLocation(next, true);
-        }
+      }
+    }
+    reset = () => {
+      this.__store.setState(s => Object.assign(s, getInitialRouterState()));
+    };
+    mount = () => {
+      // If the router matches are empty, start loading the matches
+      // if (!this.state.matches.length) {
+      this.safeLoad();
+      // }
+    };
 
-        if (!router.state.matches.length) {
-          router.load();
+    update = opts => {
+      this.options = {
+        ...this.options,
+        ...opts,
+        context: {
+          ...this.options.context,
+          ...opts?.context
         }
-
-        const unsub = router.history.listen(event => {
-          router.load(router.__.parseLocation(event.location, router.location));
-        }); // addEventListener does not exist in React Native, but window does
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-
-        if (!isServer && window.addEventListener) {
-          // Listen to visibillitychange and focus
-          window.addEventListener('visibilitychange', router.onFocus, false);
-          window.addEventListener('focus', router.onFocus, false);
+      };
+      if (!this.history || this.options.history && this.options.history !== this.history) {
+        if (this.#unsubHistory) {
+          this.#unsubHistory();
         }
+        this.history = this.options.history ?? (isServer ? createMemoryHistory() : createBrowserHistory());
+        const parsedLocation = this.#parseLocation();
+        this.__store.setState(s => ({
+          ...s,
+          resolvedLocation: parsedLocation,
+          location: parsedLocation
+        }));
+        this.#unsubHistory = this.history.listen(() => {
+          this.safeLoad({
+            next: this.#parseLocation(this.state.location)
+          });
+        });
+      }
+      const {
+        basepath,
+        routeTree
+      } = this.options;
+      this.basepath = `/${trimPath(basepath ?? '') ?? ''}`;
+      if (routeTree && routeTree !== this.routeTree) {
+        this.#buildRouteTree(routeTree);
+      }
+      return this;
+    };
+    buildNext = opts => {
+      const next = this.#buildLocation(opts);
+      const __matches = this.matchRoutes(next.pathname, next.search);
+      return this.#buildLocation({
+        ...opts,
+        __matches
+      });
+    };
+    cancelMatches = () => {
+      this.state.matches.forEach(match => {
+        this.cancelMatch(match.id);
+      });
+    };
+    cancelMatch = id => {
+      this.getRouteMatch(id)?.abortController?.abort();
+    };
+    safeLoad = async opts => {
+      try {
+        return this.load(opts);
+      } catch (err) {
+        // Don't do anything
+      }
+    };
+    latestLoadPromise = Promise.resolve();
+    load = async opts => {
+      const promise = new Promise(async (resolve, reject) => {
+        let latestPromise;
+        const checkLatest = () => {
+          return this.latestLoadPromise !== promise ? this.latestLoadPromise : undefined;
+        };
 
-        return () => {
-          unsub();
+        // Cancel any pending matches
+        // this.cancelMatches()
 
-          if (!isServer && window.removeEventListener) {
-            // Be sure to unsubscribe if a new handler is set
-            window.removeEventListener('visibilitychange', router.onFocus);
-            window.removeEventListener('focus', router.onFocus);
+        let pendingMatches;
+        this.__store.batch(() => {
+          if (opts?.next) {
+            // Ingest the new location
+            this.__store.setState(s => ({
+              ...s,
+              location: opts.next
+            }));
           }
-        };
-      },
-      onFocus: () => {
-        router.load();
-      },
-      update: opts => {
-        const newHistory = (opts == null ? void 0 : opts.history) !== router.history;
 
-        if (!router.location || newHistory) {
-          if (opts != null && opts.history) {
-            router.history = opts.history;
+          // Match the routes
+          pendingMatches = this.matchRoutes(this.state.location.pathname, this.state.location.search, {
+            throwOnError: opts?.throwOnError,
+            debug: true
+          });
+          this.__store.setState(s => ({
+            ...s,
+            status: 'pending',
+            pendingMatchIds: pendingMatches.map(d => d.id),
+            matchesById: this.#mergeMatches(s.matchesById, pendingMatches)
+          }));
+        });
+        try {
+          // Load the matches
+          try {
+            await this.loadMatches(pendingMatches);
+          } catch (err) {
+            // swallow this error, since we'll display the
+            // errors on the route components
           }
 
-          router.location = router.__.parseLocation(router.history.location);
-          router.state.location = router.location;
-        }
-
-        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);
+          // Only apply the latest transition
+          if (latestPromise = checkLatest()) {
+            return latestPromise;
+          }
+          const prevLocation = this.state.resolvedLocation;
+          this.__store.setState(s => ({
+            ...s,
+            status: 'idle',
+            resolvedLocation: s.location,
+            matchIds: s.pendingMatchIds,
+            pendingMatchIds: []
+          }));
+          if (prevLocation.href !== this.state.location.href) {
+            this.options.onRouteChange?.();
+          }
+          resolve();
+        } catch (err) {
+          // Only apply the latest transition
+          if (latestPromise = checkLatest()) {
+            return latestPromise;
+          }
+          reject(err);
         }
-
-        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();
+      });
+      this.latestLoadPromise = promise;
+      return this.latestLoadPromise;
+    };
+    #mergeMatches = (prevMatchesById, nextMatches) => {
+      const nextMatchesById = {
+        ...prevMatchesById
+      };
+      let hadNew = false;
+      nextMatches.forEach(match => {
+        if (!nextMatchesById[match.id]) {
+          hadNew = true;
+          nextMatchesById[match.id] = match;
+        }
+      });
+      if (!hadNew) {
+        return prevMatchesById;
+      }
+      return nextMatchesById;
+    };
+    getRoute = id => {
+      const route = this.routesById[id];
+      invariant(route, `Route with id "${id}" not found`);
+      return route;
+    };
+    preloadRoute = async (navigateOpts = this.state.location) => {
+      const next = this.buildNext(navigateOpts);
+      const matches = this.matchRoutes(next.pathname, next.search, {
+        throwOnError: true
+      });
+      this.__store.setState(s => {
+        return {
+          ...s,
+          matchesById: this.#mergeMatches(s.matchesById, matches)
+        };
+      });
+      await this.loadMatches(matches, {
+        preload: true,
+        maxAge: navigateOpts.maxAge
+      });
+      return matches;
+    };
+    cleanMatches = () => {
+      const now = Date.now();
+      const outdatedMatchIds = Object.values(this.state.matchesById).filter(match => {
+        const route = this.getRoute(match.routeId);
+        return !this.state.matchIds.includes(match.id) && !this.state.pendingMatchIds.includes(match.id) && match.preloadInvalidAt < now && (route.options.gcMaxAge ? match.updatedAt + route.options.gcMaxAge < now : true);
+      }).map(d => d.id);
+      if (outdatedMatchIds.length) {
+        this.__store.setState(s => {
+          const matchesById = {
+            ...s.matchesById
+          };
+          outdatedMatchIds.forEach(id => {
+            delete matchesById[id];
+          });
+          return {
+            ...s,
+            matchesById
+          };
         });
-      },
-      load: async next => {
-        const id = Math.random();
-        router.startedLoadingAt = id;
-
-        if (next) {
-          // Ingest the new location
-          router.location = next;
-        } // Cancel any pending matches
-
-
-        router.cancelMatches(); // Match the routes
-
-        const matches = router.matchRoutes(router.location.pathname, {
-          strictParseParams: true
+      }
+    };
+    matchRoutes = (pathname, locationSearch, opts) => {
+      let routeParams = {};
+      let foundRoute = this.flatRoutes.find(route => {
+        const matchedParams = matchPathname(this.basepath, trimPathRight(pathname), {
+          to: route.fullPath,
+          caseSensitive: route.options.caseSensitive ?? this.options.caseSensitive
         });
-
-        if (typeof document !== 'undefined') {
-          router.state = _extends({}, router.state, {
-            pending: {
-              matches: matches,
-              location: router.location
-            },
-            status: 'loading'
-          });
-        } else {
-          router.state = _extends({}, router.state, {
-            matches: matches,
-            location: router.location,
-            status: 'loading'
-          });
+        if (matchedParams) {
+          routeParams = matchedParams;
+          return true;
         }
+        return false;
+      });
+      let routeCursor = foundRoute || this.routesById['__root__'];
+      let matchedRoutes = [routeCursor];
+      // let includingLayouts = true
+      while (routeCursor?.parentRoute) {
+        routeCursor = routeCursor.parentRoute;
+        if (routeCursor) matchedRoutes.unshift(routeCursor);
+      }
 
-        router.notify(); // Load the matches
-
-        await router.loadMatches(matches);
-
-        if (router.startedLoadingAt !== id) {
-          // Ignore side-effects of match loading
-          return router.navigationPromise;
-        }
+      // Existing matches are matches that are already loaded along with
+      // pending matches that are still loading
 
-        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 entering = matches.filter(d => {
-          return !previousMatches.find(dd => dd.matchId === d.matchId);
-        });
-        const now = Date.now();
-        exiting.forEach(d => {
-          var _ref, _d$options$loaderGcMa, _ref2, _d$options$loaderMaxA;
-
-          d.__.onExit == null ? void 0 : d.__.onExit({
-            params: d.params,
-            search: d.routeSearch
-          }); // Clear idle error states when match leaves
-
-          if (d.status === 'error' && !d.isFetching) {
-            d.status = 'idle';
-            d.error = undefined;
+      const parseErrors = matchedRoutes.map(route => {
+        let parsedParamsError;
+        if (route.options.parseParams) {
+          try {
+            const parsedParams = route.options.parseParams(routeParams);
+            // Add the parsed params to the accumulated params bag
+            Object.assign(routeParams, parsedParams);
+          } catch (err) {
+            parsedParamsError = new PathParamError(err.message, {
+              cause: err
+            });
+            if (opts?.throwOnError) {
+              throw parsedParamsError;
+            }
+            return parsedParamsError;
           }
+        }
+        return;
+      });
+      const matches = matchedRoutes.map((route, index) => {
+        const interpolatedPath = interpolatePath(route.path, routeParams);
+        const key = route.options.key ? route.options.key({
+          params: routeParams,
+          search: locationSearch
+        }) ?? '' : '';
+        const stringifiedKey = key ? JSON.stringify(key) : '';
+        const matchId = interpolatePath(route.id, routeParams, true) + stringifiedKey;
+
+        // Waste not, want not. If we already have a match for this route,
+        // reuse it. This is important for layout routes, which might stick
+        // around between navigation actions that only change leaf routes.
+        const existingMatch = this.getRouteMatch(matchId);
+        if (existingMatch) {
+          return {
+            ...existingMatch
+          };
+        }
 
-          const gc = Math.max((_ref = (_d$options$loaderGcMa = d.options.loaderGcMaxAge) != null ? _d$options$loaderGcMa : router.options.defaultLoaderGcMaxAge) != null ? _ref : 0, (_ref2 = (_d$options$loaderMaxA = d.options.loaderMaxAge) != null ? _d$options$loaderMaxA : router.options.defaultLoaderMaxAge) != null ? _ref2 : 0);
+        // Create a fresh route match
+        const hasLoaders = !!(route.options.loader || componentTypes.some(d => route.options[d]?.preload));
+        const routeMatch = {
+          id: matchId,
+          key: stringifiedKey,
+          routeId: route.id,
+          params: routeParams,
+          pathname: joinPaths([this.basepath, interpolatedPath]),
+          updatedAt: Date.now(),
+          invalidAt: Infinity,
+          preloadInvalidAt: Infinity,
+          routeSearch: {},
+          search: {},
+          status: hasLoaders ? 'pending' : 'success',
+          isFetching: false,
+          invalid: false,
+          error: undefined,
+          paramsError: parseErrors[index],
+          searchError: undefined,
+          loaderData: undefined,
+          loadPromise: Promise.resolve(),
+          routeContext: undefined,
+          context: undefined,
+          abortController: new AbortController(),
+          fetchedAt: 0
+        };
+        return routeMatch;
+      });
 
-          if (gc > 0) {
-            router.matchCache[d.matchId] = {
-              gc: gc == Infinity ? Number.MAX_SAFE_INTEGER : now + gc,
-              match: d
+      // Take each match and resolve its search params and context
+      // This has to happen after the matches are created or found
+      // so that we can use the parent match's search params and context
+      matches.forEach((match, i) => {
+        const parentMatch = matches[i - 1];
+        const route = this.getRoute(match.routeId);
+        const searchInfo = (() => {
+          // Validate the search params and stabilize them
+          const parentSearchInfo = {
+            search: parentMatch?.search ?? locationSearch,
+            routeSearch: parentMatch?.routeSearch ?? locationSearch
+          };
+          try {
+            const validator = typeof route.options.validateSearch === 'object' ? route.options.validateSearch.parse : route.options.validateSearch;
+            const routeSearch = validator?.(parentSearchInfo.search) ?? {};
+            const search = {
+              ...parentSearchInfo.search,
+              ...routeSearch
             };
+            return {
+              routeSearch: replaceEqualDeep(match.routeSearch, routeSearch),
+              search: replaceEqualDeep(match.search, search)
+            };
+          } catch (err) {
+            match.searchError = new SearchParamError(err.message, {
+              cause: err
+            });
+            if (opts?.throwOnError) {
+              throw match.searchError;
+            }
+            return parentSearchInfo;
           }
+        })();
+        Object.assign(match, {
+          ...searchInfo
         });
-        staying.forEach(d => {
-          d.options.onTransition == null ? void 0 : d.options.onTransition({
-            params: d.params,
-            search: d.routeSearch
-          });
-        });
-        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];
-        });
-
-        if (router.startedLoadingAt !== id) {
-          // Ignore side-effects of match loading
-          return;
-        }
-
-        matches.forEach(match => {
-          // Clear actions
-          if (match.action) {
-            match.action.current = undefined;
-            match.action.submissions = [];
+        const contextInfo = (() => {
+          try {
+            const routeContext = route.options.getContext?.({
+              parentContext: parentMatch?.routeContext ?? {},
+              context: parentMatch?.context ?? this?.options.context ?? {},
+              params: match.params,
+              search: match.search
+            }) || {};
+            const context = {
+              ...(parentMatch?.context ?? this?.options.context),
+              ...routeContext
+            };
+            return {
+              context,
+              routeContext
+            };
+          } catch (err) {
+            route.options.onError?.(err);
+            throw err;
           }
+        })();
+        Object.assign(match, {
+          ...contextInfo
         });
-        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
-
-          if (entry.match.status === 'loading') {
-            return;
-          } // Do not remove successful matches that are still valid
-
-
-          if (entry.gc > 0 && entry.gc > now) {
-            return;
-          } // Everything else gets removed
-
-
-          delete router.matchCache[matchId];
+      });
+      return matches;
+    };
+    loadMatches = async (resolvedMatches, opts) => {
+      this.cleanMatches();
+      if (!opts?.preload) {
+        resolvedMatches.forEach(match => {
+          // Update each match with its latest route data
+          this.setRouteMatch(match.id, s => ({
+            ...s,
+            routeSearch: match.routeSearch,
+            search: match.search,
+            routeContext: match.routeContext,
+            context: match.context,
+            error: match.error,
+            paramsError: match.paramsError,
+            searchError: match.searchError,
+            params: match.params
+          }));
         });
-      },
-      loadRoute: async function loadRoute(navigateOpts) {
-        if (navigateOpts === void 0) {
-          navigateOpts = router.location;
-        }
+      }
+      let firstBadMatchIndex;
 
-        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 _ref3, _ref4, _loaderOpts$maxAge, _ref5, _ref6, _loaderOpts$gcMaxAge;
+      // Check each match middleware to see if the route can be accessed
+      try {
+        for (const [index, match] of resolvedMatches.entries()) {
+          const route = this.getRoute(match.routeId);
+          const handleError = (err, handler) => {
+            firstBadMatchIndex = firstBadMatchIndex ?? index;
+            handler = handler || route.options.onError;
+            if (isRedirect(err)) {
+              throw err;
+            }
+            try {
+              handler?.(err);
+            } catch (errorHandlerErr) {
+              err = errorHandlerErr;
+              if (isRedirect(errorHandlerErr)) {
+                throw errorHandlerErr;
+              }
+            }
+            this.setRouteMatch(match.id, s => ({
+              ...s,
+              error: err,
+              status: 'error',
+              updatedAt: Date.now()
+            }));
+          };
+          if (match.paramsError) {
+            handleError(match.paramsError, route.options.onParseParamsError);
+          }
+          if (match.searchError) {
+            handleError(match.searchError, route.options.onValidateSearchError);
+          }
+          let didError = false;
+          try {
+            await route.options.beforeLoad?.({
+              ...match,
+              preload: !!opts?.preload
+            });
+          } catch (err) {
+            handleError(err, route.options.onBeforeLoadError);
+            didError = true;
+          }
 
-        if (navigateOpts === void 0) {
-          navigateOpts = router.location;
+          // If we errored, do not run the next matches' middleware
+          if (didError) {
+            break;
+          }
         }
-
-        const next = router.buildNext(navigateOpts);
-        const matches = router.matchRoutes(next.pathname, {
-          strictParseParams: true
-        });
-        await router.loadMatches(matches, {
-          preload: true,
-          maxAge: (_ref3 = (_ref4 = (_loaderOpts$maxAge = loaderOpts.maxAge) != null ? _loaderOpts$maxAge : router.options.defaultPreloadMaxAge) != null ? _ref4 : router.options.defaultLoaderMaxAge) != null ? _ref3 : 0,
-          gcMaxAge: (_ref5 = (_ref6 = (_loaderOpts$gcMaxAge = loaderOpts.gcMaxAge) != null ? _loaderOpts$gcMaxAge : router.options.defaultPreloadGcMaxAge) != null ? _ref6 : router.options.defaultLoaderGcMaxAge) != null ? _ref5 : 0
-        });
-        return matches;
-      },
-      matchRoutes: (pathname, opts) => {
-        var _router$state$pending3, _router$state$pending4;
-
-        router.cleanMatchCache();
-        const matches = [];
-
-        if (!router.routeTree) {
-          return matches;
+      } catch (err) {
+        if (!opts?.preload) {
+          this.navigate(err);
         }
-
-        const existingMatches = [...router.state.matches, ...((_router$state$pending3 = (_router$state$pending4 = router.state.pending) == null ? void 0 : _router$state$pending4.matches) != null ? _router$state$pending3 : [])];
-
-        const recurse = async routes => {
-          var _parentMatch$params, _router$options$filte, _foundRoute$childRout;
-
-          const parentMatch = last(matches);
-          let params = (_parentMatch$params = parentMatch == null ? void 0 : parentMatch.params) != null ? _parentMatch$params : {};
-          const filteredRoutes = (_router$options$filte = router.options.filterRoutes == null ? void 0 : router.options.filterRoutes(routes)) != null ? _router$options$filte : routes;
-          let foundRoutes = [];
-
-          const findMatchInRoutes = (parentRoutes, routes) => {
-            routes.some(route => {
-              var _route$childRoutes, _route$childRoutes2, _route$options$caseSe;
-
-              if (!route.routePath && (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length) {
-                return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
+        throw err;
+      }
+      const validResolvedMatches = resolvedMatches.slice(0, firstBadMatchIndex);
+      const matchPromises = [];
+      validResolvedMatches.forEach((match, index) => {
+        matchPromises.push((async () => {
+          const parentMatchPromise = matchPromises[index - 1];
+          const route = this.getRoute(match.routeId);
+          if (match.isFetching || match.status === 'success' && !this.getIsInvalid({
+            matchId: match.id,
+            preload: opts?.preload
+          })) {
+            return this.getRouteMatch(match.id)?.loadPromise;
+          }
+          const fetchedAt = Date.now();
+          const checkLatest = () => {
+            const latest = this.getRouteMatch(match.id);
+            return latest && latest.fetchedAt !== fetchedAt ? latest.loadPromise : undefined;
+          };
+          const handleIfRedirect = err => {
+            if (isRedirect(err)) {
+              if (!opts?.preload) {
+                this.navigate(err);
               }
-
-              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
+              return true;
+            }
+            return false;
+          };
+          const load = async () => {
+            let latestPromise;
+            try {
+              const componentsPromise = Promise.all(componentTypes.map(async type => {
+                const component = route.options[type];
+                if (component?.preload) {
+                  await component.preload();
+                }
+              }));
+              const loaderPromise = route.options.loader?.({
+                ...match,
+                preload: !!opts?.preload,
+                parentMatchPromise
               });
-
-              if (matchParams) {
-                let parsedParams;
-
+              const [_, loader] = await Promise.all([componentsPromise, loaderPromise]);
+              if (latestPromise = checkLatest()) return await latestPromise;
+              this.setRouteMatchData(match.id, () => loader, opts);
+            } catch (loaderError) {
+              let latestError = loaderError;
+              if (latestPromise = checkLatest()) return await latestPromise;
+              if (handleIfRedirect(loaderError)) return;
+              if (route.options.onLoadError) {
                 try {
-                  var _route$options$parseP;
-
-                  parsedParams = (_route$options$parseP = route.options.parseParams == null ? void 0 : route.options.parseParams(matchParams)) != null ? _route$options$parseP : matchParams;
-                } catch (err) {
-                  if (opts != null && opts.strictParseParams) {
-                    throw err;
-                  }
+                  route.options.onLoadError(loaderError);
+                } catch (onLoadError) {
+                  latestError = onLoadError;
+                  if (handleIfRedirect(onLoadError)) return;
                 }
-
-                params = _extends({}, params, parsedParams);
               }
-
-              if (!!matchParams) {
-                foundRoutes = [...parentRoutes, route];
+              if ((!route.options.onLoadError || latestError !== loaderError) && route.options.onError) {
+                try {
+                  route.options.onError(latestError);
+                } catch (onErrorError) {
+                  if (handleIfRedirect(onErrorError)) return;
+                }
               }
-
-              return !!foundRoutes.length;
-            });
-            return !!foundRoutes.length;
+              this.setRouteMatch(match.id, s => ({
+                ...s,
+                error: loaderError,
+                status: 'error',
+                isFetching: false,
+                updatedAt: Date.now()
+              }));
+            }
           };
-
-          findMatchInRoutes([], filteredRoutes);
-
-          if (!foundRoutes.length) {
-            return;
-          }
-
-          foundRoutes.forEach(foundRoute => {
-            var _router$matchCache$ma;
-
-            const interpolatedPath = interpolatePath(foundRoute.routePath, params);
-            const matchId = interpolatePath(foundRoute.routeId, params, true);
-            const match = existingMatches.find(d => d.matchId === matchId) || ((_router$matchCache$ma = router.matchCache[matchId]) == null ? void 0 : _router$matchCache$ma.match) || createRouteMatch(router, foundRoute, {
-              parentMatch,
-              matchId,
-              params,
-              pathname: joinPaths([pathname, interpolatedPath])
-            });
-            matches.push(match);
+          let loadPromise;
+          this.__store.batch(() => {
+            this.setRouteMatch(match.id, s => ({
+              ...s,
+              // status: s.status !== 'success' ? 'pending' : s.status,
+              isFetching: true,
+              fetchedAt,
+              invalid: false
+            }));
+            loadPromise = load();
+            this.setRouteMatch(match.id, s => ({
+              ...s,
+              loadPromise
+            }));
           });
-          const foundRoute = last(foundRoutes);
-
-          if ((_foundRoute$childRout = foundRoute.childRoutes) != null && _foundRoute$childRout.length) {
-            recurse(foundRoute.childRoutes);
-          }
-        };
-
-        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();
-
-          match.load(loaderOpts);
-
-          if (match.__.loadPromise) {
-            // Wait for the first sign of activity from the match
-            await match.__.loadPromise;
-          }
-        });
-        router.notify();
-        await Promise.all(matchPromises);
-      },
-      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.invalidate();
-          }
-        });
-      },
-      reload: () => router.__.navigate({
+          await loadPromise;
+        })());
+      });
+      await Promise.all(matchPromises);
+    };
+    reload = () => {
+      return this.navigate({
         fromCurrent: true,
         replace: true,
         search: true
-      }),
-      resolvePath: (from, path) => {
-        return resolvePath(router.basepath, from, cleanPath(path));
-      },
-      matchRoute: (location, opts) => {
-        var _location$from;
-
-        // const location = router.buildNext(opts)
-        location = _extends({}, location, {
-          to: location.to ? router.resolvePath((_location$from = location.from) != null ? _location$from : '', location.to) : undefined
-        });
-        const next = router.buildNext(location);
-
-        if (opts != null && opts.pending) {
-          var _router$state$pending7;
-
-          if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
-            return false;
-          }
+      });
+    };
+    resolvePath = (from, path) => {
+      return resolvePath(this.basepath, from, cleanPath(path));
+    };
+    navigate = async ({
+      from,
+      to = '',
+      search,
+      hash,
+      replace,
+      params
+    }) => {
+      // 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 = typeof from === 'undefined' ? from : String(from);
+      let isExternal;
+      try {
+        new URL(`${toString}`);
+        isExternal = true;
+      } catch (e) {}
+      invariant(!isExternal, 'Attempting to navigate to external url with this.navigate!');
+      return this.#commitLocation({
+        from: fromString,
+        to: toString,
+        search,
+        hash,
+        replace,
+        params
+      });
+    };
+    matchRoute = (location, opts) => {
+      location = {
+        ...location,
+        to: location.to ? this.resolvePath(location.from ?? '', location.to) : undefined
+      };
+      const next = this.buildNext(location);
+      if (opts?.pending && this.state.status !== 'pending') {
+        return false;
+      }
+      const baseLocation = opts?.pending ? this.state.location : this.state.resolvedLocation;
+      if (!baseLocation) {
+        return false;
+      }
+      const match = matchPathname(this.basepath, baseLocation.pathname, {
+        ...opts,
+        to: next.pathname
+      });
+      if (!match) {
+        return false;
+      }
+      if (opts?.includeSearch ?? true) {
+        return partialDeepEqual(baseLocation.search, next.search) ? match : false;
+      }
+      return match;
+    };
+    buildLink = ({
+      from,
+      to = '.',
+      search,
+      params,
+      hash,
+      target,
+      replace,
+      activeOptions,
+      preload,
+      preloadDelay: userPreloadDelay,
+      disabled,
+      state
+    }) => {
+      // 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
 
-          return !!matchPathname(router.state.pending.location.pathname, _extends({}, opts, {
-            to: next.pathname
-          }));
+      try {
+        new URL(`${to}`);
+        return {
+          type: 'external',
+          href: to
+        };
+      } catch (e) {}
+      const nextOpts = {
+        from,
+        to,
+        search,
+        params,
+        hash,
+        replace,
+        state
+      };
+      const next = this.buildNext(nextOpts);
+      preload = preload ?? this.options.defaultPreload;
+      const preloadDelay = userPreloadDelay ?? this.options.defaultPreloadDelay ?? 0;
+
+      // Compare path/hash for matches
+      const currentPathSplit = this.state.location.pathname.split('/');
+      const nextPathSplit = next.pathname.split('/');
+      const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
+      // Combine the matches based on user options
+      const pathTest = activeOptions?.exact ? this.state.location.pathname === next.pathname : pathIsFuzzyEqual;
+      const hashTest = activeOptions?.includeHash ? this.state.location.hash === next.hash : true;
+      const searchTest = activeOptions?.includeSearch ?? true ? partialDeepEqual(this.state.location.search, next.search) : true;
+
+      // The final "active" test
+      const isActive = pathTest && hashTest && searchTest;
+
+      // The click handler
+      const handleClick = e => {
+        if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
+          e.preventDefault();
+
+          // All is well? Navigate!
+          this.#commitLocation(nextOpts);
         }
+      };
 
-        return !!matchPathname(router.state.location.pathname, _extends({}, opts, {
-          to: next.pathname
-        }));
-      },
-      navigate: async _ref7 => {
-        let {
-          from,
-          to = '.',
-          search,
-          hash,
-          replace,
-          params
-        } = _ref7;
-        // If this link simply reloads the current route,
-        // make sure it has a new key so it will trigger a data refresh
-        // If this `to` is a valid external URL, return
-        // null for LinkUtils
-        const toString = String(to);
-        const fromString = String(from);
-        let isExternal;
-
-        try {
-          new URL("" + toString);
-          isExternal = true;
-        } catch (e) {}
-
-        invariant(!isExternal, 'Attempting to navigate to external url with router.navigate!');
-        return router.__.navigate({
-          from: fromString,
-          to: toString,
-          search,
-          hash,
-          replace,
-          params
+      // The click handler
+      const handleFocus = e => {
+        if (preload) {
+          this.preloadRoute(nextOpts).catch(err => {
+            console.warn(err);
+            console.warn('Error preloading route! ☝️');
+          });
+        }
+      };
+      const handleTouchStart = e => {
+        this.preloadRoute(nextOpts).catch(err => {
+          console.warn(err);
+          console.warn('Error preloading route! ☝️');
         });
-      },
-      buildLink: _ref8 => {
-        var _preload, _ref9;
-
-        let {
-          from,
-          to = '.',
-          search,
-          params,
-          hash,
-          target,
-          replace,
-          activeOptions,
-          preload,
-          preloadMaxAge: userPreloadMaxAge,
-          preloadGcMaxAge: userPreloadGcMaxAge,
-          preloadDelay: userPreloadDelay,
-          disabled
-        } = _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
-        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.defaultPreload;
-        const preloadDelay = (_ref9 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref9 : 0; // Compare path/hash for matches
-
-        const pathIsEqual = router.state.location.pathname === next.pathname;
-        const currentPathSplit = router.state.location.pathname.split('/');
-        const nextPathSplit = next.pathname.split('/');
-        const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
-        const hashIsEqual = router.state.location.hash === next.hash; // Combine the matches based on user options
-
-        const pathTest = activeOptions != null && activeOptions.exact ? pathIsEqual : pathIsFuzzyEqual;
-        const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true; // The final "active" test
-
-        const isActive = pathTest && hashTest; // The click handler
-
-        const handleClick = e => {
-          if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
-            e.preventDefault();
-
-            if (pathIsEqual && !search && !hash) {
-              router.invalidateRoute(nextOpts);
-            } // All is well? Navigate!)
-
-
-            router.__.navigate(nextOpts);
-          }
-        }; // The click handler
-
-
-        const handleFocus = e => {
-          if (preload) {
-            router.preloadRoute(nextOpts, {
-              maxAge: userPreloadMaxAge,
-              gcMaxAge: userPreloadGcMaxAge
-            });
-          }
-        };
-
-        const handleEnter = e => {
-          const target = e.target || {};
-
-          if (preload) {
-            if (target.preloadTimeout) {
-              return;
-            }
-
-            target.preloadTimeout = setTimeout(() => {
-              target.preloadTimeout = null;
-              router.preloadRoute(nextOpts, {
-                maxAge: userPreloadMaxAge,
-                gcMaxAge: userPreloadGcMaxAge
-              });
-            }, preloadDelay);
-          }
-        };
-
-        const handleLeave = e => {
-          const target = e.target || {};
-
+      };
+      const handleEnter = e => {
+        const target = e.target || {};
+        if (preload) {
           if (target.preloadTimeout) {
-            clearTimeout(target.preloadTimeout);
-            target.preloadTimeout = null;
+            return;
           }
-        };
-
+          target.preloadTimeout = setTimeout(() => {
+            target.preloadTimeout = null;
+            this.preloadRoute(nextOpts).catch(err => {
+              console.warn(err);
+              console.warn('Error preloading route! ☝️');
+            });
+          }, preloadDelay);
+        }
+      };
+      const handleLeave = e => {
+        const target = e.target || {};
+        if (target.preloadTimeout) {
+          clearTimeout(target.preloadTimeout);
+          target.preloadTimeout = null;
+        }
+      };
+      return {
+        type: 'internal',
+        next,
+        handleFocus,
+        handleClick,
+        handleEnter,
+        handleLeave,
+        handleTouchStart,
+        isActive,
+        disabled
+      };
+    };
+    dehydrate = () => {
+      return {
+        state: pick(this.state, ['location', 'status', 'lastUpdated'])
+      };
+    };
+    hydrate = async __do_not_use_server_ctx => {
+      let _ctx = __do_not_use_server_ctx;
+      // Client hydrates from window
+      if (typeof document !== 'undefined') {
+        _ctx = window.__TSR_DEHYDRATED__;
+      }
+      invariant(_ctx, 'Expected to find a __TSR_DEHYDRATED__ property on window... but we did not. Did you forget to render <DehydrateRouter /> in your app?');
+      const ctx = _ctx;
+      this.dehydratedData = ctx.payload;
+      this.options.hydrate?.(ctx.payload);
+      const routerState = ctx.router.state;
+      this.__store.setState(s => {
         return {
-          type: 'internal',
-          next,
-          handleFocus,
-          handleClick,
-          handleEnter,
-          handleLeave,
-          isActive,
-          disabled
+          ...s,
+          ...routerState,
+          resolvedLocation: routerState.location
         };
-      },
-      buildNext: opts => {
-        const next = router.__.buildLocation(opts);
-
-        const matches = router.matchRoutes(next.pathname);
-
-        const __preSearchFilters = matches.map(match => {
-          var _match$options$preSea;
-
-          return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
-        }).flat().filter(Boolean);
-
-        const __postSearchFilters = matches.map(match => {
-          var _match$options$postSe;
-
-          return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
-        }).flat().filter(Boolean);
-
-        return router.__.buildLocation(_extends({}, opts, {
-          __preSearchFilters,
-          __postSearchFilters
-        }));
-      },
-      __: {
-        buildRouteTree: rootRouteConfig => {
-          const recurseRoutes = (routeConfigs, parent) => {
-            return routeConfigs.map(routeConfig => {
-              const routeOptions = routeConfig.options;
-              const route = createRoute(routeConfig, routeOptions, parent, router);
-              const existingRoute = router.routesById[route.routeId];
-
-              if (existingRoute) {
-                {
-                  console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
-                }
-
-                throw new Error();
-              }
-              router.routesById[route.routeId] = route;
-              const children = routeConfig.children;
-              route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
-              return route;
-            });
-          };
-
-          const routes = recurseRoutes([rootRouteConfig]);
-          return routes[0];
-        },
-        parseLocation: (location, previousLocation) => {
-          var _location$hash$split$;
-
-          const parsedSearch = router.options.parseSearch(location.search);
-          return {
-            pathname: location.pathname,
-            searchStr: location.search,
-            search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
-            hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
-            href: "" + location.pathname + location.search + location.hash,
-            state: location.state,
-            key: location.key
-          };
-        },
-        navigate: location => {
-          const next = router.buildNext(location);
-          return router.__.commitLocation(next, location.replace);
-        },
-        buildLocation: function buildLocation(dest) {
-          var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
-
-          if (dest === void 0) {
-            dest = {};
-          }
-
-          // const resolvedFrom: Location = {
-          //   ...router.location,
-          const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
+      });
+      await this.load();
+      return;
+    };
+    injectedHtml = [];
+    injectHtml = async html => {
+      this.injectedHtml.push(html);
+    };
+    dehydrateData = (key, getData) => {
+      if (typeof document === 'undefined') {
+        const strKey = typeof key === 'string' ? key : JSON.stringify(key);
+        this.injectHtml(async () => {
+          const id = `__TSR_DEHYDRATED__${strKey}`;
+          const data = typeof getData === 'function' ? await getData() : getData;
+          return `<script id='${id}' suppressHydrationWarning>window["__TSR_DEHYDRATED__${escapeJSON(strKey)}"] = ${JSON.stringify(data)}
+        ;(() => {
+          var el = document.getElementById('${id}')
+          el.parentElement.removeChild(el)
+        })()
+        </script>`;
+        });
+        return () => this.hydrateData(key);
+      }
+      return () => undefined;
+    };
+    hydrateData = key => {
+      if (typeof document !== 'undefined') {
+        const strKey = typeof key === 'string' ? key : JSON.stringify(key);
+        return window[`__TSR_DEHYDRATED__${strKey}`];
+      }
+      return undefined;
+    };
 
-          let pathname = resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
+    // resolveMatchPromise = (matchId: string, key: string, value: any) => {
+    //   this.state.matches
+    //     .find((d) => d.id === matchId)
+    //     ?.__promisesByKey[key]?.resolve(value)
+    // }
 
-          const fromMatches = router.matchRoutes(router.location.pathname, {
-            strictParseParams: true
+    #buildRouteTree = routeTree => {
+      this.routeTree = routeTree;
+      this.routesById = {};
+      this.routesByPath = {};
+      this.flatRoutes = [];
+      const recurseRoutes = routes => {
+        routes.forEach((route, i) => {
+          route.init({
+            originalIndex: i,
+            router: this
           });
-          const toMatches = router.matchRoutes(pathname);
-
-          const prevParams = _extends({}, (_last = last(fromMatches)) == null ? void 0 : _last.params);
-
-          let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
-
-          if (nextParams) {
-            toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
-              Object.assign({}, nextParams, fn(nextParams));
-            });
+          const existingRoute = this.routesById[route.id];
+          invariant(!existingRoute, `Duplicate routes found with id: ${String(route.id)}`);
+          this.routesById[route.id] = route;
+          if (!route.isRoot && route.path) {
+            const trimmedFullPath = trimPathRight(route.fullPath);
+            if (!this.routesByPath[trimmedFullPath] || route.fullPath.endsWith('/')) {
+              this.routesByPath[trimmedFullPath] = route;
+            }
           }
-
-          pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
-
-          const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search; // Then the link/navigate function
-
-          const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
-          : dest.search ? (_functionalUpdate = functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
-          : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom filters
-          : {}; // Then post filters
-
-          const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
-          const search = replaceEqualDeep(router.location.search, postFilteredSearch);
-          const searchStr = router.options.stringifySearch(search);
-          let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
-          hash = hash ? "#" + hash : '';
-          return {
-            pathname,
-            search,
-            searchStr,
-            state: router.location.state,
-            hash,
-            href: "" + pathname + searchStr + hash,
-            key: dest.key
-          };
-        },
-        commitLocation: (next, replace) => {
-          const id = '' + Date.now() + Math.random();
-          if (router.navigateTimeout) clearTimeout(router.navigateTimeout);
-          let nextAction = 'replace';
-
-          if (!replace) {
-            nextAction = 'push';
+          const children = route.children;
+          if (children?.length) {
+            recurseRoutes(children);
           }
+        });
+      };
+      recurseRoutes([routeTree]);
+      this.flatRoutes = Object.values(this.routesByPath).map((d, i) => {
+        const trimmed = trimPath(d.fullPath);
+        const parsed = parsePathname(trimmed);
+        while (parsed.length > 1 && parsed[0]?.value === '/') {
+          parsed.shift();
+        }
+        const score = parsed.map(d => {
+          if (d.type === 'param') {
+            return 0.5;
+          }
+          if (d.type === 'wildcard') {
+            return 0.25;
+          }
+          return 1;
+        });
+        return {
+          child: d,
+          trimmed,
+          parsed,
+          index: i,
+          score
+        };
+      }).sort((a, b) => {
+        let isIndex = a.trimmed === '/' ? 1 : b.trimmed === '/' ? -1 : 0;
+        if (isIndex !== 0) return isIndex;
+        const length = Math.min(a.score.length, b.score.length);
+
+        // Sort by length of score
+        if (a.score.length !== b.score.length) {
+          return b.score.length - a.score.length;
+        }
 
-          const isSameUrl = router.__.parseLocation(history.location).href === next.href;
-
-          if (isSameUrl && !next.key) {
-            nextAction = 'replace';
+        // Sort by min available score
+        for (let i = 0; i < length; i++) {
+          if (a.score[i] !== b.score[i]) {
+            return b.score[i] - a.score[i];
           }
+        }
 
-          if (nextAction === 'replace') {
-            history.replace({
-              pathname: next.pathname,
-              hash: next.hash,
-              search: next.searchStr
-            }, _extends({
-              id
-            }, next.state));
-          } else {
-            history.push({
-              pathname: next.pathname,
-              hash: next.hash,
-              search: next.searchStr
-            }, {
-              id
-            });
+        // Sort by min available parsed value
+        for (let i = 0; i < length; i++) {
+          if (a.parsed[i].value !== b.parsed[i].value) {
+            return a.parsed[i].value > b.parsed[i].value ? 1 : -1;
           }
+        }
 
-          router.navigationPromise = new Promise(resolve => {
-            const previousNavigationResolve = router.resolveNavigation;
+        // Sort by length of trimmed full path
+        if (a.trimmed !== b.trimmed) {
+          return a.trimmed > b.trimmed ? 1 : -1;
+        }
 
-            router.resolveNavigation = () => {
-              previousNavigationResolve();
-              resolve();
-            };
+        // Sort by original index
+        return a.index - b.index;
+      }).map((d, i) => {
+        d.child.rank = i;
+        return d.child;
+      });
+    };
+    #parseLocation = previousLocation => {
+      let {
+        pathname,
+        search,
+        hash,
+        state
+      } = this.history.location;
+      const parsedSearch = this.options.parseSearch(search);
+      return {
+        pathname: pathname,
+        searchStr: search,
+        search: replaceEqualDeep(previousLocation?.search, parsedSearch),
+        hash: hash.split('#').reverse()[0] ?? '',
+        href: `${pathname}${search}${hash}`,
+        state: state,
+        key: state?.key || '__init__'
+      };
+    };
+    #buildLocation = (dest = {}) => {
+      dest.fromCurrent = dest.fromCurrent ?? dest.to === '';
+      const fromPathname = dest.fromCurrent ? this.state.location.pathname : dest.from ?? this.state.location.pathname;
+      let pathname = resolvePath(this.basepath ?? '/', fromPathname, `${dest.to ?? ''}`);
+      const fromMatches = this.matchRoutes(this.state.location.pathname, this.state.location.search);
+      const prevParams = {
+        ...last(fromMatches)?.params
+      };
+      let nextParams = (dest.params ?? true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
+      if (nextParams) {
+        dest.__matches?.map(d => this.getRoute(d.routeId).options.stringifyParams).filter(Boolean).forEach(fn => {
+          nextParams = {
+            ...nextParams,
+            ...fn(nextParams)
+          };
+        });
+      }
+      pathname = interpolatePath(pathname, nextParams ?? {});
+      const preSearchFilters = dest.__matches?.map(match => this.getRoute(match.routeId).options.preSearchFilters ?? []).flat().filter(Boolean) ?? [];
+      const postSearchFilters = dest.__matches?.map(match => this.getRoute(match.routeId).options.postSearchFilters ?? []).flat().filter(Boolean) ?? [];
+
+      // Pre filters first
+      const preFilteredSearch = preSearchFilters?.length ? preSearchFilters?.reduce((prev, next) => next(prev), this.state.location.search) : this.state.location.search;
+
+      // Then the link/navigate function
+      const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
+      : dest.search ? functionalUpdate(dest.search, preFilteredSearch) ?? {} // Updater
+      : preSearchFilters?.length ? preFilteredSearch // Preserve resolvedFrom filters
+      : {};
+
+      // Then post filters
+      const postFilteredSearch = postSearchFilters?.length ? postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
+      const search = replaceEqualDeep(this.state.location.search, postFilteredSearch);
+      const searchStr = this.options.stringifySearch(search);
+      const hash = dest.hash === true ? this.state.location.hash : functionalUpdate(dest.hash, this.state.location.hash);
+      const hashStr = hash ? `#${hash}` : '';
+      const nextState = dest.state === true ? this.state.location.state : functionalUpdate(dest.state, this.state.location.state);
+      return {
+        pathname,
+        search,
+        searchStr,
+        state: nextState,
+        hash,
+        href: this.history.createHref(`${pathname}${searchStr}${hashStr}`),
+        key: dest.key
+      };
+    };
+    #commitLocation = async location => {
+      const next = this.buildNext(location);
+      const id = '' + Date.now() + Math.random();
+      if (this.navigateTimeout) clearTimeout(this.navigateTimeout);
+      let nextAction = 'replace';
+      if (!location.replace) {
+        nextAction = 'push';
+      }
+      const isSameUrl = this.state.location.href === next.href;
+      if (isSameUrl && !next.key) {
+        nextAction = 'replace';
+      }
+      const href = `${next.pathname}${next.searchStr}${next.hash ? `#${next.hash}` : ''}`;
+      this.history[nextAction === 'push' ? 'push' : 'replace'](href, {
+        id,
+        ...next.state
+      });
+      return this.latestLoadPromise;
+    };
+    getRouteMatch = id => {
+      return this.state.matchesById[id];
+    };
+    setRouteMatch = (id, updater) => {
+      this.__store.setState(prev => {
+        if (!prev.matchesById[id]) {
+          console.warn(`No match found with id: ${id}`);
+        }
+        return {
+          ...prev,
+          matchesById: {
+            ...prev.matchesById,
+            [id]: updater(prev.matchesById[id])
+          }
+        };
+      });
+    };
+    setRouteMatchData = (id, updater, opts) => {
+      const match = this.getRouteMatch(id);
+      if (!match) return;
+      const route = this.getRoute(match.routeId);
+      const updatedAt = opts?.updatedAt ?? Date.now();
+      const preloadInvalidAt = updatedAt + (opts?.maxAge ?? route.options.preloadMaxAge ?? this.options.defaultPreloadMaxAge ?? 5000);
+      const invalidAt = updatedAt + (opts?.maxAge ?? route.options.maxAge ?? this.options.defaultMaxAge ?? Infinity);
+      this.setRouteMatch(id, s => ({
+        ...s,
+        error: undefined,
+        status: 'success',
+        isFetching: false,
+        updatedAt: Date.now(),
+        loaderData: functionalUpdate(updater, s.loaderData),
+        preloadInvalidAt,
+        invalidAt
+      }));
+      if (this.state.matches.find(d => d.id === id)) ;
+    };
+    invalidate = async opts => {
+      if (opts?.matchId) {
+        this.setRouteMatch(opts.matchId, s => ({
+          ...s,
+          invalid: true
+        }));
+        const matchIndex = this.state.matches.findIndex(d => d.id === opts.matchId);
+        const childMatch = this.state.matches[matchIndex + 1];
+        if (childMatch) {
+          return this.invalidate({
+            matchId: childMatch.id,
+            reload: false
           });
-          return router.navigationPromise;
         }
+      } else {
+        this.__store.batch(() => {
+          Object.values(this.state.matchesById).forEach(match => {
+            this.setRouteMatch(match.id, s => ({
+              ...s,
+              invalid: true
+            }));
+          });
+        });
+      }
+      if (opts?.reload ?? true) {
+        return this.reload();
       }
     };
-    router.update(userOptions); // Allow frameworks to hook into the router creation
-
-    router.options.createRouter == null ? void 0 : router.options.createRouter(router);
-    return router;
+    getIsInvalid = opts => {
+      if (!opts?.matchId) {
+        return !!this.state.matches.find(d => this.getIsInvalid({
+          matchId: d.id,
+          preload: opts?.preload
+        }));
+      }
+      const match = this.getRouteMatch(opts?.matchId);
+      if (!match) {
+        return false;
+      }
+      const now = Date.now();
+      return match.invalid || (opts?.preload ? match.preloadInvalidAt : match.invalidAt) < now;
+    };
   }
 
+  // Detect if we're in the DOM
+  const isServer = typeof window === 'undefined' || !window.document.createElement;
+  function getInitialRouterState() {
+    return {
+      status: 'idle',
+      isFetching: false,
+      resolvedLocation: null,
+      location: null,
+      matchesById: {},
+      matchIds: [],
+      pendingMatchIds: [],
+      matches: [],
+      pendingMatches: [],
+      lastUpdated: Date.now()
+    };
+  }
   function isCtrlEvent(e) {
     return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
   }
+  function redirect(opts) {
+    opts.isRedirect = true;
+    return opts;
+  }
+  function isRedirect(obj) {
+    return !!obj?.isRedirect;
+  }
+  class SearchParamError extends Error {}
+  class PathParamError extends Error {}
+  function escapeJSON(jsonString) {
+    return jsonString.replace(/\\/g, '\\\\') // Escape backslashes
+    .replace(/'/g, "\\'") // Escape single quotes
+    .replace(/"/g, '\\"'); // Escape double quotes
+  }
 
-  function cascadeLoaderData(matches) {
-    matches.forEach((match, index) => {
-      const parent = matches[index - 1];
+  // A function that takes an import() argument which is a function and returns a new function that will
+  // proxy arguments from the caller to the imported function, retaining all type
+  // information along the way
+  function lazyFn(fn, key) {
+    return async (...args) => {
+      const imported = await fn();
+      return imported[key || 'default'](...args);
+    };
+  }
 
-      if (parent) {
-        match.loaderData = replaceEqualDeep(match.loaderData, _extends({}, parent.loaderData, match.routeLoaderData));
+  Route.__onInit = route => {
+    Object.assign(route, {
+      useMatch: (opts = {}) => {
+        return useMatch({
+          ...opts,
+          from: route.id
+        });
+      },
+      useLoader: (opts = {}) => {
+        return useLoader({
+          ...opts,
+          from: route.id
+        });
+      },
+      useContext: (opts = {}) => {
+        return useMatch({
+          ...opts,
+          from: route.id,
+          select: d => opts?.select?.(d.context) ?? d.context
+        });
+      },
+      useRouteContext: (opts = {}) => {
+        return useMatch({
+          ...opts,
+          from: route.id,
+          select: d => opts?.select?.(d.routeContext) ?? d.routeContext
+        });
+      },
+      useSearch: (opts = {}) => {
+        return useSearch({
+          ...opts,
+          from: route.id
+        });
+      },
+      useParams: (opts = {}) => {
+        return useParams({
+          ...opts,
+          from: route.id
+        });
       }
     });
-  }
+  };
 
-  const _excluded = ["type", "children", "target", "activeProps", "inactiveProps", "activeOptions", "disabled", "hash", "search", "params", "to", "preload", "preloadDelay", "preloadMaxAge", "replace", "style", "className", "onClick", "onFocus", "onMouseEnter", "onMouseLeave", "onTouchStart", "onTouchEnd"],
-        _excluded2 = ["pending", "caseSensitive", "children"],
-        _excluded3 = ["children", "router"];
   //
-  const matchesContext = /*#__PURE__*/React__namespace.createContext(null);
-  const routerContext = /*#__PURE__*/React__namespace.createContext(null); // Detect if we're in the DOM
-  function MatchesProvider(props) {
-    return /*#__PURE__*/React__namespace.createElement(matchesContext.Provider, props);
-  }
 
-  const useRouterSubscription = router => {
-    shim.useSyncExternalStore(cb => router.subscribe(() => cb()), () => router.state, () => router.state);
-  };
-
-  function createReactRouter(opts) {
-    const makeRouteExt = (route, router) => {
+  function lazyRouteComponent(importer, exportName) {
+    let loadPromise;
+    const load = () => {
+      if (!loadPromise) {
+        loadPromise = importer();
+      }
+      return loadPromise;
+    };
+    const lazyComp = /*#__PURE__*/React__namespace.lazy(async () => {
+      const moduleExports = await load();
+      const comp = moduleExports[exportName ?? 'default'];
       return {
-        useRoute: function useRoute(subRouteId) {
-          if (subRouteId === void 0) {
-            subRouteId = '.';
-          }
-
-          const resolvedRouteId = router.resolvePath(route.routeId, subRouteId);
-          const resolvedRoute = router.getRoute(resolvedRouteId);
-          useRouterSubscription(router);
-          invariant(resolvedRoute, "Could not find a route for route \"" + resolvedRouteId + "\"! Did you forget to add it to your route config?");
-          return resolvedRoute;
-        },
-        linkProps: options => {
-          var _functionalUpdate, _functionalUpdate2;
-
-          const {
-            // custom props
-            target,
-            activeProps = () => ({
-              className: 'active'
-            }),
-            inactiveProps = () => ({}),
-            disabled,
-            // element props
-            style,
-            className,
-            onClick,
-            onFocus,
-            onMouseEnter,
-            onMouseLeave
-          } = options,
-                rest = _objectWithoutPropertiesLoose(options, _excluded);
-
-          const linkInfo = route.buildLink(options);
-
-          if (linkInfo.type === 'external') {
-            const {
-              href
-            } = linkInfo;
-            return {
-              href
-            };
-          }
-
-          const {
-            handleClick,
-            handleFocus,
-            handleEnter,
-            handleLeave,
-            isActive,
-            next
-          } = linkInfo;
-
-          const reactHandleClick = e => {
-            React__namespace.startTransition(() => {
-              handleClick(e);
-            });
-          };
-
-          const composeHandlers = handlers => e => {
-            e.persist();
-            handlers.forEach(handler => {
-              if (handler) handler(e);
-            });
-          }; // Get the active props
-
-
-          const resolvedActiveProps = isActive ? (_functionalUpdate = functionalUpdate(activeProps, {})) != null ? _functionalUpdate : {} : {}; // Get the inactive props
-
-          const resolvedInactiveProps = isActive ? {} : (_functionalUpdate2 = functionalUpdate(inactiveProps, {})) != null ? _functionalUpdate2 : {};
-          return _extends$2({}, resolvedActiveProps, resolvedInactiveProps, rest, {
-            href: disabled ? undefined : next.href,
-            onClick: composeHandlers([reactHandleClick, onClick]),
-            onFocus: composeHandlers([handleFocus, onFocus]),
-            onMouseEnter: composeHandlers([handleEnter, onMouseEnter]),
-            onMouseLeave: composeHandlers([handleLeave, onMouseLeave]),
-            target,
-            style: _extends$2({}, style, resolvedActiveProps.style, resolvedInactiveProps.style),
-            className: [className, resolvedActiveProps.className, resolvedInactiveProps.className].filter(Boolean).join(' ') || undefined
-          }, disabled ? {
-            role: 'link',
-            'aria-disabled': true
-          } : undefined, {
-            ['data-status']: isActive ? 'active' : undefined
-          });
-        },
-        Link: /*#__PURE__*/React__namespace.forwardRef((props, ref) => {
-          const linkProps = route.linkProps(props);
-          useRouterSubscription(router);
-          return /*#__PURE__*/React__namespace.createElement("a", _extends$2({
-            ref: ref
-          }, linkProps, {
-            children: typeof props.children === 'function' ? props.children({
-              isActive: linkProps['data-status'] === 'active'
-            }) : props.children
-          }));
-        }),
-        MatchRoute: opts => {
-          const {
-            pending,
-            caseSensitive
-          } = opts,
-                rest = _objectWithoutPropertiesLoose(opts, _excluded2);
-
-          const params = route.matchRoute(rest, {
-            pending,
-            caseSensitive
-          });
-
-          if (!params) {
-            return null;
-          }
+        default: comp
+      };
+    });
+    lazyComp.preload = load;
+    return lazyComp;
+  }
+  //
 
-          return typeof opts.children === 'function' ? opts.children(params) : opts.children;
-        }
+  function useLinkProps(options) {
+    const router = useRouter();
+    const {
+      // custom props
+      type,
+      children,
+      target,
+      activeProps = () => ({
+        className: 'active'
+      }),
+      inactiveProps = () => ({}),
+      activeOptions,
+      disabled,
+      // fromCurrent,
+      hash,
+      search,
+      params,
+      to = '.',
+      preload,
+      preloadDelay,
+      replace,
+      // element props
+      style,
+      className,
+      onClick,
+      onFocus,
+      onMouseEnter,
+      onMouseLeave,
+      onTouchStart,
+      ...rest
+    } = options;
+    const linkInfo = router.buildLink(options);
+    if (linkInfo.type === 'external') {
+      const {
+        href
+      } = linkInfo;
+      return {
+        href
       };
+    }
+    const {
+      handleClick,
+      handleFocus,
+      handleEnter,
+      handleLeave,
+      handleTouchStart,
+      isActive,
+      next
+    } = linkInfo;
+    const handleReactClick = e => {
+      if (options.startTransition ?? true) {
+        (React__namespace.startTransition || (d => d))(() => {
+          handleClick(e);
+        });
+      }
+    };
+    const composeHandlers = handlers => e => {
+      if (e.persist) e.persist();
+      handlers.filter(Boolean).forEach(handler => {
+        if (e.defaultPrevented) return;
+        handler(e);
+      });
     };
 
-    const coreRouter = createRouter(_extends$2({}, opts, {
-      createRouter: router => {
-        const routerExt = {
-          useState: () => {
-            useRouterSubscription(router);
-            return router.state;
-          },
-          useMatch: (routeId, opts) => {
-            var _useMatches, _opts$strict;
-
-            useRouterSubscription(router);
-            invariant(routeId !== rootRouteId, "\"" + rootRouteId + "\" cannot be used with useMatch! Did you mean to useRoute(\"" + rootRouteId + "\")?");
-            const runtimeMatch = (_useMatches = useMatches()) == null ? void 0 : _useMatches[0];
-            const match = router.state.matches.find(d => d.routeId === routeId);
-
-            if ((_opts$strict = opts == null ? void 0 : opts.strict) != null ? _opts$strict : true) {
-              invariant(match, "Could not find an active match for \"" + routeId + "\"!");
-              invariant(runtimeMatch.routeId == (match == null ? void 0 : match.routeId), "useMatch('" + (match == null ? void 0 : match.routeId) + "') is being called in a component that is meant to render the '" + runtimeMatch.routeId + "' route. Did you mean to 'useMatch(" + (match == null ? void 0 : match.routeId) + ", { strict: false })' or 'useRoute(" + (match == null ? void 0 : match.routeId) + ")' instead?");
-            }
+    // Get the active props
+    const resolvedActiveProps = isActive ? functionalUpdate(activeProps, {}) ?? {} : {};
 
-            return match;
-          }
-        };
-        const routeExt = makeRouteExt(router.getRoute('/'), router);
-        Object.assign(router, routerExt, routeExt);
-      },
-      createRoute: _ref => {
-        let {
-          router,
-          route
-        } = _ref;
-        const routeExt = makeRouteExt(route, router);
-        Object.assign(route, routeExt);
+    // Get the inactive props
+    const resolvedInactiveProps = isActive ? {} : functionalUpdate(inactiveProps, {}) ?? {};
+    return {
+      ...resolvedActiveProps,
+      ...resolvedInactiveProps,
+      ...rest,
+      href: disabled ? undefined : next.href,
+      onClick: composeHandlers([onClick, handleReactClick]),
+      onFocus: composeHandlers([onFocus, handleFocus]),
+      onMouseEnter: composeHandlers([onMouseEnter, handleEnter]),
+      onMouseLeave: composeHandlers([onMouseLeave, handleLeave]),
+      onTouchStart: composeHandlers([onTouchStart, handleTouchStart]),
+      target,
+      style: {
+        ...style,
+        ...resolvedActiveProps.style,
+        ...resolvedInactiveProps.style
       },
-      loadComponent: async component => {
-        if (component.preload && typeof document !== 'undefined') {
-          component.preload(); // return await component.preload()
-        }
-
-        return component;
-      }
+      className: [className, resolvedActiveProps.className, resolvedInactiveProps.className].filter(Boolean).join(' ') || undefined,
+      ...(disabled ? {
+        role: 'link',
+        'aria-disabled': true
+      } : undefined),
+      ['data-status']: isActive ? 'active' : undefined
+    };
+  }
+  const Link = /*#__PURE__*/React__namespace.forwardRef((props, ref) => {
+    const linkProps = useLinkProps(props);
+    return /*#__PURE__*/React__namespace.createElement("a", _extends({
+      ref: ref
+    }, linkProps, {
+      children: typeof props.children === 'function' ? props.children({
+        isActive: linkProps['data-status'] === 'active'
+      }) : props.children
     }));
-    return coreRouter;
+  });
+  function Navigate(props) {
+    const router = useRouter();
+    React__namespace.useLayoutEffect(() => {
+      router.navigate(props);
+    }, []);
+    return null;
   }
-  function RouterProvider(_ref2) {
-    let {
-      children,
-      router
-    } = _ref2,
-        rest = _objectWithoutPropertiesLoose(_ref2, _excluded3);
-
+  const matchIdsContext = /*#__PURE__*/React__namespace.createContext(null);
+  const routerContext = /*#__PURE__*/React__namespace.createContext(null);
+  function useRouterState(opts) {
+    const router = useRouter();
+    return useStore(router.__store, opts?.select);
+  }
+  function RouterProvider({
+    router,
+    ...rest
+  }) {
     router.update(rest);
-    useRouterSubscription(router);
     React__namespace.useEffect(() => {
-      return router.mount();
+      let unsub;
+      React__namespace.startTransition(() => {
+        unsub = router.mount();
+      });
+      return unsub;
     }, [router]);
-    return /*#__PURE__*/React__namespace.createElement(routerContext.Provider, {
-      value: {
-        router
+    const Wrap = router.options.Wrap || React__namespace.Fragment;
+    return /*#__PURE__*/React__namespace.createElement(React__namespace.Suspense, {
+      fallback: null
+    }, /*#__PURE__*/React__namespace.createElement(Wrap, null, /*#__PURE__*/React__namespace.createElement(routerContext.Provider, {
+      value: router
+    }, /*#__PURE__*/React__namespace.createElement(Matches, null))));
+  }
+  function Matches() {
+    const router = useRouter();
+    const matchIds = useRouterState({
+      select: state => {
+        const hasPendingComponent = state.pendingMatches.some(d => {
+          const route = router.getRoute(d.routeId);
+          return !!route?.options.pendingComponent;
+        });
+        if (hasPendingComponent) {
+          return state.pendingMatchIds;
+        }
+        return state.matchIds;
+      }
+    });
+    return /*#__PURE__*/React__namespace.createElement(matchIdsContext.Provider, {
+      value: [undefined, ...matchIds]
+    }, /*#__PURE__*/React__namespace.createElement(CatchBoundary, {
+      errorComponent: ErrorComponent,
+      onCatch: () => {
+        warning(false, `Error in router! Consider setting an 'errorComponent' in your RootRoute! 👍`);
       }
-    }, /*#__PURE__*/React__namespace.createElement(MatchesProvider, {
-      value: router.state.matches
-    }, children != null ? children : /*#__PURE__*/React__namespace.createElement(Outlet, null)));
+    }, /*#__PURE__*/React__namespace.createElement(Outlet, null)));
   }
   function useRouter() {
     const value = React__namespace.useContext(routerContext);
-    warning(!value, 'useRouter must be used inside a <Router> component!');
-    useRouterSubscription(value.router);
-    return value.router;
+    warning(value, 'useRouter must be used inside a <Router> component!');
+    return value;
   }
-  function useMatches() {
-    return React__namespace.useContext(matchesContext);
+  function useMatches(opts) {
+    const matchIds = React__namespace.useContext(matchIdsContext);
+    return useRouterState({
+      select: state => {
+        const matches = state.matches.slice(state.matches.findIndex(d => d.id === matchIds[0]));
+        return opts?.select?.(matches) ?? matches;
+      }
+    });
   }
-  function Outlet() {
-    var _ref3, _match$__$pendingComp, _match$__$errorCompon;
-
+  function useMatch(opts) {
     const router = useRouter();
-    const matches = useMatches().slice(1);
-    const match = matches[0];
-    const defaultPending = React__namespace.useCallback(() => null, []);
-
-    if (!match) {
+    const nearestMatchId = React__namespace.useContext(matchIdsContext)[0];
+    const nearestMatchRouteId = router.getRouteMatch(nearestMatchId)?.routeId;
+    const matchRouteId = useRouterState({
+      select: state => {
+        const matches = state.matches;
+        const match = opts?.from ? matches.find(d => d.routeId === opts?.from) : matches.find(d => d.id === nearestMatchId);
+        return match.routeId;
+      }
+    });
+    if (opts?.strict ?? true) {
+      invariant(nearestMatchRouteId == matchRouteId, `useMatch("${matchRouteId}") is being called in a component that is meant to render the '${nearestMatchRouteId}' route. Did you mean to 'useMatch("${matchRouteId}", { strict: false })' or 'useRoute("${matchRouteId}")' instead?`);
+    }
+    const match = useRouterState({
+      select: state => {
+        const matches = state.matches;
+        const match = opts?.from ? matches.find(d => d.routeId === opts?.from) : matches.find(d => d.id === nearestMatchId);
+        invariant(match, `Could not find ${opts?.from ? `an active match from "${opts.from}"` : 'a nearest match!'}`);
+        return opts?.select?.(match) ?? match;
+      }
+    });
+    return match;
+  }
+  function useLoader(opts) {
+    return useMatch({
+      ...opts,
+      select: match => opts?.select?.(match.loaderData) ?? match.loaderData
+    });
+  }
+  function useRouterContext(opts) {
+    return useMatch({
+      ...opts,
+      select: match => opts?.select?.(match.context) ?? match.context
+    });
+  }
+  function useRouteContext(opts) {
+    return useMatch({
+      ...opts,
+      select: match => opts?.select?.(match.routeContext) ?? match.routeContext
+    });
+  }
+  function useSearch(opts) {
+    return useMatch({
+      ...opts,
+      select: match => {
+        return opts?.select?.(match.search) ?? match.search;
+      }
+    });
+  }
+  function useParams(opts) {
+    return useRouterState({
+      select: state => {
+        const params = last(state.matches)?.params;
+        return opts?.select?.(params) ?? params;
+      }
+    });
+  }
+  function useNavigate(defaultOpts) {
+    const router = useRouter();
+    return React__namespace.useCallback(opts => {
+      return router.navigate({
+        ...defaultOpts,
+        ...opts
+      });
+    }, []);
+  }
+  function useMatchRoute() {
+    const router = useRouter();
+    return React__namespace.useCallback(opts => {
+      const {
+        pending,
+        caseSensitive,
+        ...rest
+      } = opts;
+      return router.matchRoute(rest, {
+        pending,
+        caseSensitive
+      });
+    }, []);
+  }
+  function MatchRoute(props) {
+    const matchRoute = useMatchRoute();
+    const params = matchRoute(props);
+    if (typeof props.children === 'function') {
+      return props.children(params);
+    }
+    return !!params ? props.children : null;
+  }
+  function Outlet() {
+    const matchIds = React__namespace.useContext(matchIdsContext).slice(1);
+    if (!matchIds[0]) {
       return null;
     }
-
-    const PendingComponent = (_ref3 = (_match$__$pendingComp = match.__.pendingComponent) != null ? _match$__$pendingComp : router.options.defaultPendingComponent) != null ? _ref3 : defaultPending;
-    const errorComponent = (_match$__$errorCompon = match.__.errorComponent) != null ? _match$__$errorCompon : router.options.defaultErrorComponent;
-    return /*#__PURE__*/React__namespace.createElement(MatchesProvider, {
-      value: matches
-    }, /*#__PURE__*/React__namespace.createElement(React__namespace.Suspense, {
-      fallback: /*#__PURE__*/React__namespace.createElement(PendingComponent, null)
-    }, /*#__PURE__*/React__namespace.createElement(CatchBoundary, {
-      errorComponent: errorComponent
-    }, (() => {
-      if (match.status === 'error') {
-        throw match.error;
+    return /*#__PURE__*/React__namespace.createElement(Match, {
+      matchIds: matchIds
+    });
+  }
+  const defaultPending = () => null;
+  function Match({
+    matchIds
+  }) {
+    const router = useRouter();
+    const matchId = matchIds[0];
+    const routeId = router.getRouteMatch(matchId).routeId;
+    const route = router.getRoute(routeId);
+    const PendingComponent = route.options.pendingComponent ?? router.options.defaultPendingComponent ?? defaultPending;
+    const errorComponent = route.options.errorComponent ?? router.options.defaultErrorComponent ?? ErrorComponent;
+    const ResolvedSuspenseBoundary = route.options.wrapInSuspense ?? !route.isRoot ? React__namespace.Suspense : SafeFragment;
+    const ResolvedCatchBoundary = !!errorComponent ? CatchBoundary : SafeFragment;
+    return /*#__PURE__*/React__namespace.createElement(matchIdsContext.Provider, {
+      value: matchIds
+    }, /*#__PURE__*/React__namespace.createElement(ResolvedSuspenseBoundary, {
+      fallback: /*#__PURE__*/React__namespace.createElement(PendingComponent, {
+        useLoader: route.useLoader,
+        useMatch: route.useMatch,
+        useContext: route.useContext,
+        useRouteContext: route.useRouteContext,
+        useSearch: route.useSearch,
+        useParams: route.useParams
+      })
+    }, /*#__PURE__*/React__namespace.createElement(ResolvedCatchBoundary, {
+      key: route.id,
+      errorComponent: errorComponent,
+      onCatch: () => {
+        warning(false, `Error in route match: ${matchId}`);
       }
-
-      if (match.status === 'success') {
-        var _ref4, _ref5;
-
-        return /*#__PURE__*/React__namespace.createElement((_ref4 = (_ref5 = match.__.component) != null ? _ref5 : router.options.defaultComponent) != null ? _ref4 : Outlet);
+    }, /*#__PURE__*/React__namespace.createElement(MatchInner, {
+      matchId: matchId,
+      PendingComponent: PendingComponent
+    }))));
+  }
+  function MatchInner({
+    matchId,
+    PendingComponent
+  }) {
+    const router = useRouter();
+    const match = useRouterState({
+      select: d => {
+        const match = d.matchesById[matchId];
+        return pick(match, ['status', 'loadPromise', 'routeId', 'error']);
       }
-
-      if (match.__.loadPromise) {
-        console.log(match.matchId, 'suspend');
-        throw match.__.loadPromise;
+    });
+    const route = router.getRoute(match.routeId);
+    if (match.status === 'error') {
+      throw match.error;
+    }
+    if (match.status === 'pending') {
+      return /*#__PURE__*/React__namespace.createElement(PendingComponent, {
+        useLoader: route.useLoader,
+        useMatch: route.useMatch,
+        useContext: route.useContext,
+        useRouteContext: route.useRouteContext,
+        useSearch: route.useSearch,
+        useParams: route.useParams
+      });
+    }
+    if (match.status === 'success') {
+      let comp = route.options.component ?? router.options.defaultComponent;
+      if (comp) {
+        return /*#__PURE__*/React__namespace.createElement(comp, {
+          useLoader: route.useLoader,
+          useMatch: route.useMatch,
+          useContext: route.useContext,
+          useRouteContext: route.useRouteContext,
+          useSearch: route.useSearch,
+          useParams: route.useParams
+        });
       }
-
-      invariant(false, 'This should never happen!');
-    })())));
+      return /*#__PURE__*/React__namespace.createElement(Outlet, null);
+    }
+    invariant(false, 'Idle routeMatch status encountered during rendering! You should never see this. File an issue!');
+  }
+  function SafeFragment(props) {
+    return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, props.children);
+  }
+  function useInjectHtml() {
+    const router = useRouter();
+    return React__namespace.useCallback(html => {
+      router.injectHtml(html);
+    }, []);
+  }
+  function useDehydrate() {
+    const router = useRouter();
+    return React__namespace.useCallback(function dehydrate(key, data) {
+      return router.dehydrateData(key, data);
+    }, []);
+  }
+  function useHydrate() {
+    const router = useRouter();
+    return function hydrate(key) {
+      return router.hydrateData(key);
+    };
   }
 
-  class CatchBoundary extends React__namespace.Component {
-    constructor() {
-      super(...arguments);
-      this.state = {
-        error: false
-      };
-    }
+  // This is the messiest thing ever... I'm either seriously tired (likely) or
+  // there has to be a better way to reset error boundaries when the
+  // router's location key changes.
 
+  class CatchBoundary extends React__namespace.Component {
+    state = {
+      error: false,
+      info: undefined
+    };
     componentDidCatch(error, info) {
-      console.error(error);
+      this.props.onCatch(error, info);
       this.setState({
         error,
         info
       });
     }
-
     render() {
-      var _this$props$errorComp;
-
-      const errorComponent = (_this$props$errorComp = this.props.errorComponent) != null ? _this$props$errorComp : DefaultErrorBoundary;
-
-      if (this.state.error) {
-        return /*#__PURE__*/React__namespace.createElement(errorComponent, this.state);
+      return /*#__PURE__*/React__namespace.createElement(CatchBoundaryInner, _extends({}, this.props, {
+        errorState: this.state,
+        reset: () => this.setState({})
+      }));
+    }
+  }
+  function CatchBoundaryInner(props) {
+    const locationKey = useRouterState({
+      select: d => d.resolvedLocation.key
+    });
+    const [activeErrorState, setActiveErrorState] = React__namespace.useState(props.errorState);
+    const errorComponent = props.errorComponent ?? ErrorComponent;
+    const prevKeyRef = React__namespace.useRef('');
+    React__namespace.useEffect(() => {
+      if (activeErrorState) {
+        if (locationKey !== prevKeyRef.current) {
+          setActiveErrorState({});
+        }
       }
-
-      return this.props.children;
+      prevKeyRef.current = locationKey;
+    }, [activeErrorState, locationKey]);
+    React__namespace.useEffect(() => {
+      if (props.errorState.error) {
+        setActiveErrorState(props.errorState);
+      }
+      // props.reset()
+    }, [props.errorState.error]);
+    if (props.errorState.error && activeErrorState.error) {
+      return /*#__PURE__*/React__namespace.createElement(errorComponent, activeErrorState);
     }
-
+    return props.children;
   }
-
-  function DefaultErrorBoundary(_ref6) {
-    let {
-      error
-    } = _ref6;
+  function ErrorComponent({
+    error
+  }) {
+    const [show, setShow] = React__namespace.useState("development" !== 'production');
     return /*#__PURE__*/React__namespace.createElement("div", {
       style: {
         padding: '.5rem',
         maxWidth: '100%'
       }
+    }, /*#__PURE__*/React__namespace.createElement("div", {
+      style: {
+        display: 'flex',
+        alignItems: 'center',
+        gap: '.5rem'
+      }
     }, /*#__PURE__*/React__namespace.createElement("strong", {
       style: {
-        fontSize: '1.2rem'
+        fontSize: '1rem'
       }
-    }, "Something went wrong!"), /*#__PURE__*/React__namespace.createElement("div", {
+    }, "Something went wrong!"), /*#__PURE__*/React__namespace.createElement("button", {
       style: {
-        height: '.5rem'
+        appearance: 'none',
+        fontSize: '.6em',
+        border: '1px solid currentColor',
+        padding: '.1rem .2rem',
+        fontWeight: 'bold',
+        borderRadius: '.25rem'
+      },
+      onClick: () => setShow(d => !d)
+    }, show ? 'Hide Error' : 'Show Error')), /*#__PURE__*/React__namespace.createElement("div", {
+      style: {
+        height: '.25rem'
       }
-    }), /*#__PURE__*/React__namespace.createElement("div", null, /*#__PURE__*/React__namespace.createElement("pre", null, error.message ? /*#__PURE__*/React__namespace.createElement("code", {
+    }), show ? /*#__PURE__*/React__namespace.createElement("div", null, /*#__PURE__*/React__namespace.createElement("pre", {
       style: {
         fontSize: '.7em',
         border: '1px solid red',
         borderRadius: '.25rem',
-        padding: '.5rem',
-        color: 'red'
+        padding: '.3rem',
+        color: 'red',
+        overflow: 'auto'
       }
-    }, error.message) : null)));
+    }, error.message ? /*#__PURE__*/React__namespace.createElement("code", null, error.message) : null)) : null);
   }
-  function usePrompt(message, when) {
+  function useBlocker(message, condition = true) {
     const router = useRouter();
     React__namespace.useEffect(() => {
-      if (!when) return;
-      let unblock = router.history.block(transition => {
+      if (!condition) return;
+      let unblock = router.history.block((retry, cancel) => {
         if (window.confirm(message)) {
           unblock();
-          transition.retry();
-        } else {
-          router.location.pathname = window.location.pathname;
+          retry();
         }
       });
       return unblock;
-    }, [when, location, message]);
+    });
+  }
+  function Block({
+    message,
+    condition,
+    children
+  }) {
+    useBlocker(message, condition);
+    return children ?? null;
   }
-  function Prompt(_ref7) {
-    let {
-      message,
-      when,
-      children
-    } = _ref7;
-    usePrompt(message, when != null ? when : true);
-    return children != null ? children : null;
+  function shallow(objA, objB) {
+    if (Object.is(objA, objB)) {
+      return true;
+    }
+    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+      return false;
+    }
+    const keysA = Object.keys(objA);
+    if (keysA.length !== Object.keys(objB).length) {
+      return false;
+    }
+    for (let i = 0; i < keysA.length; i++) {
+      if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) {
+        return false;
+      }
+    }
+    return true;
   }
 
-  Object.defineProperty(exports, 'lazy', {
-    enumerable: true,
-    get: function () { return index.lazyWithPreload; }
-  });
-  exports.DefaultErrorBoundary = DefaultErrorBoundary;
-  exports.MatchesProvider = MatchesProvider;
+  exports.Block = Block;
+  exports.ErrorComponent = ErrorComponent;
+  exports.FileRoute = FileRoute;
+  exports.Link = Link;
+  exports.MatchRoute = MatchRoute;
+  exports.Navigate = Navigate;
   exports.Outlet = Outlet;
-  exports.Prompt = Prompt;
+  exports.PathParamError = PathParamError;
+  exports.RootRoute = RootRoute;
+  exports.Route = Route;
+  exports.Router = Router;
+  exports.RouterContext = RouterContext;
   exports.RouterProvider = RouterProvider;
+  exports.SearchParamError = SearchParamError;
   exports.cleanPath = cleanPath;
+  exports.componentTypes = componentTypes;
   exports.createBrowserHistory = createBrowserHistory;
   exports.createHashHistory = createHashHistory;
   exports.createMemoryHistory = createMemoryHistory;
-  exports.createReactRouter = createReactRouter;
-  exports.createRoute = createRoute;
-  exports.createRouteConfig = createRouteConfig;
-  exports.createRouteMatch = createRouteMatch;
-  exports.createRouter = createRouter;
   exports.decode = decode;
   exports.defaultParseSearch = defaultParseSearch;
   exports.defaultStringifySearch = defaultStringifySearch;
@@ -2865,23 +2564,46 @@
   exports.functionalUpdate = functionalUpdate;
   exports.interpolatePath = interpolatePath;
   exports.invariant = invariant;
+  exports.isPlainObject = isPlainObject;
+  exports.isRedirect = isRedirect;
   exports.joinPaths = joinPaths;
   exports.last = last;
+  exports.lazyFn = lazyFn;
+  exports.lazyRouteComponent = lazyRouteComponent;
   exports.matchByPath = matchByPath;
+  exports.matchIdsContext = matchIdsContext;
   exports.matchPathname = matchPathname;
   exports.parsePathname = parsePathname;
   exports.parseSearchWith = parseSearchWith;
+  exports.partialDeepEqual = partialDeepEqual;
   exports.pick = pick;
+  exports.redirect = redirect;
   exports.replaceEqualDeep = replaceEqualDeep;
   exports.resolvePath = resolvePath;
   exports.rootRouteId = rootRouteId;
+  exports.routerContext = routerContext;
+  exports.shallow = shallow;
   exports.stringifySearchWith = stringifySearchWith;
   exports.trimPath = trimPath;
   exports.trimPathLeft = trimPathLeft;
   exports.trimPathRight = trimPathRight;
+  exports.useBlocker = useBlocker;
+  exports.useDehydrate = useDehydrate;
+  exports.useHydrate = useHydrate;
+  exports.useInjectHtml = useInjectHtml;
+  exports.useLinkProps = useLinkProps;
+  exports.useLoader = useLoader;
+  exports.useMatch = useMatch;
+  exports.useMatchRoute = useMatchRoute;
   exports.useMatches = useMatches;
-  exports.usePrompt = usePrompt;
+  exports.useNavigate = useNavigate;
+  exports.useParams = useParams;
+  exports.useRouteContext = useRouteContext;
   exports.useRouter = useRouter;
+  exports.useRouterContext = useRouterContext;
+  exports.useRouterState = useRouterState;
+  exports.useSearch = useSearch;
+  exports.useStore = useStore;
   exports.warning = warning;
 
   Object.defineProperty(exports, '__esModule', { value: true });