@tanstack/router-core 0.0.1-beta.5 → 0.0.1-beta.50

package/build/umd/index.development.js

@@ -9,2153 +9,1364 @@
  * @license MIT
  */
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.RouterCore = {}));
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.RouterCore = {}));
 })(this, (function (exports) { 'use strict';
 
-  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];
-          }
+    var prefix = 'Invariant failed';
+    function invariant(condition, message) {
+        if (condition) {
+            return;
         }
-      }
-
-      return target;
-    };
-    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
-   */
-  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) {}
-    }
-  }
-
-  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 provided = typeof message === 'function' ? message() : message;
+        var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+        throw new Error(value);
     }
 
-    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'
-      })];
-    }
-
-    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.") ;
+    // 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 popStateEvent = 'popstate';
+    function createHistory(opts) {
+      let currentLocation = opts.getLocation();
+      let unsub = () => {};
+      let listeners = new Set();
+      const onUpdate = () => {
+        currentLocation = opts.getLocation();
+        listeners.forEach(listener => listener());
+      };
+      return {
+        get location() {
+          return currentLocation;
+        },
+        listen: cb => {
+          if (listeners.size === 0) {
+            unsub = opts.listener(onUpdate);
           }
-        } else {
-          applyTx(nextAction);
+          listeners.add(cb);
+          return () => {
+            listeners.delete(cb);
+            if (listeners.size === 0) {
+              unsub();
+            }
+          };
+        },
+        push: (path, state) => {
+          opts.pushState(path, state);
+          onUpdate();
+        },
+        replace: (path, state) => {
+          opts.replaceState(path, state);
+          onUpdate();
+        },
+        go: index => {
+          opts.go(index);
+          onUpdate();
+        },
+        back: () => {
+          opts.back();
+          onUpdate();
+        },
+        forward: () => {
+          opts.forward();
+          onUpdate();
         }
-      }
-    }
-
-    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
-      }), '');
-    }
-
-    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;
-      }
-
-      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 createBrowserHistory(opts) {
+      const getHref = opts?.getHref ?? (() => `${window.location.pathname}${window.location.hash}${window.location.search}`);
+      const createHref = opts?.createHref ?? (path => path);
+      const getLocation = () => parseLocation(getHref(), history.state);
+      return createHistory({
+        getLocation,
+        listener: onUpdate => {
+          window.addEventListener(popStateEvent, onUpdate);
+          return () => {
+            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)
+      });
     }
-
-    function allowTx(action, location, retry) {
-      return !blockers.length || (blockers.call({
-        action: action,
-        location: location,
-        retry: retry
-      }), false);
+    function createHashHistory() {
+      return createBrowserHistory({
+        getHref: () => window.location.hash.substring(1),
+        createHref: path => `#${path}`
+      });
     }
-
-    function applyTx(nextAction) {
-      action = nextAction;
-
-      var _getIndexAndLocation3 = getIndexAndLocation();
-
-      index = _getIndexAndLocation3[0];
-      location = _getIndexAndLocation3[1];
-      listeners.call({
-        action: action,
-        location: location
+    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: onUpdate => {
+          window.addEventListener(popStateEvent, onUpdate);
+          // We might need to handle the hashchange event in the future
+          // window.addEventListener(hashChangeEvent, onUpdate)
+          return () => {
+            window.removeEventListener(popStateEvent, onUpdate);
+          };
+        },
+        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)
       });
     }
-
-    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);
-      }
+    function parseLocation(href, state) {
+      let hashIndex = href.indexOf('#');
+      let searchIndex = href.indexOf('?');
+      const pathEnd = Math.min(hashIndex, searchIndex);
+      return {
+        href,
+        pathname: pathEnd > -1 ? href.substring(0, pathEnd) : href,
+        hash: hashIndex > -1 ? href.substring(hashIndex, searchIndex) : '',
+        search: searchIndex > -1 ? href.substring(searchIndex) : '',
+        state
+      };
     }
 
-    function replace(to, state) {
-      var nextAction = Action.Replace;
-      var nextLocation = getNextLocation(to, state);
-
-      function retry() {
-        replace(to, state);
-      }
-
-      if (allowTx(nextAction, nextLocation, retry)) {
-        var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index),
-            historyState = _getHistoryStateAndUr2[0],
-            url = _getHistoryStateAndUr2[1]; // TODO: Support forced reloading
-
-
-        globalHistory.replaceState(historyState, '', url);
-        applyTx(nextAction);
-      }
+    // Thanks co-pilot!
+    function createRandomKey() {
+      return (Math.random() + 1).toString(36).substring(7);
     }
 
-    function go(delta) {
-      globalHistory.go(delta);
+    function last(arr) {
+      return arr[arr.length - 1];
     }
-
-    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);
-          }
-        };
+    function warning(cond, message) {
+      if (cond) {
+        if (typeof console !== 'undefined') console.warn(message);
+        try {
+          throw new Error(message);
+        } catch {}
       }
-    };
-    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 createHashHistory(options) {
-    if (options === void 0) {
-      options = {};
+      return true;
     }
-
-    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 isFunction(d) {
+      return typeof d === 'function';
     }
-
-    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);
-        }
+    function functionalUpdate(updater, previous) {
+      if (isFunction(updater)) {
+        return updater(previous);
       }
+      return updater;
     }
-
-    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
-      }), '');
+    function pick(parent, keys) {
+      return keys.reduce((obj, key) => {
+        obj[key] = parent[key];
+        return obj;
+      }, {});
     }
 
-    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;
+    function joinPaths(paths) {
+      return cleanPath(paths.filter(Boolean).join('/'));
     }
-
-    function createHref(to) {
-      return getBaseHref() + '#' + (typeof to === 'string' ? to : createPath(to));
+    function cleanPath(path) {
+      // remove double slashes
+      return path.replace(/\/{2,}/g, '/');
     }
-
-    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()
-      }));
+    function trimPathLeft(path) {
+      return path === '/' ? path : path.replace(/^\/{1,}/, '');
     }
-
-    function getHistoryStateAndUrl(nextLocation, index) {
-      return [{
-        usr: nextLocation.state,
-        key: nextLocation.key,
-        idx: index
-      }, createHref(nextLocation)];
+    function trimPathRight(path) {
+      return path === '/' ? path : path.replace(/\/{1,}$/, '');
     }
-
-    function allowTx(action, location, retry) {
-      return !blockers.length || (blockers.call({
-        action: action,
-        location: location,
-        retry: retry
-      }), false);
+    function trimPath(path) {
+      return trimPathRight(trimPathLeft(path));
     }
-
-    function applyTx(nextAction) {
-      action = nextAction;
-
-      var _getIndexAndLocation7 = getIndexAndLocation();
-
-      index = _getIndexAndLocation7[0];
-      location = _getIndexAndLocation7[1];
-      listeners.call({
-        action: action,
-        location: location
+    function resolvePath(basepath, base, to) {
+      base = base.replace(new RegExp(`^${basepath}`), '/');
+      to = to.replace(new RegExp(`^${basepath}`), '/');
+      let baseSegments = parsePathname(base);
+      const toSegments = parsePathname(to);
+      toSegments.forEach((toSegment, index) => {
+        if (toSegment.value === '/') {
+          if (!index) {
+            // Leading slash
+            baseSegments = [toSegment];
+          } else if (index === toSegments.length - 1) {
+            // Trailing Slash
+            baseSegments.push(toSegment);
+          } else ;
+        } else if (toSegment.value === '..') {
+          // Extra trailing slash? pop it off
+          if (baseSegments.length > 1 && last(baseSegments)?.value === '/') {
+            baseSegments.pop();
+          }
+          baseSegments.pop();
+        } else if (toSegment.value === '.') {
+          return;
+        } else {
+          baseSegments.push(toSegment);
+        }
       });
+      const joined = joinPaths([basepath, ...baseSegments.map(d => d.value)]);
+      return cleanPath(joined);
     }
-
-    function push(to, state) {
-      var nextAction = Action.Push;
-      var nextLocation = getNextLocation(to, state);
-
-      function retry() {
-        push(to, state);
+    function parsePathname(pathname) {
+      if (!pathname) {
+        return [];
       }
-
-      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);
+      pathname = cleanPath(pathname);
+      const segments = [];
+      if (pathname.slice(0, 1) === '/') {
+        pathname = pathname.substring(1);
+        segments.push({
+          type: 'pathname',
+          value: '/'
+        });
       }
-
-      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);
+      if (!pathname) {
+        return segments;
       }
-    }
-
-    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);
+      // Remove empty segments and '.' segments
+      const split = pathname.split('/').filter(Boolean);
+      segments.push(...split.map(part => {
+        if (part.startsWith('*')) {
+          return {
+            type: 'wildcard',
+            value: part
+          };
         }
-
-        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);
-          }
+        if (part.charAt(0) === '$') {
+          return {
+            type: 'param',
+            value: part
+          };
+        }
+        return {
+          type: 'pathname',
+          value: part
         };
-      }
-    };
-    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);
+      if (pathname.slice(-1) === '/') {
+        pathname = pathname.substring(1);
+        segments.push({
+          type: 'pathname',
+          value: '/'
         });
       }
-    };
-  }
-
-  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;
+      return segments;
     }
-
-    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++;
+    function interpolatePath(path, params, leaveWildcard) {
+      const interpolatedPathSegments = parsePathname(path);
+      return joinPaths(interpolatedPathSegments.map(segment => {
+        if (segment.value === '*' && !leaveWildcard) {
+          return '';
         }
-      }
-
-      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 joinPaths(paths) {
-    return cleanPath(paths.filter(Boolean).join('/'));
-  }
-  function cleanPath(path) {
-    // remove double slashes
-    return path.replace(/\/{2,}/g, '/');
-  }
-  function trimPathLeft(path) {
-    return path === '/' ? path : path.replace(/^\/{1,}/, '');
-  }
-  function trimPathRight(path) {
-    return path === '/' ? path : path.replace(/\/{1,}$/, '');
-  }
-  function trimPath(path) {
-    return trimPathRight(trimPathLeft(path));
-  }
-  function resolvePath(basepath, base, to) {
-    base = base.replace(new RegExp("^" + basepath), '/');
-    to = to.replace(new RegExp("^" + basepath), '/');
-    let baseSegments = parsePathname(base);
-    const toSegments = parsePathname(to);
-    toSegments.forEach((toSegment, index) => {
-      if (toSegment.value === '/') {
-        if (!index) {
-          // Leading slash
-          baseSegments = [toSegment];
-        } else if (index === toSegments.length - 1) {
-          // Trailing Slash
-          baseSegments.push(toSegment);
-        } else ;
-      } else if (toSegment.value === '..') {
-        var _last;
-
-        // Extra trailing slash? pop it off
-        if (baseSegments.length > 1 && ((_last = last(baseSegments)) == null ? void 0 : _last.value) === '/') {
-          baseSegments.pop();
+        if (segment.type === 'param') {
+          return params[segment.value.substring(1)] ?? '';
         }
+        return segment.value;
+      }));
+    }
+    function matchPathname(basepath, currentPathname, matchLocation) {
+      const pathParams = matchByPath(basepath, currentPathname, matchLocation);
+      // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
 
-        baseSegments.pop();
-      } else if (toSegment.value === '.') {
+      if (matchLocation.to && !pathParams) {
         return;
-      } else {
-        baseSegments.push(toSegment);
       }
-    });
-    const joined = joinPaths([basepath, ...baseSegments.map(d => d.value)]);
-    return cleanPath(joined);
-  }
-  function parsePathname(pathname) {
-    if (!pathname) {
-      return [];
-    }
-
-    pathname = cleanPath(pathname);
-    const segments = [];
-
-    if (pathname.slice(0, 1) === '/') {
-      pathname = pathname.substring(1);
-      segments.push({
-        type: 'pathname',
-        value: '/'
-      });
+      return pathParams ?? {};
     }
-
-    if (!pathname) {
-      return segments;
-    } // Remove empty segments and '.' segments
-
-
-    const split = pathname.split('/').filter(Boolean);
-    segments.push(...split.map(part => {
-      if (part.startsWith('*')) {
-        return {
-          type: 'wildcard',
-          value: part
-        };
+    function matchByPath(basepath, from, matchLocation) {
+      if (!from.startsWith(basepath)) {
+        return undefined;
       }
-
-      if (part.charAt(0) === ':') {
-        return {
-          type: 'param',
-          value: part
-        };
-      }
-
-      return {
-        type: 'pathname',
-        value: part
-      };
-    }));
-
-    if (pathname.slice(-1) === '/') {
-      pathname = pathname.substring(1);
-      segments.push({
-        type: 'pathname',
-        value: '/'
-      });
-    }
-
-    return segments;
-  }
-  function interpolatePath(path, params, leaveWildcard) {
-    const interpolatedPathSegments = parsePathname(path);
-    return joinPaths(interpolatedPathSegments.map(segment => {
-      if (segment.value === '*' && !leaveWildcard) {
-        return '';
-      }
-
-      if (segment.type === 'param') {
-        var _segment$value$substr;
-
-        return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
-      }
-
-      return segment.value;
-    }));
-  }
-  function matchPathname(currentPathname, matchLocation) {
-    const pathParams = matchByPath(currentPathname, matchLocation); // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
-
-    if (matchLocation.to && !pathParams) {
-      return;
-    } // if (matchLocation.search && !searchMatched) {
-    //   return
-    // }
-
-
-    return pathParams != null ? pathParams : {};
-  }
-  function matchByPath(from, matchLocation) {
-    var _matchLocation$to;
-
-    const baseSegments = parsePathname(from);
-    const routeSegments = parsePathname("" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*'));
-    const params = {};
-
-    let isMatch = (() => {
-      for (let i = 0; i < Math.max(baseSegments.length, routeSegments.length); i++) {
-        const baseSegment = baseSegments[i];
-        const routeSegment = routeSegments[i];
-        const isLastRouteSegment = i === routeSegments.length - 1;
-        const isLastBaseSegment = i === baseSegments.length - 1;
-
-        if (routeSegment) {
-          if (routeSegment.type === 'wildcard') {
-            if (baseSegment != null && baseSegment.value) {
-              params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
-              return true;
-            }
-
-            return false;
-          }
-
-          if (routeSegment.type === 'pathname') {
-            if (routeSegment.value === '/' && !(baseSegment != null && baseSegment.value)) {
-              return true;
+      from = basepath != '/' ? from.substring(basepath.length) : from;
+      const baseSegments = parsePathname(from);
+      const to = `${matchLocation.to ?? '*'}`;
+      const routeSegments = parsePathname(to);
+      const params = {};
+      let isMatch = (() => {
+        for (let i = 0; i < Math.max(baseSegments.length, routeSegments.length); i++) {
+          const baseSegment = baseSegments[i];
+          const routeSegment = routeSegments[i];
+          const isLastRouteSegment = i === routeSegments.length - 1;
+          const isLastBaseSegment = i === baseSegments.length - 1;
+          if (routeSegment) {
+            if (routeSegment.type === 'wildcard') {
+              if (baseSegment?.value) {
+                params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
+                return true;
+              }
+              return false;
             }
-
-            if (baseSegment) {
-              if (matchLocation.caseSensitive) {
-                if (routeSegment.value !== baseSegment.value) {
+            if (routeSegment.type === 'pathname') {
+              if (routeSegment.value === '/' && !baseSegment?.value) {
+                return true;
+              }
+              if (baseSegment) {
+                if (matchLocation.caseSensitive) {
+                  if (routeSegment.value !== baseSegment.value) {
+                    return false;
+                  }
+                } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
                   return false;
                 }
-              } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
-                return false;
               }
             }
-          }
-
-          if (!baseSegment) {
-            return false;
-          }
-
-          if (routeSegment.type === 'param') {
-            if ((baseSegment == null ? void 0 : baseSegment.value) === '/') {
+            if (!baseSegment) {
               return false;
             }
-
-            if (!baseSegment.value.startsWith(':')) {
-              params[routeSegment.value.substring(1)] = baseSegment.value;
+            if (routeSegment.type === 'param') {
+              if (baseSegment?.value === '/') {
+                return false;
+              }
+              if (baseSegment.value.charAt(0) !== '$') {
+                params[routeSegment.value.substring(1)] = baseSegment.value;
+              }
             }
           }
+          if (isLastRouteSegment && !isLastBaseSegment) {
+            return !!matchLocation.fuzzy;
+          }
         }
+        return true;
+      })();
+      return isMatch ? params : undefined;
+    }
 
-        if (isLastRouteSegment && !isLastBaseSegment) {
-          return !!matchLocation.fuzzy;
-        }
-      }
-
-      return true;
-    })();
+    // @ts-nocheck
 
-    return isMatch ? params : undefined;
-  }
+    // 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.
 
-  // @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,
+    function encode(obj, pfx) {
+      var k,
         i,
         tmp,
         str = '';
-
-    for (k in obj) {
-      if ((tmp = obj[k]) !== void 0) {
-        if (Array.isArray(tmp)) {
-          for (i = 0; i < tmp.length; i++) {
+      for (k in obj) {
+        if ((tmp = obj[k]) !== void 0) {
+          if (Array.isArray(tmp)) {
+            for (i = 0; i < tmp.length; i++) {
+              str && (str += '&');
+              str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp[i]);
+            }
+          } else {
             str && (str += '&');
-            str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp[i]);
+            str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp);
           }
-        } else {
-          str && (str += '&');
-          str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp);
         }
       }
+      return (pfx || '') + str;
     }
-
-    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;
-  }
-
-  function decode(str) {
-    var tmp,
+    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;
+    }
+    function decode(str) {
+      var tmp,
         k,
         out = {},
         arr = str.split('&');
-
-    while (tmp = arr.shift()) {
-      tmp = tmp.split('=');
-      k = tmp.shift();
-
-      if (out[k] !== void 0) {
-        out[k] = [].concat(out[k], toValue(tmp.shift()));
-      } else {
-        out[k] = toValue(tmp.shift());
+      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;
     }
 
-    return out;
-  }
+    class Route {
+      constructor(routeConfig, options, originalIndex, parent, router) {
+        Object.assign(this, {
+          ...routeConfig,
+          originalIndex,
+          options,
+          getRouter: () => router,
+          childRoutes: undefined,
+          getParentRoute: () => parent
+        });
+        router.options.createRoute?.({
+          router,
+          route: this
+        });
+      }
+    }
 
-  function _extends() {
-    _extends = Object.assign ? Object.assign.bind() : function (target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
+    const rootRouteId = '__root__';
+    const createRouteConfig = (options = {}, children = [], isRoot = true, parentId, parentPath) => {
+      if (isRoot) {
+        options.path = rootRouteId;
+      }
 
-        for (var key in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key)) {
-            target[key] = source[key];
-          }
-        }
+      // Strip the root from parentIds
+      if (parentId === rootRouteId) {
+        parentId = '';
       }
+      let path = isRoot ? rootRouteId : options.path;
 
-      return target;
+      // If the path is anything other than an index path, trim it up
+      if (path && path !== '/') {
+        path = trimPath(path);
+      }
+      const routeId = path || options.id;
+      let id = joinPaths([parentId, routeId]);
+      if (path === rootRouteId) {
+        path = '/';
+      }
+      if (id !== rootRouteId) {
+        id = joinPaths(['/', id]);
+      }
+      const fullPath = id === rootRouteId ? '/' : trimPathRight(joinPaths([parentPath, path]));
+      return {
+        id: id,
+        routeId: routeId,
+        path: path,
+        fullPath: fullPath,
+        options: options,
+        children,
+        addChildren: children => createRouteConfig(options, children, false, parentId, parentPath),
+        createRoute: childOptions => createRouteConfig(childOptions, undefined, false, id, fullPath),
+        generate: () => {
+          invariant(false, `routeConfig.generate() is used by TanStack Router's file-based routing code generation and should not actually be called during runtime. `);
+        }
+      };
     };
-    return _extends.apply(this, arguments);
-  }
-
-  function createRoute(routeConfig, options, parent, router) {
-    const {
-      id,
-      routeId,
-      path: routePath,
-      fullPath
-    } = routeConfig;
-
-    const action = router.state.actions[id] || (() => {
-      router.state.actions[id] = {
-        pending: [],
-        submit: async (submission, actionOpts) => {
-          var _actionOpts$invalidat;
-
-          if (!route) {
-            return;
-          }
-
-          const invalidate = (_actionOpts$invalidat = actionOpts == null ? void 0 : actionOpts.invalidate) != null ? _actionOpts$invalidat : true;
-          const actionState = {
-            submittedAt: Date.now(),
-            status: 'pending',
-            submission
-          };
-          action.current = actionState;
-          action.latest = actionState;
-          action.pending.push(actionState);
-          router.state = _extends({}, router.state, {
-            currentAction: actionState,
-            latestAction: actionState
-          });
-          router.notify();
-
-          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();
-            }
+    function n(n){for(var r=arguments.length,t=Array(r>1?r-1:0),e=1;e<r;e++)t[e-1]=arguments[e];{var i=Y[n],o=i?"function"==typeof i?i.apply(null,t):i:"unknown error nr: "+n;throw Error("[Immer] "+o)}}function r(n){return !!n&&!!n[Q]}function t(n){var r;return !!n&&(function(n){if(!n||"object"!=typeof n)return !1;var r=Object.getPrototypeOf(n);if(null===r)return !0;var t=Object.hasOwnProperty.call(r,"constructor")&&r.constructor;return t===Object||"function"==typeof t&&Function.toString.call(t)===Z}(n)||Array.isArray(n)||!!n[L]||!!(null===(r=n.constructor)||void 0===r?void 0:r[L])||s(n)||v(n))}function i(n,r,t){void 0===t&&(t=!1),0===o(n)?(t?Object.keys:nn)(n).forEach((function(e){t&&"symbol"==typeof e||r(e,n[e],n);})):n.forEach((function(t,e){return r(e,t,n)}));}function o(n){var r=n[Q];return r?r.i>3?r.i-4:r.i:Array.isArray(n)?1:s(n)?2:v(n)?3:0}function u(n,r){return 2===o(n)?n.has(r):Object.prototype.hasOwnProperty.call(n,r)}function a(n,r){return 2===o(n)?n.get(r):n[r]}function f(n,r,t){var e=o(n);2===e?n.set(r,t):3===e?(n.delete(r),n.add(t)):n[r]=t;}function c(n,r){return n===r?0!==n||1/n==1/r:n!=n&&r!=r}function s(n){return X&&n instanceof Map}function v(n){return q&&n instanceof Set}function p(n){return n.o||n.t}function l(n){if(Array.isArray(n))return Array.prototype.slice.call(n);var r=rn(n);delete r[Q];for(var t=nn(r),e=0;e<t.length;e++){var i=t[e],o=r[i];!1===o.writable&&(o.writable=!0,o.configurable=!0),(o.get||o.set)&&(r[i]={configurable:!0,writable:!0,enumerable:o.enumerable,value:n[i]});}return Object.create(Object.getPrototypeOf(n),r)}function d(n,e){return void 0===e&&(e=!1),y(n)||r(n)||!t(n)?n:(o(n)>1&&(n.set=n.add=n.clear=n.delete=h),Object.freeze(n),e&&i(n,(function(n,r){return d(r,!0)}),!0),n)}function h(){n(2);}function y(n){return null==n||"object"!=typeof n||Object.isFrozen(n)}function b(r){var t=tn[r];return t||n(18,r),t}function _(){return U||n(0),U}function j(n,r){r&&(b("Patches"),n.u=[],n.s=[],n.v=r);}function O(n){g(n),n.p.forEach(S),n.p=null;}function g(n){n===U&&(U=n.l);}function w(n){return U={p:[],l:U,h:n,m:!0,_:0}}function S(n){var r=n[Q];0===r.i||1===r.i?r.j():r.O=!0;}function P(r,e){e._=e.p.length;var i=e.p[0],o=void 0!==r&&r!==i;return e.h.g||b("ES5").S(e,r,o),o?(i[Q].P&&(O(e),n(4)),t(r)&&(r=M(e,r),e.l||x(e,r)),e.u&&b("Patches").M(i[Q].t,r,e.u,e.s)):r=M(e,i,[]),O(e),e.u&&e.v(e.u,e.s),r!==H?r:void 0}function M(n,r,t){if(y(r))return r;var e=r[Q];if(!e)return i(r,(function(i,o){return A(n,e,r,i,o,t)}),!0),r;if(e.A!==n)return r;if(!e.P)return x(n,e.t,!0),e.t;if(!e.I){e.I=!0,e.A._--;var o=4===e.i||5===e.i?e.o=l(e.k):e.o;i(3===e.i?new Set(o):o,(function(r,i){return A(n,e,o,r,i,t)})),x(n,o,!1),t&&n.u&&b("Patches").R(e,t,n.u,n.s);}return e.o}function A(e,i,o,a,c,s){if(c===o&&n(5),r(c)){var v=M(e,c,s&&i&&3!==i.i&&!u(i.D,a)?s.concat(a):void 0);if(f(o,a,v),!r(v))return;e.m=!1;}if(t(c)&&!y(c)){if(!e.h.F&&e._<1)return;M(e,c),i&&i.A.l||x(e,c);}}function x(n,r,t){void 0===t&&(t=!1),n.h.F&&n.m&&d(r,t);}function z(n,r){var t=n[Q];return (t?p(t):n)[r]}function I(n,r){if(r in n)for(var t=Object.getPrototypeOf(n);t;){var e=Object.getOwnPropertyDescriptor(t,r);if(e)return e;t=Object.getPrototypeOf(t);}}function k(n){n.P||(n.P=!0,n.l&&k(n.l));}function E(n){n.o||(n.o=l(n.t));}function R(n,r,t){var e=s(r)?b("MapSet").N(r,t):v(r)?b("MapSet").T(r,t):n.g?function(n,r){var t=Array.isArray(n),e={i:t?1:0,A:r?r.A:_(),P:!1,I:!1,D:{},l:r,t:n,k:null,o:null,j:null,C:!1},i=e,o=en;t&&(i=[e],o=on);var u=Proxy.revocable(i,o),a=u.revoke,f=u.proxy;return e.k=f,e.j=a,f}(r,t):b("ES5").J(r,t);return (t?t.A:_()).p.push(e),e}function D(e){return r(e)||n(22,e),function n(r){if(!t(r))return r;var e,u=r[Q],c=o(r);if(u){if(!u.P&&(u.i<4||!b("ES5").K(u)))return u.t;u.I=!0,e=F(r,c),u.I=!1;}else e=F(r,c);return i(e,(function(r,t){u&&a(u.t,r)===t||f(e,r,n(t));})),3===c?new Set(e):e}(e)}function F(n,r){switch(r){case 2:return new Map(n);case 3:return Array.from(n)}return l(n)}var G,U,W="undefined"!=typeof Symbol&&"symbol"==typeof Symbol("x"),X="undefined"!=typeof Map,q="undefined"!=typeof Set,B="undefined"!=typeof Proxy&&void 0!==Proxy.revocable&&"undefined"!=typeof Reflect,H=W?Symbol.for("immer-nothing"):((G={})["immer-nothing"]=!0,G),L=W?Symbol.for("immer-draftable"):"__$immer_draftable",Q=W?Symbol.for("immer-state"):"__$immer_state",Y={0:"Illegal state",1:"Immer drafts cannot have computed properties",2:"This object has been frozen and should not be mutated",3:function(n){return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? "+n},4:"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",5:"Immer forbids circular references",6:"The first or second argument to `produce` must be a function",7:"The third argument to `produce` must be a function or undefined",8:"First argument to `createDraft` must be a plain object, an array, or an immerable object",9:"First argument to `finishDraft` must be a draft returned by `createDraft`",10:"The given draft is already finalized",11:"Object.defineProperty() cannot be used on an Immer draft",12:"Object.setPrototypeOf() cannot be used on an Immer draft",13:"Immer only supports deleting array indices",14:"Immer only supports setting array indices and the 'length' property",15:function(n){return "Cannot apply patch, path doesn't resolve: "+n},16:'Sets cannot have "replace" patches.',17:function(n){return "Unsupported patch operation: "+n},18:function(n){return "The plugin for '"+n+"' has not been loaded into Immer. To enable the plugin, import and call `enable"+n+"()` when initializing your application."},20:"Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available",21:function(n){return "produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '"+n+"'"},22:function(n){return "'current' expects a draft, got: "+n},23:function(n){return "'original' expects a draft, got: "+n},24:"Patching reserved attributes like __proto__, prototype and constructor is not allowed"},Z=""+Object.prototype.constructor,nn="undefined"!=typeof Reflect&&Reflect.ownKeys?Reflect.ownKeys:void 0!==Object.getOwnPropertySymbols?function(n){return Object.getOwnPropertyNames(n).concat(Object.getOwnPropertySymbols(n))}:Object.getOwnPropertyNames,rn=Object.getOwnPropertyDescriptors||function(n){var r={};return nn(n).forEach((function(t){r[t]=Object.getOwnPropertyDescriptor(n,t);})),r},tn={},en={get:function(n,r){if(r===Q)return n;var e=p(n);if(!u(e,r))return function(n,r,t){var e,i=I(r,t);return i?"value"in i?i.value:null===(e=i.get)||void 0===e?void 0:e.call(n.k):void 0}(n,e,r);var i=e[r];return n.I||!t(i)?i:i===z(n.t,r)?(E(n),n.o[r]=R(n.A.h,i,n)):i},has:function(n,r){return r in p(n)},ownKeys:function(n){return Reflect.ownKeys(p(n))},set:function(n,r,t){var e=I(p(n),r);if(null==e?void 0:e.set)return e.set.call(n.k,t),!0;if(!n.P){var i=z(p(n),r),o=null==i?void 0:i[Q];if(o&&o.t===t)return n.o[r]=t,n.D[r]=!1,!0;if(c(t,i)&&(void 0!==t||u(n.t,r)))return !0;E(n),k(n);}return n.o[r]===t&&"number"!=typeof t&&(void 0!==t||r in n.o)||(n.o[r]=t,n.D[r]=!0,!0)},deleteProperty:function(n,r){return void 0!==z(n.t,r)||r in n.t?(n.D[r]=!1,E(n),k(n)):delete n.D[r],n.o&&delete n.o[r],!0},getOwnPropertyDescriptor:function(n,r){var t=p(n),e=Reflect.getOwnPropertyDescriptor(t,r);return e?{writable:!0,configurable:1!==n.i||"length"!==r,enumerable:e.enumerable,value:t[r]}:e},defineProperty:function(){n(11);},getPrototypeOf:function(n){return Object.getPrototypeOf(n.t)},setPrototypeOf:function(){n(12);}},on={};i(en,(function(n,r){on[n]=function(){return arguments[0]=arguments[0][0],r.apply(this,arguments)};})),on.deleteProperty=function(r,t){return isNaN(parseInt(t))&&n(13),on.set.call(this,r,t,void 0)},on.set=function(r,t,e){return "length"!==t&&isNaN(parseInt(t))&&n(14),en.set.call(this,r[0],t,e,r[0])};var un=function(){function e(r){var e=this;this.g=B,this.F=!0,this.produce=function(r,i,o){if("function"==typeof r&&"function"!=typeof i){var u=i;i=r;var a=e;return function(n){var r=this;void 0===n&&(n=u);for(var t=arguments.length,e=Array(t>1?t-1:0),o=1;o<t;o++)e[o-1]=arguments[o];return a.produce(n,(function(n){var t;return (t=i).call.apply(t,[r,n].concat(e))}))}}var f;if("function"!=typeof i&&n(6),void 0!==o&&"function"!=typeof o&&n(7),t(r)){var c=w(e),s=R(e,r,void 0),v=!0;try{f=i(s),v=!1;}finally{v?O(c):g(c);}return "undefined"!=typeof Promise&&f instanceof Promise?f.then((function(n){return j(c,o),P(n,c)}),(function(n){throw O(c),n})):(j(c,o),P(f,c))}if(!r||"object"!=typeof r){if(void 0===(f=i(r))&&(f=r),f===H&&(f=void 0),e.F&&d(f,!0),o){var p=[],l=[];b("Patches").M(r,f,p,l),o(p,l);}return f}n(21,r);},this.produceWithPatches=function(n,r){if("function"==typeof n)return function(r){for(var t=arguments.length,i=Array(t>1?t-1:0),o=1;o<t;o++)i[o-1]=arguments[o];return e.produceWithPatches(r,(function(r){return n.apply(void 0,[r].concat(i))}))};var t,i,o=e.produce(n,r,(function(n,r){t=n,i=r;}));return "undefined"!=typeof Promise&&o instanceof Promise?o.then((function(n){return [n,t,i]})):[o,t,i]},"boolean"==typeof(null==r?void 0:r.useProxies)&&this.setUseProxies(r.useProxies),"boolean"==typeof(null==r?void 0:r.autoFreeze)&&this.setAutoFreeze(r.autoFreeze);}var i=e.prototype;return i.createDraft=function(e){t(e)||n(8),r(e)&&(e=D(e));var i=w(this),o=R(this,e,void 0);return o[Q].C=!0,g(i),o},i.finishDraft=function(r,t){var e=r&&r[Q];(e&&e.C||n(9),e.I&&n(10));var i=e.A;return j(i,t),P(void 0,i)},i.setAutoFreeze=function(n){this.F=n;},i.setUseProxies=function(r){r&&!B&&n(20),this.g=r;},i.applyPatches=function(n,t){var e;for(e=t.length-1;e>=0;e--){var i=t[e];if(0===i.path.length&&"replace"===i.op){n=i.value;break}}e>-1&&(t=t.slice(e+1));var o=b("Patches").$;return r(n)?o(n,t):this.produce(n,(function(n){return o(n,t)}))},e}(),an=new un,fn=an.produce;an.produceWithPatches.bind(an);var sn=an.setAutoFreeze.bind(an);an.setUseProxies.bind(an);an.applyPatches.bind(an);an.createDraft.bind(an);an.finishDraft.bind(an);
 
-            actionState.status = 'success';
-            return res;
-          } catch (err) {
-            console.error(err);
-            actionState.error = err;
-            actionState.status = 'error';
-          } finally {
-            action.pending = action.pending.filter(d => d !== actionState);
-            router.removeActionQueue.push({
-              action,
-              actionState
-            });
-            router.notify();
-          }
+    sn(false);
+    let queue = [];
+    let batching = false;
+    function flush() {
+      if (batching) return;
+      queue.forEach(cb => cb());
+      queue = [];
+    }
+    function createStore(initialState, debug) {
+      const listeners = new Set();
+      const store = {
+        state: initialState,
+        subscribe: listener => {
+          listeners.add(listener);
+          return () => listeners.delete(listener);
+        },
+        setState: updater => {
+          const previous = store.state;
+          store.state = fn(d => {
+            updater(d);
+          })(previous);
+          if (debug) console.log(store.state);
+          queue.push(() => listeners.forEach(listener => listener(store.state, previous)));
+          flush();
         }
       };
-      return router.state.actions[id];
-    })();
-
-    const loader = router.state.loaders[id] || (() => {
-      router.state.loaders[id] = {
-        pending: [],
-        fetch: async loaderContext => {
-          if (!route) {
-            return;
-          }
-
-          const loaderState = {
-            loadedAt: Date.now(),
-            loaderContext
-          };
-          loader.current = loaderState;
-          loader.latest = loaderState;
-          loader.pending.push(loaderState); // router.state = {
-          //   ...router.state,
-          //   currentAction: loaderState,
-          //   latestAction: loaderState,
-          // }
-
-          router.notify();
+      return store;
+    }
+    function batch(cb) {
+      batching = true;
+      cb();
+      batching = false;
+      flush();
+    }
 
-          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 })
+    // /**
+    //  * This function converts a store to an immutable value, which is
+    //  * more complex than you think. On first read, (when prev is undefined)
+    //  * every value must be recursively touched so tracking is "deep".
+    //  * Every object/array structure must also be cloned to
+    //  * have a new reference, otherwise it will get mutated by subsequent
+    //  * store updates.
+    //  *
+    //  * In the case that prev is supplied, we have to do deep comparisons
+    //  * between prev and next objects/array references and if they are deeply
+    //  * equal, we can return the prev version for referential equality.
+    //  */
+    // export function storeToImmutable<T>(prev: any, next: T): T {
+    //   const cache = new Map()
+
+    //   // Visit all nodes
+    //   // clone all next structures
+    //   // from bottom up, if prev === next, return prev
+
+    //   function recurse(prev: any, next: any) {
+    //     if (cache.has(next)) {
+    //       return cache.get(next)
+    //     }
+
+    //     const prevIsArray = Array.isArray(prev)
+    //     const nextIsArray = Array.isArray(next)
+    //     const prevIsObj = isPlainObject(prev)
+    //     const nextIsObj = isPlainObject(next)
+    //     const nextIsComplex = nextIsArray || nextIsObj
+
+    //     const isArray = prevIsArray && nextIsArray
+    //     const isObj = prevIsObj && nextIsObj
+
+    //     const isSameStructure = isArray || isObj
+
+    //     if (nextIsComplex) {
+    //       const prevSize = isArray
+    //         ? prev.length
+    //         : isObj
+    //         ? Object.keys(prev).length
+    //         : -1
+    //       const nextKeys = isArray ? next : Object.keys(next)
+    //       const nextSize = nextKeys.length
+
+    //       let changed = false
+    //       const copy: any = nextIsArray ? [] : {}
+
+    //       for (let i = 0; i < nextSize; i++) {
+    //         const key = isArray ? i : nextKeys[i]
+    //         const prevValue = isSameStructure ? prev[key] : undefined
+    //         const nextValue = next[key]
+
+    //         // Recurse the new value
+    //         try {
+    //           console.count(key)
+    //           copy[key] = recurse(prevValue, nextValue)
+    //         } catch {}
+
+    //         // If the new value has changed reference,
+    //         // mark the obj/array as changed
+    //         if (!changed && copy[key] !== prevValue) {
+    //           changed = true
+    //         }
+    //       }
+
+    //       // No items have changed!
+    //       // If something has changed, return a clone of the next obj/array
+    //       if (changed || prevSize !== nextSize) {
+    //         cache.set(next, copy)
+    //         return copy
+    //       }
+
+    //       // If they are exactly the same, return the prev obj/array
+    //       cache.set(next, prev)
+    //       return prev
+    //     }
+
+    //     cache.set(next, next)
+    //     return next
+    //   }
+
+    //   return recurse(prev, next)
+    // }
 
-            router.notify();
+    /**
+     * 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 router.state.loaders[id];
-    })();
-
-    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);
-      }
-    };
-    router.options.createRoute == null ? void 0 : router.options.createRoute({
-      router,
-      route
-    });
-    return route;
-  }
-  function cascadeLoaderData(matches) {
-    matches.forEach((match, index) => {
-      const parent = matches[index - 1];
-
-      if (parent) {
-        match.loaderData = replaceEqualDeep(match.loaderData, _extends({}, parent.loaderData, match.routeLoaderData));
+        return prevSize === nextSize && equalItems === prevSize ? prev : copy;
       }
-    });
-  }
-
-  const rootRouteId = '__root__';
-  const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId, parentPath) {
-    if (options === void 0) {
-      options = {};
-    }
-
-    if (isRoot === void 0) {
-      isRoot = true;
+      return next;
     }
 
-    if (isRoot) {
-      options.path = rootRouteId;
-    } // Strip the root from parentIds
+    // 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 (parentId === rootRouteId) {
-      parentId = '';
-    }
+      // If has modified prototype
+      const prot = ctor.prototype;
+      if (!hasObjectPrototype(prot)) {
+        return false;
+      }
 
-    let path = isRoot ? rootRouteId : options.path; // If the path is anything other than an index path, trim it up
+      // If constructor does not have an Object-specific method
+      if (!prot.hasOwnProperty('isPrototypeOf')) {
+        return false;
+      }
 
-    if (path && path !== '/') {
-      path = trimPath(path);
+      // Most likely a plain Object
+      return true;
     }
-
-    const routeId = path || options.id;
-    let id = joinPaths([parentId, routeId]);
-
-    if (path === rootRouteId) {
-      path = '/';
+    function hasObjectPrototype(o) {
+      return Object.prototype.toString.call(o) === '[object Object]';
     }
-
-    if (id !== rootRouteId) {
-      id = joinPaths(['/', id]);
+    function trackDeep(obj) {
+      const seen = new Set();
+      JSON.stringify(obj, (_, value) => {
+        if (typeof value === 'function') {
+          return undefined;
+        }
+        if (typeof value === 'object' && value !== null) {
+          if (seen.has(value)) return;
+          seen.add(value);
+        }
+        return value;
+      });
+      return obj;
     }
 
-    const fullPath = id === rootRouteId ? '/' : trimPathRight(joinPaths([parentPath, path]));
-    return {
-      id: id,
-      routeId: routeId,
-      path: path,
-      fullPath: fullPath,
-      options: options,
-      children,
-      createChildren: cb => createRouteConfig(options, cb(childOptions => createRouteConfig(childOptions, undefined, false, id, fullPath)), false, parentId, parentPath),
-      addChildren: children => createRouteConfig(options, children, false, parentId, parentPath),
-      createRoute: childOptions => createRouteConfig(childOptions, undefined, false, id, fullPath)
-    };
-  };
-
-  const elementTypes = ['element', 'errorElement', 'catchElement', 'pendingElement'];
-  function createRouteMatch(router, route, opts) {
-    const routeMatch = _extends({}, route, opts, {
-      router,
-      routeSearch: {},
-      search: {},
-      childMatches: [],
-      status: 'idle',
-      routeLoaderData: {},
-      loaderData: {},
-      isPending: false,
-      isFetching: false,
-      isInvalid: false,
-      invalidAt: Infinity,
-      getIsInvalid: () => {
-        const now = Date.now();
-        return routeMatch.isInvalid || routeMatch.invalidAt < now;
-      },
-      __: {
-        abortController: new AbortController(),
-        latestId: '',
-        resolve: () => {},
-        notify: () => {
-          routeMatch.__.resolve();
-
-          routeMatch.router.notify();
-        },
-        startPending: () => {
-          var _routeMatch$options$p, _routeMatch$options$p2;
-
-          const pendingMs = (_routeMatch$options$p = routeMatch.options.pendingMs) != null ? _routeMatch$options$p : router.options.defaultPendingMs;
-          const pendingMinMs = (_routeMatch$options$p2 = routeMatch.options.pendingMinMs) != null ? _routeMatch$options$p2 : router.options.defaultPendingMinMs;
-
-          if (routeMatch.__.pendingTimeout || routeMatch.status !== 'loading' || typeof pendingMs === 'undefined') {
-            return;
-          }
-
-          routeMatch.__.pendingTimeout = setTimeout(() => {
-            routeMatch.isPending = true;
-
-            routeMatch.__.resolve();
-
-            if (typeof pendingMinMs !== 'undefined') {
-              routeMatch.__.pendingMinPromise = new Promise(r => routeMatch.__.pendingMinTimeout = setTimeout(r, pendingMinMs));
-            }
-          }, pendingMs);
-        },
-        cancelPending: () => {
-          routeMatch.isPending = false;
-          clearTimeout(routeMatch.__.pendingTimeout);
-          clearTimeout(routeMatch.__.pendingMinTimeout);
-          delete routeMatch.__.pendingMinPromise;
-        },
-        // setParentMatch: (parentMatch?: RouteMatch) => {
-        //   routeMatch.parentMatch = parentMatch
-        // },
-        // addChildMatch: (childMatch: RouteMatch) => {
-        //   if (
-        //     routeMatch.childMatches.find((d) => d.matchId === childMatch.matchId)
-        //   ) {
-        //     return
-        //   }
-        //   routeMatch.childMatches.push(childMatch)
-        // },
-        validate: () => {
-          var _routeMatch$parentMat, _routeMatch$parentMat2;
-
-          // Validate the search params and stabilize them
-          const parentSearch = (_routeMatch$parentMat = (_routeMatch$parentMat2 = routeMatch.parentMatch) == null ? void 0 : _routeMatch$parentMat2.search) != null ? _routeMatch$parentMat : router.location.search;
-
-          try {
-            const prevSearch = routeMatch.routeSearch;
-            const validator = typeof routeMatch.options.validateSearch === 'object' ? routeMatch.options.validateSearch.parse : routeMatch.options.validateSearch;
-            let nextSearch = replaceEqualDeep(prevSearch, validator == null ? void 0 : validator(parentSearch)); // Invalidate route matches when search param stability changes
-
-            if (prevSearch !== nextSearch) {
-              routeMatch.isInvalid = true;
-            }
-
-            routeMatch.routeSearch = nextSearch;
-            routeMatch.search = replaceEqualDeep(parentSearch, _extends({}, parentSearch, nextSearch));
-          } catch (err) {
-            console.error(err);
-            const error = new Error('Invalid search params found', {
-              cause: err
-            });
-            error.code = 'INVALID_SEARCH_PARAMS';
-            routeMatch.status = 'error';
-            routeMatch.error = error; // Do not proceed with loading the route
-
-            return;
-          }
+    const componentTypes = ['component', 'errorComponent', 'pendingComponent'];
+    class RouteMatch {
+      abortController = new AbortController();
+      #latestId = '';
+      #resolve = () => {};
+      onLoaderDataListeners = new Set();
+      constructor(router, route, opts) {
+        Object.assign(this, {
+          route,
+          router,
+          matchId: opts.matchId,
+          pathname: opts.pathname,
+          params: opts.params,
+          store: createStore({
+            routeSearch: {},
+            search: {},
+            status: 'idle',
+            routeLoaderData: {},
+            loaderData: {},
+            isFetching: false,
+            invalid: false,
+            invalidAt: Infinity
+          })
+        });
+        if (!this.__hasLoaders()) {
+          this.store.setState(s => s.status = 'success');
         }
-      },
-      cancel: () => {
-        var _routeMatch$__$abortC;
-
-        (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
-
-        routeMatch.__.cancelPending();
-      },
-      invalidate: () => {
-        routeMatch.isInvalid = true;
-      },
-      hasLoaders: () => {
-        return !!(route.options.loader || elementTypes.some(d => typeof route.options[d] === 'function'));
-      },
-      load: async loaderOpts => {
+      }
+      #setLoaderData = loaderData => {
+        batch(() => {
+          this.store.setState(s => {
+            s.routeLoaderData = loaderData;
+          });
+          this.#updateLoaderData();
+        });
+      };
+      cancel = () => {
+        this.abortController?.abort();
+      };
+      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
+        const minMaxAge = loaderOpts?.preload ? Math.max(loaderOpts?.maxAge, loaderOpts?.gcMaxAge) : 0;
 
-        if (loaderOpts != null && loaderOpts.preload && minMaxAge > 0) {
+        // If this is a preload, add it to the preload cache
+        if (loaderOpts?.preload && minMaxAge > 0) {
           // If the match is currently active, don't preload it
-          if (router.state.matches.find(d => d.matchId === routeMatch.matchId)) {
+          if (this.router.store.state.currentMatches.find(d => d.id === this.id)) {
             return;
           }
+          this.router.store.setState(s => {
+            s.matchCache[this.id] = {
+              gc: now + loaderOpts.gcMaxAge,
+              match: this
+            };
+          });
+        }
 
-          router.matchCache[routeMatch.matchId] = {
-            gc: now + loaderOpts.gcMaxAge,
-            match: routeMatch
-          };
-        } // If the match is invalid, errored or idle, trigger it to load
-
-
-        if (routeMatch.status === 'success' && routeMatch.getIsInvalid() || routeMatch.status === 'error' || routeMatch.status === 'idle') {
-          const maxAge = loaderOpts != null && loaderOpts.preload ? loaderOpts == null ? void 0 : loaderOpts.maxAge : undefined;
-          routeMatch.fetch({
+        // If the match is invalid, errored or idle, trigger it to load
+        if (this.store.state.status === 'success' && this.getIsInvalid() || this.store.state.status === 'error' || this.store.state.status === 'idle') {
+          const maxAge = loaderOpts?.preload ? loaderOpts?.maxAge : undefined;
+          await this.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
+      };
+      fetch = async opts => {
+        this.__loadPromise = new Promise(async resolve => {
+          const loadId = '' + Date.now() + Math.random();
+          this.#latestId = loadId;
+          const checkLatest = () => loadId !== this.#latestId ? this.__loadPromise?.then(() => resolve()) : undefined;
+          let latestPromise;
+          batch(() => {
+            // If the match was in an error state, set it
+            // to a loading state again. Otherwise, keep it
+            // as loading or resolved
+            if (this.store.state.status === 'idle') {
+              this.store.setState(s => s.status = 'loading');
+            }
 
+            // We started loading the route, so it's no longer invalid
+            this.store.setState(s => s.invalid = false);
+          });
 
-        routeMatch.isInvalid = false;
-        routeMatch.__.loadPromise = new Promise(async resolve => {
           // We are now fetching, even if it's in the background of a
           // resolved state
-          routeMatch.isFetching = true;
-          routeMatch.__.resolve = resolve;
-
-          const loaderPromise = (async () => {
-            // Load the elements and data in parallel
-            routeMatch.__.elementsPromise = (async () => {
-              // then run all element and data loaders in parallel
-              // For each element type, potentially load it asynchronously
-              await Promise.all(elementTypes.map(async type => {
-                const routeElement = routeMatch.options[type];
-
-                if (routeMatch.__[type]) {
-                  return;
-                }
-
-                routeMatch.__[type] = await router.options.createElement(routeElement);
-              }));
-            })();
-
-            routeMatch.__.dataPromise = Promise.resolve().then(async () => {
-              try {
-                var _ref, _ref2, _opts$maxAge;
-
-                if (routeMatch.options.loader) {
-                  const data = await routeMatch.options.loader({
-                    params: routeMatch.params,
-                    search: routeMatch.routeSearch,
-                    signal: routeMatch.__.abortController.signal
-                  });
-
-                  if (id !== routeMatch.__.latestId) {
-                    return routeMatch.__.loaderPromise;
-                  }
-
-                  routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
-                }
-
-                routeMatch.error = undefined;
-                routeMatch.status = 'success';
-                routeMatch.updatedAt = Date.now();
-                routeMatch.invalidAt = routeMatch.updatedAt + ((_ref = (_ref2 = (_opts$maxAge = opts == null ? void 0 : opts.maxAge) != null ? _opts$maxAge : routeMatch.options.loaderMaxAge) != null ? _ref2 : router.options.defaultLoaderMaxAge) != null ? _ref : 0);
-              } catch (err) {
-                if (id !== routeMatch.__.latestId) {
-                  return routeMatch.__.loaderPromise;
-                }
-
-                {
-                  console.error(err);
-                }
-
-                routeMatch.error = err;
-                routeMatch.status = 'error';
-                routeMatch.updatedAt = Date.now();
+          this.store.setState(s => s.isFetching = true);
+          this.#resolve = resolve;
+          const 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 => {
+              const component = this.route.options[type];
+              if (this[type]?.preload) {
+                this[type] = await this.router.options.loadComponent(component);
               }
-            });
-
+            }));
+          })();
+          const dataPromise = Promise.resolve().then(async () => {
             try {
-              await Promise.all([routeMatch.__.elementsPromise, routeMatch.__.dataPromise]);
-
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
+              if (this.route.options.loader) {
+                const data = await this.router.loadMatchData(this);
+                if (latestPromise = checkLatest()) return latestPromise;
+                this.#setLoaderData(data);
               }
-
-              if (routeMatch.__.pendingMinPromise) {
-                await routeMatch.__.pendingMinPromise;
-                delete routeMatch.__.pendingMinPromise;
-              }
-            } finally {
-              if (id !== routeMatch.__.latestId) {
-                return routeMatch.__.loaderPromise;
+              this.store.setState(s => {
+                s.error = undefined;
+                s.status = 'success';
+                s.updatedAt = Date.now();
+                s.invalidAt = s.updatedAt + (opts?.maxAge ?? this.route.options.loaderMaxAge ?? this.router.options.defaultLoaderMaxAge ?? 0);
+              });
+              return this.store.state.routeLoaderData;
+            } catch (err) {
+              if (latestPromise = checkLatest()) return latestPromise;
+              {
+                console.error(err);
               }
-
-              routeMatch.__.cancelPending();
-
-              routeMatch.isPending = false;
-              routeMatch.isFetching = false;
-
-              routeMatch.__.notify();
+              this.store.setState(s => {
+                s.error = err;
+                s.status = 'error';
+                s.updatedAt = Date.now();
+              });
+              throw err;
             }
-          })();
-
-          routeMatch.__.loaderPromise = loaderPromise;
-          await loaderPromise;
-
-          if (id !== routeMatch.__.latestId) {
-            return routeMatch.__.loaderPromise;
+          });
+          const after = async () => {
+            if (latestPromise = checkLatest()) return latestPromise;
+            this.store.setState(s => s.isFetching = false);
+            this.#resolve();
+            delete this.__loadPromise;
+          };
+          try {
+            await Promise.all([componentsPromise, dataPromise.catch(() => {})]);
+            after();
+          } catch {
+            after();
           }
-
-          delete routeMatch.__.loaderPromise;
         });
-        return await routeMatch.__.loadPromise;
-      }
-    });
-
-    if (!routeMatch.hasLoaders()) {
-      routeMatch.status = 'success';
-    }
-
-    return routeMatch;
-  }
-
-  const defaultParseSearch = parseSearchWith(JSON.parse);
-  const defaultStringifySearch = stringifySearchWith(JSON.stringify);
-  function parseSearchWith(parser) {
-    return searchStr => {
-      if (searchStr.substring(0, 1) === '?') {
-        searchStr = searchStr.substring(1);
-      }
+        return this.__loadPromise;
+      };
+      invalidate = async () => {
+        this.store.setState(s => s.invalid = true);
+        if (this.router.store.state.currentMatches.find(d => d.id === this.id)) {
+          await this.load();
+        }
+      };
+      __hasLoaders = () => {
+        return !!(this.route.options.loader || componentTypes.some(d => this.route.options[d]?.preload));
+      };
+      getIsInvalid = () => {
+        const now = Date.now();
+        return this.store.state.invalid || this.store.state.invalidAt < now;
+      };
+      #updateLoaderData = () => {
+        this.store.setState(s => {
+          s.loaderData = replaceEqualDeep(s.loaderData, {
+            ...this.parentMatch?.store.state.loaderData,
+            ...s.routeLoaderData
+          });
+        });
+        this.onLoaderDataListeners.forEach(listener => listener());
+      };
+      __setParentMatch = parentMatch => {
+        if (!this.parentMatch && parentMatch) {
+          this.parentMatch = parentMatch;
+          this.parentMatch.__onLoaderData(() => {
+            this.#updateLoaderData();
+          });
+        }
+      };
+      __onLoaderData = listener => {
+        this.onLoaderDataListeners.add(listener);
+        // return () => this.onLoaderDataListeners.delete(listener)
+      };
 
-      let query = decode(searchStr); // Try to parse any query params that might be json
+      __validate = () => {
+        // Validate the search params and stabilize them
+        const parentSearch = this.parentMatch?.store.state.search ?? this.router.store.state.latestLocation.search;
+        try {
+          const prevSearch = this.store.state.routeSearch;
+          const validator = typeof this.route.options.validateSearch === 'object' ? this.route.options.validateSearch.parse : this.route.options.validateSearch;
+          let nextSearch = validator?.(parentSearch) ?? {};
+          batch(() => {
+            // Invalidate route matches when search param stability changes
+            if (prevSearch !== nextSearch) {
+              this.store.setState(s => s.invalid = true);
+            }
+            this.store.setState(s => {
+              s.routeSearch = nextSearch;
+              s.search = {
+                ...parentSearch,
+                ...nextSearch
+              };
+            });
+          });
+          componentTypes.map(async type => {
+            const component = this.route.options[type];
+            if (typeof this[type] !== 'function') {
+              this[type] = component;
+            }
+          });
+        } catch (err) {
+          console.error(err);
+          const error = new Error('Invalid search params found', {
+            cause: err
+          });
+          error.code = 'INVALID_SEARCH_PARAMS';
+          this.store.setState(s => {
+            s.status = 'error';
+            s.error = error;
+          });
 
-      for (let key in query) {
-        const value = query[key];
+          // Do not proceed with loading the route
+          return;
+        }
+      };
+    }
 
-        if (typeof value === 'string') {
-          try {
-            query[key] = parser(value);
-          } catch (err) {//
-          }
+    const defaultParseSearch = parseSearchWith(JSON.parse);
+    const defaultStringifySearch = stringifySearchWith(JSON.stringify);
+    function parseSearchWith(parser) {
+      return searchStr => {
+        if (searchStr.substring(0, 1) === '?') {
+          searchStr = searchStr.substring(1);
         }
-      }
+        let query = decode(searchStr);
 
-      return query;
-    };
-  }
-  function stringifySearchWith(stringify) {
-    return search => {
-      search = _extends({}, search);
-
-      if (search) {
-        Object.keys(search).forEach(key => {
-          const val = search[key];
-
-          if (typeof val === 'undefined' || val === undefined) {
-            delete search[key];
-          } else if (val && typeof val === 'object' && val !== null) {
+        // Try to parse any query params that might be json
+        for (let key in query) {
+          const value = query[key];
+          if (typeof value === 'string') {
             try {
-              search[key] = stringify(val);
-            } catch (err) {// silent
+              query[key] = parser(value);
+            } catch (err) {
+              //
             }
           }
-        });
-      }
-
-      const searchStr = encode(search).toString();
-      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 createRouter(userOptions) {
-    var _userOptions$stringif, _userOptions$parseSea;
-
-    const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
-
-    const originalOptions = _extends({
-      defaultLoaderGcMaxAge: 5 * 60 * 1000,
-      defaultLoaderMaxAge: 0,
-      defaultPreloadMaxAge: 2000,
-      defaultPreloadDelay: 50
-    }, userOptions, {
-      stringifySearch: (_userOptions$stringif = userOptions == null ? void 0 : userOptions.stringifySearch) != null ? _userOptions$stringif : defaultStringifySearch,
-      parseSearch: (_userOptions$parseSea = userOptions == null ? void 0 : userOptions.parseSearch) != null ? _userOptions$parseSea : defaultParseSearch
-    });
-
-    let router = {
-      history,
-      options: originalOptions,
-      listeners: [],
-      removeActionQueue: [],
-      // Resolved after construction
-      basepath: '',
-      routeTree: undefined,
-      routesById: {},
-      location: undefined,
-      allRouteInfo: undefined,
-      //
-      navigationPromise: Promise.resolve(),
-      resolveNavigation: () => {},
-      matchCache: {},
-      state: {
-        status: 'idle',
-        location: null,
-        matches: [],
-        actions: {},
-        loaders: {},
-        lastUpdated: Date.now(),
-        isFetching: false,
-        isPreloading: false
-      },
-      startedLoadingAt: Date.now(),
-      subscribe: listener => {
-        router.listeners.push(listener);
-        return () => {
-          router.listeners = router.listeners.filter(x => x !== listener);
-        };
-      },
-      getRoute: id => {
-        return router.routesById[id];
-      },
-      notify: () => {
-        router.state = _extends({}, router.state, {
-          isFetching: router.state.status === 'loading' || router.state.matches.some(d => d.isFetching),
-          isPreloading: Object.values(router.matchCache).some(d => d.match.isFetching && !router.state.matches.find(dd => dd.matchId === d.match.matchId))
-        });
-        cascadeLoaderData(router.state.matches);
-        router.listeners.forEach(listener => listener(router));
-      },
-      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);
         }
-
-        router.loadLocation();
-        const unsub = router.history.listen(event => {
-          console.log(event.location);
-          router.loadLocation(router.__.parseLocation(event.location, router.location));
-        }); // addEventListener does not exist in React Native, but window does
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-
-        if (!isServer && window.addEventListener) {
-          // Listen to visibillitychange and focus
-          window.addEventListener('visibilitychange', router.onFocus, false);
-          window.addEventListener('focus', router.onFocus, false);
+        return query;
+      };
+    }
+    function stringifySearchWith(stringify) {
+      return 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
+              }
+            }
+          });
         }
+        const searchStr = encode(search).toString();
+        return searchStr ? `?${searchStr}` : '';
+      };
+    }
 
-        return () => {
-          unsub(); // Be sure to unsubscribe if a new handler is set
-
-          window.removeEventListener('visibilitychange', router.onFocus);
-          window.removeEventListener('focus', router.onFocus);
+    const defaultFetchServerDataFn = async ({
+      router,
+      routeMatch
+    }) => {
+      const next = router.buildNext({
+        to: '.',
+        search: d => ({
+          ...(d ?? {}),
+          __data: {
+            matchId: routeMatch.id
+          }
+        })
+      });
+      const res = await fetch(next.href, {
+        method: 'GET',
+        signal: routeMatch.abortController.signal
+      });
+      if (res.ok) {
+        return res.json();
+      }
+      throw new Error('Failed to fetch match data');
+    };
+    class Router {
+      // __location: Location<TAllRouteInfo['fullSearchSchema']>
+
+      startedLoadingAt = Date.now();
+      resolveNavigation = () => {};
+      constructor(options) {
+        this.options = {
+          defaultLoaderGcMaxAge: 5 * 60 * 1000,
+          defaultLoaderMaxAge: 0,
+          defaultPreloadMaxAge: 2000,
+          defaultPreloadDelay: 50,
+          context: undefined,
+          ...options,
+          stringifySearch: options?.stringifySearch ?? defaultStringifySearch,
+          parseSearch: options?.parseSearch ?? defaultParseSearch,
+          fetchServerDataFn: options?.fetchServerDataFn ?? defaultFetchServerDataFn
         };
-      },
-      onFocus: () => {
-        router.loadLocation();
-      },
-      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;
+        this.history = this.options?.history ?? createBrowserHistory();
+        this.store = createStore(getInitialRouterState());
+        this.basepath = '';
+        this.update(options);
+
+        // Allow frameworks to hook into the router creation
+        this.options.createRouter?.(this);
+      }
+      reset = () => {
+        this.store.setState(s => Object.assign(s, getInitialRouterState()));
+      };
+      mount = () => {
+        // Mount only does anything on the client
+        if (!isServer) {
+          // If the router matches are empty, load the matches
+          if (!this.store.state.currentMatches.length) {
+            this.load();
+          }
+          const unsubHistory = this.history.listen(() => {
+            this.load(this.#parseLocation(this.store.state.latestLocation));
+          });
+          const visibilityChangeEvent = 'visibilitychange';
+          const focusEvent = 'focus';
+
+          // addEventListener does not exist in React Native, but window does
+          // In the future, we might need to invert control here for more adapters
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          if (window.addEventListener) {
+            // Listen to visibilitychange and focus
+            window.addEventListener(visibilityChangeEvent, this.#onFocus, false);
+            window.addEventListener(focusEvent, this.#onFocus, false);
           }
+          return () => {
+            unsubHistory();
+            if (window.removeEventListener) {
+              // Be sure to unsubscribe if a new handler is set
 
-          router.location = router.__.parseLocation(router.history.location);
-          router.state.location = router.location;
+              window.removeEventListener(visibilityChangeEvent, this.#onFocus);
+              window.removeEventListener(focusEvent, this.#onFocus);
+            }
+          };
         }
-
-        Object.assign(router.options, opts);
+        return () => {};
+      };
+      update = opts => {
+        if (!this.store.state.latestLocation) {
+          this.store.setState(s => {
+            s.latestLocation = this.#parseLocation();
+            s.currentLocation = s.latestLocation;
+          });
+        }
+        Object.assign(this.options, opts);
         const {
           basepath,
           routeConfig
-        } = router.options;
-        router.basepath = cleanPath("/" + (basepath != null ? basepath : ''));
-
+        } = this.options;
+        this.basepath = `/${trimPath(basepath ?? '') ?? ''}`;
         if (routeConfig) {
-          router.routesById = {};
-          router.routeTree = router.__.buildRouteTree(routeConfig);
+          this.routesById = {};
+          this.routeTree = this.#buildRouteTree(routeConfig);
         }
-
-        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 => {
+        return this;
+      };
+      buildNext = opts => {
+        const next = this.#buildLocation(opts);
+        const matches = this.matchRoutes(next.pathname);
+        const __preSearchFilters = matches.map(match => match.route.options.preSearchFilters ?? []).flat().filter(Boolean);
+        const __postSearchFilters = matches.map(match => match.route.options.postSearchFilters ?? []).flat().filter(Boolean);
+        return this.#buildLocation({
+          ...opts,
+          __preSearchFilters,
+          __postSearchFilters
+        });
+      };
+      cancelMatches = () => {
+        [...this.store.state.currentMatches, ...(this.store.state.pendingMatches || [])].forEach(match => {
           match.cancel();
         });
-      },
-      loadLocation: async next => {
-        const id = Math.random();
-        router.startedLoadingAt = id;
-
-        if (next) {
-          // Ingest the new location
-          router.location = next;
-        } // Clear out old actions
-
-
-        router.removeActionQueue.forEach(_ref => {
-          let {
-            action,
-            actionState
-          } = _ref;
-
-          if (router.state.currentAction === actionState) {
-            router.state.currentAction = undefined;
-          }
-
-          if (action.current === actionState) {
-            action.current = undefined;
+      };
+      load = async next => {
+        let now = Date.now();
+        const startedAt = now;
+        this.startedLoadingAt = startedAt;
+
+        // Cancel any pending matches
+        this.cancelMatches();
+        let matches;
+        batch(() => {
+          if (next) {
+            // Ingest the new location
+            this.store.setState(s => {
+              s.latestLocation = next;
+            });
           }
-        });
-        router.removeActionQueue = []; // Cancel any pending matches
-
-        router.cancelMatches(); // Match the routes
-
-        const matches = router.matchRoutes(router.location.pathname, {
-          strictParseParams: true
-        });
-        router.state = _extends({}, router.state, {
-          pending: {
-            matches: matches,
-            location: router.location
-          },
-          status: 'loading'
-        });
-        router.notify(); // Load the matches
 
-        await router.loadMatches(matches, {
-          withPending: true
+          // Match the routes
+          matches = this.matchRoutes(this.store.state.latestLocation.pathname, {
+            strictParseParams: true
+          });
+          this.store.setState(s => {
+            s.status = 'loading';
+            s.pendingMatches = matches;
+            s.pendingLocation = this.store.state.latestLocation;
+          });
         });
 
-        if (router.startedLoadingAt !== id) {
-          // Ignore side-effects of match loading
-          return router.navigationPromise;
+        // Load the matches
+        try {
+          await this.loadMatches(matches);
+        } catch (err) {
+          console.warn(err);
+          invariant(false, 'Matches failed to load due to error above ☝️. Navigation cancelled!');
         }
-
-        const previousMatches = router.state.matches;
+        if (this.startedLoadingAt !== startedAt) {
+          // Ignore side-effects of outdated side-effects
+          return this.navigationPromise;
+        }
+        const previousMatches = this.store.state.currentMatches;
         const exiting = [],
-              staying = [];
+          staying = [];
         previousMatches.forEach(d => {
-          if (matches.find(dd => dd.matchId === d.matchId)) {
+          if (matches.find(dd => dd.id === d.id)) {
             staying.push(d);
           } else {
             exiting.push(d);
           }
         });
-        const now = Date.now();
+        const entering = matches.filter(d => {
+          return !previousMatches.find(dd => dd.id === d.id);
+        });
+        now = Date.now();
         exiting.forEach(d => {
-          var _ref2, _d$options$loaderGcMa, _ref3, _d$options$loaderMaxA;
-
-          d.__.onExit == null ? void 0 : d.__.onExit({
+          d.__onExit?.({
             params: d.params,
-            search: d.routeSearch
-          }); // Clear idle error states when match leaves
+            search: d.store.state.routeSearch
+          });
 
-          if (d.status === 'error' && !d.isFetching) {
-            d.status = 'idle';
-            d.error = undefined;
+          // Clear non-loading error states when match leaves
+          if (d.store.state.status === 'error' && !d.store.state.isFetching) {
+            d.store.setState(s => {
+              s.status = 'idle';
+              s.error = undefined;
+            });
           }
-
-          const gc = Math.max((_ref2 = (_d$options$loaderGcMa = d.options.loaderGcMaxAge) != null ? _d$options$loaderGcMa : router.options.defaultLoaderGcMaxAge) != null ? _ref2 : 0, (_ref3 = (_d$options$loaderMaxA = d.options.loaderMaxAge) != null ? _d$options$loaderMaxA : router.options.defaultLoaderMaxAge) != null ? _ref3 : 0);
-
+          const gc = Math.max(d.route.options.loaderGcMaxAge ?? this.options.defaultLoaderGcMaxAge ?? 0, d.route.options.loaderMaxAge ?? this.options.defaultLoaderMaxAge ?? 0);
           if (gc > 0) {
-            router.matchCache[d.matchId] = {
-              gc: gc == Infinity ? Number.MAX_SAFE_INTEGER : now + gc,
-              match: d
-            };
+            this.store.setState(s => {
+              s.matchCache[d.id] = {
+                gc: gc == Infinity ? Number.MAX_SAFE_INTEGER : now + gc,
+                match: d
+              };
+            });
           }
         });
         staying.forEach(d => {
-          d.options.onTransition == null ? void 0 : d.options.onTransition({
+          d.route.options.onTransition?.({
             params: d.params,
-            search: d.routeSearch
+            search: d.store.state.routeSearch
           });
         });
-        const entering = matches.filter(d => {
-          return !previousMatches.find(dd => dd.matchId === d.matchId);
-        });
         entering.forEach(d => {
-          d.__.onExit = d.options.onMatch == null ? void 0 : d.options.onMatch({
+          d.__onExit = d.route.options.onLoaded?.({
             params: d.params,
-            search: d.search
+            search: d.store.state.search
           });
-          delete router.matchCache[d.matchId];
+          delete this.store.state.matchCache[d.id];
         });
-
-        if (matches.some(d => d.status === 'loading')) {
-          router.notify();
-          await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
-        }
-
-        if (router.startedLoadingAt !== id) {
-          // Ignore side-effects of match loading
-          return;
-        }
-
-        router.state = _extends({}, router.state, {
-          location: router.location,
-          matches,
-          pending: undefined,
-          status: 'idle'
+        this.store.setState(s => {
+          Object.assign(s, {
+            status: 'idle',
+            currentLocation: this.store.state.latestLocation,
+            currentMatches: matches,
+            pendingLocation: undefined,
+            pendingMatches: undefined
+          });
         });
-        router.notify();
-        router.resolveNavigation();
-      },
-      cleanMatchCache: () => {
+        this.options.onRouteChange?.();
+        this.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
+        this.store.setState(s => {
+          Object.keys(s.matchCache).forEach(matchId => {
+            const entry = s.matchCache[matchId];
 
+            // Don't remove loading matches
+            if (entry.match.store.state.status === 'loading') {
+              return;
+            }
 
-          if (entry.gc > 0 && entry.gc > now) {
-            return;
-          } // Everything else gets removed
-
+            // Do not remove successful matches that are still valid
+            if (entry.gc > 0 && entry.gc > now) {
+              return;
+            }
 
-          delete router.matchCache[matchId];
+            // Everything else gets removed
+            delete s.matchCache[matchId];
+          });
         });
-      },
-      loadRoute: async function loadRoute(navigateOpts) {
-        if (navigateOpts === void 0) {
-          navigateOpts = router.location;
-        }
-
-        const next = router.buildNext(navigateOpts);
-        const matches = router.matchRoutes(next.pathname, {
+      };
+      getRoute = id => {
+        const route = this.routesById[id];
+        invariant(route, `Route with id "${id}" not found`);
+        return route;
+      };
+      loadRoute = async (navigateOpts = this.store.state.latestLocation) => {
+        const next = this.buildNext(navigateOpts);
+        const matches = this.matchRoutes(next.pathname, {
           strictParseParams: true
         });
-        await router.loadMatches(matches);
+        await this.loadMatches(matches);
         return matches;
-      },
-      preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
-        var _ref4, _ref5, _loaderOpts$maxAge, _ref6, _ref7, _loaderOpts$gcMaxAge;
-
-        if (navigateOpts === void 0) {
-          navigateOpts = router.location;
-        }
-
-        const next = router.buildNext(navigateOpts);
-        const matches = router.matchRoutes(next.pathname, {
+      };
+      preloadRoute = async (navigateOpts = this.store.state.latestLocation, loaderOpts) => {
+        const next = this.buildNext(navigateOpts);
+        const matches = this.matchRoutes(next.pathname, {
           strictParseParams: true
         });
-        await router.loadMatches(matches, {
+        await this.loadMatches(matches, {
           preload: true,
-          maxAge: (_ref4 = (_ref5 = (_loaderOpts$maxAge = loaderOpts.maxAge) != null ? _loaderOpts$maxAge : router.options.defaultPreloadMaxAge) != null ? _ref5 : router.options.defaultLoaderMaxAge) != null ? _ref4 : 0,
-          gcMaxAge: (_ref6 = (_ref7 = (_loaderOpts$gcMaxAge = loaderOpts.gcMaxAge) != null ? _loaderOpts$gcMaxAge : router.options.defaultPreloadGcMaxAge) != null ? _ref7 : router.options.defaultLoaderGcMaxAge) != null ? _ref6 : 0
+          maxAge: loaderOpts.maxAge ?? this.options.defaultPreloadMaxAge ?? this.options.defaultLoaderMaxAge ?? 0,
+          gcMaxAge: loaderOpts.gcMaxAge ?? this.options.defaultPreloadGcMaxAge ?? this.options.defaultLoaderGcMaxAge ?? 0
         });
         return matches;
-      },
-      matchRoutes: (pathname, opts) => {
-        var _router$state$pending3, _router$state$pending4;
-
-        router.cleanMatchCache();
+      };
+      matchRoutes = (pathname, opts) => {
         const matches = [];
-
-        if (!router.routeTree) {
+        if (!this.routeTree) {
           return matches;
         }
-
-        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 existingMatches = [...this.store.state.currentMatches, ...(this.store.state.pendingMatches ?? [])];
         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 params = parentMatch?.params ?? {};
+          const filteredRoutes = this.options.filterRoutes?.(routes) ?? 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) {
+              if (!route.path && route.childRoutes?.length) {
                 return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
               }
-
-              const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length);
-              const matchParams = matchPathname(pathname, {
+              const fuzzy = !!(route.path !== '/' || route.childRoutes?.length);
+              const matchParams = matchPathname(this.basepath, pathname, {
                 to: route.fullPath,
                 fuzzy,
-                caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
+                caseSensitive: route.options.caseSensitive ?? this.options.caseSensitive
               });
-
               if (matchParams) {
                 let parsedParams;
-
                 try {
-                  var _route$options$parseP;
-
-                  parsedParams = (_route$options$parseP = route.options.parseParams == null ? void 0 : route.options.parseParams(matchParams)) != null ? _route$options$parseP : matchParams;
+                  parsedParams = route.options.parseParams?.(matchParams) ?? matchParams;
                 } catch (err) {
-                  if (opts != null && opts.strictParseParams) {
+                  if (opts?.strictParseParams) {
                     throw err;
                   }
                 }
-
-                params = _extends({}, params, parsedParams);
+                params = {
+                  ...params,
+                  ...parsedParams
+                };
               }
-
               if (!!matchParams) {
                 foundRoutes = [...parentRoutes, route];
               }
-
               return !!foundRoutes.length;
             });
             return !!foundRoutes.length;
           };
-
           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, {
+            const interpolatedPath = interpolatePath(foundRoute.path, params);
+            const matchId = interpolatePath(foundRoute.id, params, true);
+            const match = existingMatches.find(d => d.id === matchId) || this.store.state.matchCache[matchId]?.match || new RouteMatch(this, foundRoute, {
               matchId,
               params,
-              pathname: joinPaths([pathname, interpolatedPath])
+              pathname: joinPaths([this.basepath, interpolatedPath])
             });
             matches.push(match);
           });
           const foundRoute = last(foundRoutes);
-
-          if ((_foundRoute$childRout = foundRoute.childRoutes) != null && _foundRoute$childRout.length) {
+          if (foundRoute.childRoutes?.length) {
             recurse(foundRoute.childRoutes);
           }
         };
-
-        recurse([router.routeTree]);
-        cascadeLoaderData(matches);
+        recurse([this.routeTree]);
+        linkMatches(matches);
         return matches;
-      },
-      loadMatches: async (resolvedMatches, loaderOpts) => {
-        const matchPromises = resolvedMatches.map(async match => {
+      };
+      loadMatches = async (resolvedMatches, loaderOpts) => {
+        this.cleanMatchCache();
+        resolvedMatches.forEach(async match => {
           // Validate the match (loads search params etc)
-          match.__.validate();
+          match.__validate();
+        });
 
+        // Check each match middleware to see if the route can be accessed
+        await Promise.all(resolvedMatches.map(async match => {
+          try {
+            await match.route.options.beforeLoad?.({
+              router: this,
+              match
+            });
+          } catch (err) {
+            if (!loaderOpts?.preload) {
+              match.route.options.onLoadError?.(err);
+            }
+            throw err;
+          }
+        }));
+        const matchPromises = resolvedMatches.map(async (match, index) => {
+          const prevMatch = resolvedMatches[1];
+          const search = match.store.state.search;
+          if (search.__data?.matchId && search.__data.matchId !== match.id) {
+            return;
+          }
           match.load(loaderOpts);
-
-          if (match.status === 'loading') {
-            // If requested, start the pending timers
-            if (loaderOpts != null && loaderOpts.withPending) match.__.startPending(); // Wait for the first sign of activity from the match
-            // This might be completion, error, or a pending state
-
-            await match.__.loadPromise;
+          if (match.store.state.status !== 'success' && 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();
+          if (prevMatch) {
+            await prevMatch.__loadPromise;
           }
         });
-      },
-      reload: () => router.__.navigate({
-        fromCurrent: true,
-        replace: true,
-        search: true
-      }),
-      resolvePath: (from, path) => {
-        return resolvePath(router.basepath, from, cleanPath(path));
-      },
-      matchRoute: (location, opts) => {
-        var _location$from;
-
-        // const location = router.buildNext(opts)
-        location = _extends({}, location, {
-          to: location.to ? router.resolvePath((_location$from = location.from) != null ? _location$from : '', location.to) : undefined
-        });
-        const next = router.buildNext(location);
+        await Promise.all(matchPromises);
+      };
+      loadMatchData = async routeMatch => {
+        if (isServer || !this.options.useServerData) {
+          return (await routeMatch.route.options.loader?.({
+            // parentLoaderPromise: routeMatch.parentMatch.dataPromise,
+            params: routeMatch.params,
+            search: routeMatch.store.state.routeSearch,
+            signal: routeMatch.abortController.signal
+          })) || {};
+        } else {
+          // Refresh:
+          // '/dashboard'
+          // '/dashboard/invoices/'
+          // '/dashboard/invoices/123'
 
-        if (opts != null && opts.pending) {
-          var _router$state$pending7;
+          // New:
+          // '/dashboard/invoices/456'
 
-          if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
-            return false;
-          }
+          // TODO: batch requests when possible
 
-          return !!matchPathname(router.state.pending.location.pathname, _extends({}, opts, {
-            to: next.pathname
-          }));
+          return this.options.fetchServerDataFn({
+            router: this,
+            routeMatch
+          });
         }
-
-        return !!matchPathname(router.state.location.pathname, _extends({}, opts, {
-          to: next.pathname
+      };
+      invalidateRoute = async opts => {
+        const next = this.buildNext(opts);
+        const unloadedMatchIds = this.matchRoutes(next.pathname).map(d => d.id);
+        await Promise.allSettled([...this.store.state.currentMatches, ...(this.store.state.pendingMatches ?? [])].map(async match => {
+          if (unloadedMatchIds.includes(match.id)) {
+            return match.invalidate();
+          }
         }));
-      },
-      navigate: async _ref8 => {
-        let {
-          from,
-          to = '.',
-          search,
-          hash,
-          replace,
-          params
-        } = _ref8;
+      };
+      reload = () => {
+        this.navigate({
+          fromCurrent: true,
+          replace: true,
+          search: true
+        });
+      };
+      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 = String(from);
         let isExternal;
-
         try {
-          new URL("" + toString);
+          new URL(`${toString}`);
           isExternal = true;
         } catch (e) {}
-
-        invariant(!isExternal, 'Attempting to navigate to external url with router.navigate!');
-        return router.__.navigate({
+        invariant(!isExternal, 'Attempting to navigate to external url with this.navigate!');
+        return this.#commitLocation({
           from: fromString,
           to: toString,
           search,
@@ -2163,38 +1374,55 @@
           replace,
           params
         });
-      },
-      buildLink: _ref9 => {
-        var _preload, _ref10;
-
-        let {
-          from,
-          to = '.',
-          search,
-          params,
-          hash,
-          target,
-          replace,
-          activeOptions,
-          preload,
-          preloadMaxAge: userPreloadMaxAge,
-          preloadGcMaxAge: userPreloadGcMaxAge,
-          preloadDelay: userPreloadDelay,
-          disabled
-        } = _ref9;
-
+      };
+      matchRoute = (location, opts) => {
+        location = {
+          ...location,
+          to: location.to ? this.resolvePath(location.from ?? '', location.to) : undefined
+        };
+        const next = this.buildNext(location);
+        if (opts?.pending) {
+          if (!this.store.state.pendingLocation) {
+            return false;
+          }
+          return matchPathname(this.basepath, this.store.state.pendingLocation.pathname, {
+            ...opts,
+            to: next.pathname
+          });
+        }
+        return matchPathname(this.basepath, this.store.state.currentLocation.pathname, {
+          ...opts,
+          to: next.pathname
+        });
+      };
+      buildLink = ({
+        from,
+        to = '.',
+        search,
+        params,
+        hash,
+        target,
+        replace,
+        activeOptions,
+        preload,
+        preloadMaxAge: userPreloadMaxAge,
+        preloadGcMaxAge: userPreloadGcMaxAge,
+        preloadDelay: userPreloadDelay,
+        disabled
+      }) => {
         // 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);
+          new URL(`${to}`);
           return {
             type: 'external',
             href: to
           };
         } catch (e) {}
-
         const nextOpts = {
           from,
           to,
@@ -2203,71 +1431,73 @@
           hash,
           replace
         };
-        const next = router.buildNext(nextOpts);
-        preload = (_preload = preload) != null ? _preload : router.options.defaultPreload;
-        const preloadDelay = (_ref10 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref10 : 0; // Compare path/hash for matches
+        const next = this.buildNext(nextOpts);
+        preload = preload ?? this.options.defaultPreload;
+        const preloadDelay = userPreloadDelay ?? this.options.defaultPreloadDelay ?? 0;
 
-        const pathIsEqual = router.state.location.pathname === next.pathname;
-        const currentPathSplit = router.state.location.pathname.split('/');
+        // Compare path/hash for matches
+        const pathIsEqual = this.store.state.currentLocation.pathname === next.pathname;
+        const currentPathSplit = this.store.state.currentLocation.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 hashIsEqual = this.store.state.currentLocation.hash === next.hash;
+        // Combine the matches based on user options
+        const pathTest = activeOptions?.exact ? pathIsEqual : pathIsFuzzyEqual;
+        const hashTest = activeOptions?.includeHash ? hashIsEqual : true;
 
-        const isActive = pathTest && hashTest; // The click handler
+        // 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!)
-
+              this.invalidateRoute(nextOpts);
+            }
 
-            router.__.navigate(nextOpts);
+            // All is well? Navigate!
+            this.#commitLocation(nextOpts);
           }
-        }; // The click handler
-
+        };
 
+        // The click handler
         const handleFocus = e => {
           if (preload) {
-            router.preloadRoute(nextOpts, {
+            this.preloadRoute(nextOpts, {
               maxAge: userPreloadMaxAge,
               gcMaxAge: userPreloadGcMaxAge
+            }).catch(err => {
+              console.warn(err);
+              console.warn('Error preloading route! ☝️');
             });
           }
         };
-
         const handleEnter = e => {
           const target = e.target || {};
-
           if (preload) {
             if (target.preloadTimeout) {
               return;
             }
-
             target.preloadTimeout = setTimeout(() => {
               target.preloadTimeout = null;
-              router.preloadRoute(nextOpts, {
+              this.preloadRoute(nextOpts, {
                 maxAge: userPreloadMaxAge,
                 gcMaxAge: userPreloadGcMaxAge
+              }).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,
@@ -2278,215 +1508,329 @@
           isActive,
           disabled
         };
-      },
-      buildNext: opts => {
-        const next = router.__.buildLocation(opts);
-
-        const matches = router.matchRoutes(next.pathname);
-
-        const __preSearchFilters = matches.map(match => {
-          var _match$options$preSea;
-
-          return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
-        }).flat().filter(Boolean);
-
-        const __postSearchFilters = matches.map(match => {
-          var _match$options$postSe;
-
-          return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
-        }).flat().filter(Boolean);
+      };
+      dehydrate = () => {
+        return {
+          state: {
+            ...pick(this.store.state, ['latestLocation', 'currentLocation', 'status', 'lastUpdated']),
+            currentMatches: this.store.state.currentMatches.map(match => ({
+              matchId: match.id,
+              state: {
+                ...pick(match.store.state, ['status', 'routeLoaderData', 'invalidAt', 'invalid'])
+              }
+            }))
+          },
+          context: this.options.context
+        };
+      };
+      hydrate = dehydratedRouter => {
+        this.store.setState(s => {
+          // Update the context TODO: make this part of state?
+          this.options.context = dehydratedRouter.context;
 
-        return router.__.buildLocation(_extends({}, opts, {
-          __preSearchFilters,
-          __postSearchFilters
-        }));
-      },
-      __: {
-        buildRouteTree: rootRouteConfig => {
-          const recurseRoutes = (routeConfigs, parent) => {
-            return routeConfigs.map(routeConfig => {
-              const routeOptions = routeConfig.options;
-              const route = createRoute(routeConfig, routeOptions, parent, router); // {
-              //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
-              //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
-              // }
-
-              const existingRoute = router.routesById[route.routeId];
-
-              if (existingRoute) {
-                {
-                  console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
+          // Match the routes
+          const currentMatches = this.matchRoutes(dehydratedRouter.state.latestLocation.pathname, {
+            strictParseParams: true
+          });
+          currentMatches.forEach((match, index) => {
+            const dehydratedMatch = dehydratedRouter.state.currentMatches[index];
+            invariant(dehydratedMatch && dehydratedMatch.matchId === match.id, 'Oh no! There was a hydration mismatch when attempting to rethis.store the state of the router! 😬');
+            Object.assign(match, dehydratedMatch);
+          });
+          currentMatches.forEach(match => match.__validate());
+          Object.assign(s, {
+            ...dehydratedRouter.state,
+            currentMatches
+          });
+        });
+      };
+      getLoader = opts => {
+        const id = opts.from || '/';
+        const route = this.getRoute(id);
+        if (!route) return undefined;
+        let loader = this.store.state.loaders[id] || (() => {
+          this.store.setState(s => {
+            s.loaders[id] = {
+              pending: [],
+              fetch: async loaderContext => {
+                if (!route) {
+                  return;
+                }
+                const loaderState = {
+                  loadedAt: Date.now(),
+                  loaderContext
+                };
+                this.store.setState(s => {
+                  s.loaders[id].current = loaderState;
+                  s.loaders[id].latest = loaderState;
+                  s.loaders[id].pending.push(loaderState);
+                });
+                try {
+                  return await route.options.loader?.(loaderContext);
+                } finally {
+                  this.store.setState(s => {
+                    s.loaders[id].pending = s.loaders[id].pending.filter(d => d !== loaderState);
+                  });
                 }
-
-                throw new Error();
               }
-              router.routesById[route.routeId] = route;
-              const children = routeConfig.children;
-              route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
-              return route;
-            });
+            };
+          });
+          return this.store.state.loaders[id];
+        })();
+        return loader;
+      };
+      #buildRouteTree = rootRouteConfig => {
+        const recurseRoutes = (routeConfigs, parent) => {
+          return routeConfigs.map((routeConfig, i) => {
+            const routeOptions = routeConfig.options;
+            const route = new Route(routeConfig, routeOptions, i, parent, this);
+            const existingRoute = this.routesById[route.id];
+            if (existingRoute) {
+              {
+                console.warn(`Duplicate routes found with id: ${String(route.id)}`, this.routesById, route);
+              }
+              throw new Error();
+            }
+            this.routesById[route.id] = route;
+            const children = routeConfig.children;
+            route.childRoutes = children.length ? recurseRoutes(children, route) : undefined;
+            return route;
+          });
+        };
+        const routes = recurseRoutes([rootRouteConfig]);
+        return routes[0];
+      };
+      #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__'
+        };
+      };
+      #onFocus = () => {
+        this.load();
+      };
+      #buildLocation = (dest = {}) => {
+        const fromPathname = dest.fromCurrent ? this.store.state.latestLocation.pathname : dest.from ?? this.store.state.latestLocation.pathname;
+        let pathname = resolvePath(this.basepath ?? '/', fromPathname, `${dest.to ?? '.'}`);
+        const fromMatches = this.matchRoutes(this.store.state.latestLocation.pathname, {
+          strictParseParams: true
+        });
+        const toMatches = this.matchRoutes(pathname);
+        const prevParams = {
+          ...last(fromMatches)?.params
+        };
+        let nextParams = (dest.params ?? true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
+        if (nextParams) {
+          toMatches.map(d => d.route.options.stringifyParams).filter(Boolean).forEach(fn => {
+            Object.assign({}, nextParams, fn(nextParams));
+          });
+        }
+        pathname = interpolatePath(pathname, nextParams ?? {});
+
+        // Pre filters first
+        const preFilteredSearch = dest.__preSearchFilters?.length ? dest.__preSearchFilters?.reduce((prev, next) => next(prev), this.store.state.latestLocation.search) : this.store.state.latestLocation.search;
+
+        // Then the link/navigate function
+        const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
+        : dest.search ? functionalUpdate(dest.search, preFilteredSearch) ?? {} // Updater
+        : dest.__preSearchFilters?.length ? preFilteredSearch // Preserve resolvedFrom filters
+        : {};
+
+        // Then post filters
+        const postFilteredSearch = dest.__postSearchFilters?.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
+        const search = replaceEqualDeep(this.store.state.latestLocation.search, postFilteredSearch);
+        const searchStr = this.options.stringifySearch(search);
+        let hash = dest.hash === true ? this.store.state.latestLocation.hash : functionalUpdate(dest.hash, this.store.state.latestLocation.hash);
+        hash = hash ? `#${hash}` : '';
+        return {
+          pathname,
+          search,
+          searchStr,
+          state: this.store.state.latestLocation.state,
+          hash,
+          href: `${pathname}${searchStr}${hash}`,
+          key: dest.key
+        };
+      };
+      #commitLocation = 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.store.state.latestLocation.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
+        });
+        this.load(this.#parseLocation(this.store.state.latestLocation));
+        return this.navigationPromise = new Promise(resolve => {
+          const previousNavigationResolve = this.resolveNavigation;
+          this.resolveNavigation = () => {
+            previousNavigationResolve();
+            resolve();
           };
+        });
+      };
+    }
 
-          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);
+    // Detect if we're in the DOM
+    const isServer = typeof window === 'undefined' || !window.document.createElement;
+    function getInitialRouterState() {
+      return {
+        status: 'idle',
+        latestLocation: null,
+        currentLocation: null,
+        currentMatches: [],
+        loaders: {},
+        lastUpdated: Date.now(),
+        matchCache: {},
+        get isFetching() {
+          return this.status === 'loading' || this.currentMatches.some(d => d.store.state.isFetching);
         },
-        buildLocation: function buildLocation(dest) {
-          var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
-
-          if (dest === void 0) {
-            dest = {};
-          }
-
-          // const resolvedFrom: Location = {
-          //   ...router.location,
-          const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
-
-          let pathname = resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
+        get isPreloading() {
+          return Object.values(this.matchCache).some(d => d.match.store.state.isFetching && !this.currentMatches.find(dd => dd.id === d.match.id));
+        }
+      };
+    }
+    function isCtrlEvent(e) {
+      return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+    }
+    function linkMatches(matches) {
+      matches.forEach((match, index) => {
+        const parent = matches[index - 1];
+        if (parent) {
+          match.__setParentMatch(parent);
+        }
+      });
+    }
 
-          const fromMatches = router.matchRoutes(router.location.pathname, {
-            strictParseParams: true
+    // createRouterAction is a constrained identify function that takes options: key, action, onSuccess, onError, onSettled, etc
+    function createAction(options) {
+      const store = createStore({
+        submissions: []
+      }, options.debug);
+      return {
+        options,
+        store,
+        reset: () => {
+          store.setState(s => {
+            s.submissions = [];
           });
-          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));
+        },
+        submit: async payload => {
+          const submission = {
+            submittedAt: Date.now(),
+            status: 'pending',
+            payload: payload,
+            invalidate: () => {
+              setSubmission(s => {
+                s.isInvalid = true;
+              });
+            },
+            getIsLatest: () => store.state.submissions[store.state.submissions.length - 1]?.submittedAt === submission.submittedAt
+          };
+          const setSubmission = updater => {
+            store.setState(s => {
+              const a = s.submissions.find(d => d.submittedAt === submission.submittedAt);
+              invariant(a, 'Could not find submission in store');
+              updater(a);
             });
-          }
-
-          pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
-
-          const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search; // Then the link/navigate function
-
-          const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
-          : dest.search ? (_functionalUpdate = functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
-          : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom filters
-          : {}; // Then post filters
-
-          const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
-          const search = replaceEqualDeep(router.location.search, postFilteredSearch);
-          const searchStr = router.options.stringifySearch(search);
-          let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
-          hash = hash ? "#" + hash : '';
-          return {
-            pathname,
-            search,
-            searchStr,
-            state: router.location.state,
-            hash,
-            href: "" + pathname + searchStr + hash,
-            key: dest.key
           };
-        },
-        commitLocation: (next, replace) => {
-          const id = '' + Date.now() + Math.random();
-          if (router.navigateTimeout) clearTimeout(router.navigateTimeout);
-          let nextAction = 'replace';
-
-          if (!replace) {
-            nextAction = 'push';
-          }
-
-          const isSameUrl = router.__.parseLocation(history.location).href === next.href;
-
-          if (isSameUrl && !next.key) {
-            nextAction = 'replace';
-          }
-
-          if (nextAction === 'replace') {
-            history.replace({
-              pathname: next.pathname,
-              hash: next.hash,
-              search: next.searchStr
-            }, {
-              id
+          store.setState(s => {
+            s.submissions.push(submission);
+            s.submissions.reverse();
+            s.submissions = s.submissions.slice(0, options.maxSubmissions ?? 10);
+            s.submissions.reverse();
+          });
+          const after = async () => {
+            options.onEachSettled?.(submission);
+            if (submission.getIsLatest()) await options.onLatestSettled?.(submission);
+          };
+          try {
+            const res = await options.action?.(submission.payload);
+            setSubmission(s => {
+              s.response = res;
             });
-          } else {
-            history.push({
-              pathname: next.pathname,
-              hash: next.hash,
-              search: next.searchStr
-            }, {
-              id
+            await options.onEachSuccess?.(submission);
+            if (submission.getIsLatest()) await options.onLatestSuccess?.(submission);
+            await after();
+            setSubmission(s => {
+              s.status = 'success';
+            });
+            return res;
+          } catch (err) {
+            console.error(err);
+            setSubmission(s => {
+              s.error = err;
             });
+            await options.onEachError?.(submission);
+            if (submission.getIsLatest()) await options.onLatestError?.(submission);
+            await after();
+            setSubmission(s => {
+              s.status = 'error';
+            });
+            throw err;
           }
-
-          router.navigationPromise = new Promise(resolve => {
-            const previousNavigationResolve = router.resolveNavigation;
-
-            router.resolveNavigation = () => {
-              previousNavigationResolve();
-              resolve();
-            };
-          });
-          return router.navigationPromise;
         }
-      }
-    };
-    router.update(userOptions); // Allow frameworks to hook into the router creation
-
-    router.options.createRouter == null ? void 0 : router.options.createRouter(router);
-    return router;
-  }
-
-  function isCtrlEvent(e) {
-    return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
-  }
-
-  exports.cascadeLoaderData = cascadeLoaderData;
-  exports.cleanPath = cleanPath;
-  exports.createBrowserHistory = createBrowserHistory;
-  exports.createHashHistory = createHashHistory;
-  exports.createMemoryHistory = createMemoryHistory;
-  exports.createRoute = createRoute;
-  exports.createRouteConfig = createRouteConfig;
-  exports.createRouteMatch = createRouteMatch;
-  exports.createRouter = createRouter;
-  exports.decode = decode;
-  exports.defaultParseSearch = defaultParseSearch;
-  exports.defaultStringifySearch = defaultStringifySearch;
-  exports.encode = encode;
-  exports.functionalUpdate = functionalUpdate;
-  exports.interpolatePath = interpolatePath;
-  exports.invariant = invariant;
-  exports.joinPaths = joinPaths;
-  exports.last = last;
-  exports.matchByPath = matchByPath;
-  exports.matchPathname = matchPathname;
-  exports.parsePathname = parsePathname;
-  exports.parseSearchWith = parseSearchWith;
-  exports.replaceEqualDeep = replaceEqualDeep;
-  exports.resolvePath = resolvePath;
-  exports.rootRouteId = rootRouteId;
-  exports.stringifySearchWith = stringifySearchWith;
-  exports.trimPath = trimPath;
-  exports.trimPathLeft = trimPathLeft;
-  exports.trimPathRight = trimPathRight;
-  exports.warning = warning;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
+      };
+    }
+
+    exports.Route = Route;
+    exports.RouteMatch = RouteMatch;
+    exports.Router = Router;
+    exports.batch = batch;
+    exports.cleanPath = cleanPath;
+    exports.createAction = createAction;
+    exports.createBrowserHistory = createBrowserHistory;
+    exports.createHashHistory = createHashHistory;
+    exports.createMemoryHistory = createMemoryHistory;
+    exports.createRouteConfig = createRouteConfig;
+    exports.createStore = createStore;
+    exports.decode = decode;
+    exports.defaultFetchServerDataFn = defaultFetchServerDataFn;
+    exports.defaultParseSearch = defaultParseSearch;
+    exports.defaultStringifySearch = defaultStringifySearch;
+    exports.encode = encode;
+    exports.functionalUpdate = functionalUpdate;
+    exports.interpolatePath = interpolatePath;
+    exports.invariant = invariant;
+    exports.joinPaths = joinPaths;
+    exports.last = last;
+    exports.matchByPath = matchByPath;
+    exports.matchPathname = matchPathname;
+    exports.parsePathname = parsePathname;
+    exports.parseSearchWith = parseSearchWith;
+    exports.pick = pick;
+    exports.replaceEqualDeep = replaceEqualDeep;
+    exports.resolvePath = resolvePath;
+    exports.rootRouteId = rootRouteId;
+    exports.stringifySearchWith = stringifySearchWith;
+    exports.trackDeep = trackDeep;
+    exports.trimPath = trimPath;
+    exports.trimPathLeft = trimPathLeft;
+    exports.trimPathRight = trimPathRight;
+    exports.warning = warning;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
 //# sourceMappingURL=index.development.js.map