@tanstack/react-router 0.0.1-beta.37 → 0.0.1-beta.39

package/build/umd/index.development.js

@@ -34,8 +34,8 @@
 
   var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-  function _extends$2() {
-    _extends$2 = Object.assign ? Object.assign.bind() : function (target) {
+  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) {
@@ -46,23 +46,404 @@
       }
       return target;
     };
-    return _extends$2.apply(this, arguments);
+    return _extends$1.apply(this, arguments);
   }
-  function _objectWithoutPropertiesLoose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for (i = 0; i < sourceKeys.length; i++) {
-      key = sourceKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      target[key] = source[key];
+
+  // src/core.ts
+  var CurrentReaction = void 0;
+  var CurrentGets = null;
+  var CurrentGetsIndex = 0;
+  var EffectQueue = null;
+  var CacheClean = 0;
+  var CacheCheck = 1;
+  var CacheDirty = 2;
+  var Root;
+  var Reactive = class {
+    value;
+    fn;
+    observers = null;
+    sources = null;
+    state;
+    effect;
+    cleanups = null;
+    alwaysUpdate = false;
+    constructor(fnOrValue, type) {
+      if (type != 0 /* Signal */) {
+        this.fn = fnOrValue;
+        this.value = void 0;
+        this.state = CacheDirty;
+        if (Root)
+          Root.push(this);
+        else
+          console.error("Memos and effects must be wrapped in a createRoot");
+        this.effect = type == 2 /* Effect */;
+        if (this.effect)
+          this.update();
+      } else {
+        this.fn = void 0;
+        this.value = fnOrValue;
+        this.state = CacheClean;
+        this.effect = false;
+      }
+    }
+    get() {
+      if (CurrentReaction) {
+        if (!CurrentGets && CurrentReaction.sources && CurrentReaction.sources[CurrentGetsIndex] == this) {
+          CurrentGetsIndex++;
+        } else {
+          if (!CurrentGets)
+            CurrentGets = [this];
+          else
+            CurrentGets.push(this);
+        }
+      }
+      if (this.fn)
+        this.updateIfNecessary();
+      return this.value;
+    }
+    set(value) {
+      const notInBatch = !EffectQueue;
+      const newValue = typeof value === "function" ? value(this.value) : value;
+      if ((this.value !== newValue || this.alwaysUpdate) && this.observers) {
+        for (let i = 0; i < this.observers.length; i++) {
+          this.observers[i].stale(CacheDirty);
+        }
+      }
+      this.value = newValue;
+      if (notInBatch)
+        stabilize();
+      return newValue;
+    }
+    stale(state) {
+      if (this.state < state) {
+        if (this.state === CacheClean && this.effect) {
+          if (EffectQueue)
+            EffectQueue.push(this);
+          else
+            EffectQueue = [this];
+        }
+        this.state = state;
+        if (this.observers) {
+          for (let i = 0; i < this.observers.length; i++) {
+            this.observers[i].stale(CacheCheck);
+          }
+        }
+      }
+    }
+    update() {
+      const oldValue = this.value;
+      const prevReaction = CurrentReaction;
+      const prevGets = CurrentGets;
+      const prevIndex = CurrentGetsIndex;
+      CurrentReaction = this;
+      CurrentGets = null;
+      CurrentGetsIndex = 0;
+      try {
+        if (this.cleanups) {
+          this.cleanups.forEach((c) => c());
+          this.cleanups = null;
+        }
+        this.value = this.fn();
+        if (CurrentGets) {
+          this.removeParentObservers(CurrentGetsIndex);
+          if (this.sources && CurrentGetsIndex > 0) {
+            this.sources.length = CurrentGetsIndex + CurrentGets.length;
+            for (let i = 0; i < CurrentGets.length; i++) {
+              this.sources[CurrentGetsIndex + i] = CurrentGets[i];
+            }
+          } else {
+            this.sources = CurrentGets;
+          }
+          for (let i = CurrentGetsIndex; i < this.sources.length; i++) {
+            const source = this.sources[i];
+            if (!source.observers) {
+              source.observers = [this];
+            } else {
+              source.observers.push(this);
+            }
+          }
+        } else if (this.sources && CurrentGetsIndex < this.sources.length) {
+          this.removeParentObservers(CurrentGetsIndex);
+          this.sources.length = CurrentGetsIndex;
+        }
+      } finally {
+        CurrentGets = prevGets;
+        CurrentReaction = prevReaction;
+        CurrentGetsIndex = prevIndex;
+      }
+      if ((oldValue !== this.value || this.alwaysUpdate) && this.observers) {
+        for (let i = 0; i < this.observers.length; i++) {
+          this.observers[i].state = CacheDirty;
+        }
+      }
+      this.state = CacheClean;
+    }
+    updateIfNecessary() {
+      if (this.state === CacheCheck) {
+        for (const source of this.sources) {
+          source.updateIfNecessary();
+          if (this.state === CacheDirty) {
+            break;
+          }
+        }
+      }
+      if (this.state === CacheDirty) {
+        this.update();
+      }
+      this.state = CacheClean;
+    }
+    removeParentObservers(index) {
+      if (!this.sources)
+        return;
+      for (let i = index; i < this.sources.length; i++) {
+        const source = this.sources[i];
+        const swap = source.observers.findIndex((v) => v === this);
+        source.observers[swap] = source.observers[source.observers.length - 1];
+        source.observers.pop();
+      }
+    }
+    destroy() {
+      if (this.cleanups) {
+        this.cleanups.forEach((c) => c());
+        this.cleanups = null;
+      }
+      this.removeParentObservers(0);
+    }
+  };
+  function onCleanup(fn) {
+    if (CurrentReaction) {
+      if (!CurrentReaction.cleanups)
+        CurrentReaction.cleanups = [fn];
+      else
+        CurrentReaction.cleanups.push(fn);
+    } else {
+      console.error("onCleanup must be called from within a memo or effect");
+    }
+  }
+  function stabilize() {
+    if (!EffectQueue)
+      return;
+    for (let i = 0; i < EffectQueue.length; i++) {
+      EffectQueue[i].get();
+    }
+    EffectQueue = null;
+  }
+  function createSignal(value, options) {
+    const signal = new Reactive(value, 0 /* Signal */);
+    if (options?.equals !== void 0)
+      signal.alwaysUpdate = true;
+    return [signal.get.bind(signal), signal.set.bind(signal)];
+  }
+  function createMemo(fn) {
+    const memo = new Reactive(fn, 1 /* Memo */);
+    return memo.get.bind(memo);
+  }
+  function createEffect(fn) {
+    const effect = new Reactive(fn, 2 /* Effect */);
+    return effect.get.bind(effect);
+  }
+  function createRoot(fn) {
+    let root = [];
+    Root = root;
+    fn();
+    Root = null;
+    return () => {
+      if (!root)
+        return;
+      root.forEach((r) => r.destroy());
+      root = null;
+    };
+  }
+  function batch(fn) {
+    EffectQueue = [];
+    let out = fn();
+    stabilize();
+    return out;
+  }
+  function untrack(fn) {
+    const listener = CurrentReaction;
+    CurrentReaction = void 0;
+    try {
+      return fn();
+    } finally {
+      CurrentReaction = listener;
     }
-    return target;
   }
 
-  function _extends$1() {
-    _extends$1 = Object.assign ? Object.assign.bind() : function (target) {
+  // src/store.ts
+  var $RAW = Symbol("store-raw");
+  var $TRACK = Symbol("track");
+  var $PROXY = Symbol("store-proxy");
+  var $NODE = Symbol("store-node");
+  function wrap(value) {
+    let p = value[$PROXY];
+    if (!p) {
+      Object.defineProperty(value, $PROXY, {
+        value: p = new Proxy(value, proxyTraps)
+      });
+      if (!Array.isArray(value)) {
+        const keys = Object.keys(value);
+        const desc = Object.getOwnPropertyDescriptors(value);
+        for (let i = 0, l = keys.length; i < l; i++) {
+          const prop = keys[i];
+          if (desc[prop].get) {
+            const get = desc[prop].get.bind(p);
+            Object.defineProperty(value, prop, {
+              enumerable: desc[prop].enumerable,
+              get
+            });
+          }
+        }
+      }
+    }
+    return p;
+  }
+  function isWrappable(obj) {
+    let proto;
+    return obj != null && typeof obj === "object" && (obj[$PROXY] || !(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype || Array.isArray(obj));
+  }
+  function unwrap(item, set = /* @__PURE__ */ new Set()) {
+    let result, unwrapped, v, prop;
+    if (result = item != null && item[$RAW])
+      return result;
+    if (!isWrappable(item) || set.has(item))
+      return item;
+    if (Array.isArray(item)) {
+      if (Object.isFrozen(item))
+        item = item.slice(0);
+      else
+        set.add(item);
+      for (let i = 0, l = item.length; i < l; i++) {
+        v = item[i];
+        if ((unwrapped = unwrap(v, set)) !== v)
+          item[i] = unwrapped;
+      }
+    } else {
+      if (Object.isFrozen(item))
+        item = Object.assign({}, item);
+      else
+        set.add(item);
+      const keys = Object.keys(item);
+      const desc = Object.getOwnPropertyDescriptors(item);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        prop = keys[i];
+        if (desc[prop].get)
+          continue;
+        v = item[prop];
+        if ((unwrapped = unwrap(v, set)) !== v)
+          item[prop] = unwrapped;
+      }
+    }
+    return item;
+  }
+  function getDataNodes(target) {
+    let nodes = target[$NODE];
+    if (!nodes)
+      Object.defineProperty(target, $NODE, { value: nodes = {} });
+    return nodes;
+  }
+  function getDataNode(nodes, property, value) {
+    return nodes[property] || (nodes[property] = createDataNode(value));
+  }
+  function proxyDescriptor(target, property) {
+    const desc = Reflect.getOwnPropertyDescriptor(target, property);
+    if (!desc || desc.get || !desc.configurable || property === $PROXY || property === $NODE)
+      return desc;
+    delete desc.value;
+    delete desc.writable;
+    desc.get = () => target[$PROXY][property];
+    return desc;
+  }
+  function trackSelf(target) {
+    if (CurrentReaction) {
+      const nodes = getDataNodes(target);
+      (nodes._ || (nodes._ = createDataNode())).get();
+    }
+  }
+  function ownKeys(target) {
+    trackSelf(target);
+    return Reflect.ownKeys(target);
+  }
+  function createDataNode(value) {
+    const s = new Reactive(value, 0);
+    s.alwaysUpdate = true;
+    return s;
+  }
+  var Writing = false;
+  var proxyTraps = {
+    get(target, property, receiver) {
+      if (property === $RAW)
+        return target;
+      if (property === $PROXY)
+        return receiver;
+      if (property === $TRACK) {
+        trackSelf(target);
+        return receiver;
+      }
+      const nodes = getDataNodes(target);
+      const tracked = nodes.hasOwnProperty(property);
+      let value = tracked ? nodes[property].get() : target[property];
+      if (property === $NODE || property === "__proto__")
+        return value;
+      if (!tracked) {
+        const desc = Object.getOwnPropertyDescriptor(target, property);
+        if (CurrentReaction && (typeof value !== "function" || target.hasOwnProperty(property)) && !(desc && desc.get))
+          value = getDataNode(nodes, property, value).get();
+      }
+      return isWrappable(value) ? wrap(value) : value;
+    },
+    has(target, property) {
+      if (property === $RAW || property === $PROXY || property === $TRACK || property === $NODE || property === "__proto__")
+        return true;
+      this.get(target, property, target);
+      return property in target;
+    },
+    set(target, property, value) {
+      Writing && setProperty(target, property, unwrap(value));
+      return true;
+    },
+    deleteProperty(target, property) {
+      Writing && setProperty(target, property, void 0, true);
+      return true;
+    },
+    ownKeys,
+    getOwnPropertyDescriptor: proxyDescriptor
+  };
+  function setProperty(state, property, value, deleting = false) {
+    if (!deleting && state[property] === value)
+      return;
+    const prev = state[property];
+    const len = state.length;
+    if (deleting)
+      delete state[property];
+    else
+      state[property] = value;
+    const nodes = getDataNodes(state);
+    let node;
+    if (node = getDataNode(nodes, property, prev))
+      node.set(() => value);
+    if (Array.isArray(state) && state.length !== len)
+      (node = getDataNode(nodes, "length", len)) && node.set(state.length);
+    (node = nodes._) && node.set();
+  }
+  function createStore(store) {
+    const unwrappedStore = unwrap(store);
+    const wrappedStore = wrap(unwrappedStore);
+    const setStore = (fn) => {
+      batch(() => {
+        try {
+          Writing = true;
+          fn(wrappedStore);
+        } finally {
+          Writing = false;
+        }
+      });
+    };
+    return [wrappedStore, setStore];
+  }
+
+  function _extends() {
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
       for (var i = 1; i < arguments.length; i++) {
         var source = arguments[i];
         for (var key in source) {
@@ -73,7 +454,7 @@
       }
       return target;
     };
-    return _extends$1.apply(this, arguments);
+    return _extends.apply(this, arguments);
   }
 
   /**
@@ -217,7 +598,7 @@
 
     if (index == null) {
       index = 0;
-      globalHistory.replaceState(_extends$1({}, globalHistory.state, {
+      globalHistory.replaceState(_extends({}, globalHistory.state, {
         idx: index
       }), '');
     }
@@ -232,7 +613,7 @@
         state = null;
       }
 
-      return readOnly(_extends$1({
+      return readOnly(_extends({
         pathname: location.pathname,
         hash: '',
         search: ''
@@ -466,7 +847,7 @@
 
     if (index == null) {
       index = 0;
-      globalHistory.replaceState(_extends$1({}, globalHistory.state, {
+      globalHistory.replaceState(_extends({}, globalHistory.state, {
         idx: index
       }), '');
     }
@@ -493,7 +874,7 @@
         state = null;
       }
 
-      return readOnly(_extends$1({
+      return readOnly(_extends({
         pathname: location.pathname,
         hash: '',
         search: ''
@@ -645,7 +1026,7 @@
         initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,
         initialIndex = _options3.initialIndex;
     var entries = initialEntries.map(function (entry) {
-      var location = readOnly(_extends$1({
+      var location = readOnly(_extends({
         pathname: '/',
         search: '',
         hash: '',
@@ -670,7 +1051,7 @@
         state = null;
       }
 
-      return readOnly(_extends$1({
+      return readOnly(_extends({
         pathname: location.pathname,
         search: '',
         hash: ''
@@ -888,63 +1269,6 @@
    * @license MIT
    */
 
-  /**
-   * This function returns `a` if `b` is deeply equal.
-   * If not, it will replace any deeply equal children of `b` with those of `a`.
-   * This can be used for structural sharing between JSON values for example.
-   */
-  function replaceEqualDeep(prev, next) {
-    if (prev === next) {
-      return prev;
-    }
-    const array = Array.isArray(prev) && Array.isArray(next);
-    if (array || isPlainObject(prev) && isPlainObject(next)) {
-      const aSize = array ? prev.length : Object.keys(prev).length;
-      const bItems = array ? next : Object.keys(next);
-      const bSize = bItems.length;
-      const copy = array ? [] : {};
-      let equalItems = 0;
-      for (let i = 0; i < bSize; i++) {
-        const key = array ? i : bItems[i];
-        copy[key] = replaceEqualDeep(prev[key], next[key]);
-        if (copy[key] === prev[key]) {
-          equalItems++;
-        }
-      }
-      return aSize === bSize && equalItems === aSize ? prev : copy;
-    }
-    return next;
-  }
-
-  // Copied from: https://github.com/jonschlinkert/is-plain-object
-  function isPlainObject(o) {
-    if (!hasObjectPrototype(o)) {
-      return false;
-    }
-
-    // If has modified constructor
-    const ctor = o.constructor;
-    if (typeof ctor === 'undefined') {
-      return true;
-    }
-
-    // If has modified prototype
-    const prot = ctor.prototype;
-    if (!hasObjectPrototype(prot)) {
-      return false;
-    }
-
-    // If constructor does not have an Object-specific method
-    if (!prot.hasOwnProperty('isPrototypeOf')) {
-      return false;
-    }
-
-    // Most likely a plain Object
-    return true;
-  }
-  function hasObjectPrototype(o) {
-    return Object.prototype.toString.call(o) === '[object Object]';
-  }
   function last(arr) {
     return arr[arr.length - 1];
   }
@@ -953,7 +1277,7 @@
       if (typeof console !== 'undefined') console.warn(message);
       try {
         throw new Error(message);
-      } catch (_unused) {}
+      } catch {}
     }
     return true;
   }
@@ -990,8 +1314,8 @@
     return trimPathRight(trimPathLeft(path));
   }
   function resolvePath(basepath, base, to) {
-    base = base.replace(new RegExp("^" + basepath), '/');
-    to = to.replace(new RegExp("^" + basepath), '/');
+    base = base.replace(new RegExp(`^${basepath}`), '/');
+    to = to.replace(new RegExp(`^${basepath}`), '/');
     let baseSegments = parsePathname(base);
     const toSegments = parsePathname(to);
     toSegments.forEach((toSegment, index) => {
@@ -1072,8 +1396,7 @@
         return '';
       }
       if (segment.type === 'param') {
-        var _segment$value$substr;
-        return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
+        return params[segment.value.substring(1)] ?? '';
       }
       return segment.value;
     }));
@@ -1085,16 +1408,15 @@
     if (matchLocation.to && !pathParams) {
       return;
     }
-    return pathParams != null ? pathParams : {};
+    return pathParams ?? {};
   }
   function matchByPath(basepath, from, matchLocation) {
-    var _matchLocation$to;
     if (!from.startsWith(basepath)) {
       return undefined;
     }
     from = basepath != '/' ? from.substring(basepath.length) : from;
     const baseSegments = parsePathname(from);
-    const to = "" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*');
+    const to = `${matchLocation.to ?? '*'}`;
     const routeSegments = parsePathname(to);
     const params = {};
     let isMatch = (() => {
@@ -1195,134 +1517,136 @@
     return out;
   }
 
-  function _extends() {
-    _extends = Object.assign ? Object.assign.bind() : function (target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key)) {
-            target[key] = source[key];
-          }
-        }
-      }
-      return target;
-    };
-    return _extends.apply(this, arguments);
-  }
-
-  function createRoute(routeConfig, options, parent, router) {
+  function createRoute(routeConfig, options, originalIndex, parent, router) {
     const {
       id,
       routeId,
       path: routePath,
       fullPath
     } = routeConfig;
-    const action = router.state.actions[id] || (() => {
-      router.state.actions[id] = {
-        submissions: [],
-        submit: async (submission, actionOpts) => {
-          var _actionOpts$invalidat;
-          if (!route) {
-            return;
-          }
-          const invalidate = (_actionOpts$invalidat = actionOpts == null ? void 0 : actionOpts.invalidate) != null ? _actionOpts$invalidat : true;
-          if (!(actionOpts != null && actionOpts.multi)) {
-            action.submissions = action.submissions.filter(d => d.isMulti);
-          }
-          const actionState = {
-            submittedAt: Date.now(),
-            status: 'pending',
-            submission,
-            isMulti: !!(actionOpts != null && actionOpts.multi)
-          };
-          action.current = actionState;
-          action.latest = actionState;
-          action.submissions.push(actionState);
-          router.notify();
-          try {
-            const res = await (route.options.action == null ? void 0 : route.options.action(submission));
-            actionState.data = res;
-            if (invalidate) {
-              router.invalidateRoute({
-                to: '.',
-                fromCurrent: true
-              });
-              await router.reload();
-            }
-            actionState.status = 'success';
-            return res;
-          } catch (err) {
-            console.error(err);
-            actionState.error = err;
-            actionState.status = 'error';
-          } finally {
-            router.notify();
-          }
-        }
-      };
-      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();
-          try {
-            return await (route.options.loader == null ? void 0 : route.options.loader(loaderContext));
-          } finally {
-            loader.pending = loader.pending.filter(d => d !== loaderState);
-            // router.removeActionQueue.push({ loader, loaderState })
-            router.notify();
-          }
-        }
-      };
-      return router.state.loaders[id];
-    })();
     let route = {
       routeInfo: undefined,
       routeId: id,
       routeRouteId: routeId,
+      originalIndex,
       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
-        }));
+      get action() {
+        let action = router.store.actions[id] || (() => {
+          router.setStore(s => {
+            s.actions[id] = {
+              submissions: [],
+              submit: async (submission, actionOpts) => {
+                if (!route) {
+                  return;
+                }
+                const invalidate = (actionOpts == null ? void 0 : actionOpts.invalidate) ?? true;
+                const [actionStore, setActionStore] = createStore({
+                  submittedAt: Date.now(),
+                  status: 'pending',
+                  submission,
+                  isMulti: !!(actionOpts != null && actionOpts.multi)
+                });
+                router.setStore(s => {
+                  if (!(actionOpts != null && actionOpts.multi)) {
+                    s.actions[id].submissions = action.submissions.filter(d => d.isMulti);
+                  }
+                  s.actions[id].current = actionStore;
+                  s.actions[id].latest = actionStore;
+                  s.actions[id].submissions.push(actionStore);
+                });
+                try {
+                  const res = await (route.options.action == null ? void 0 : route.options.action(submission));
+                  setActionStore(s => {
+                    s.data = res;
+                  });
+                  if (invalidate) {
+                    router.invalidateRoute({
+                      to: '.',
+                      fromCurrent: true
+                    });
+                    await router.reload();
+                  }
+                  setActionStore(s => {
+                    s.status = 'success';
+                  });
+                  return res;
+                } catch (err) {
+                  console.error(err);
+                  setActionStore(s => {
+                    s.error = err;
+                    s.status = 'error';
+                  });
+                }
+              }
+            };
+          });
+          return router.store.actions[id];
+        })();
+        return action;
       },
-      matchRoute: (matchLocation, opts) => {
-        return router.matchRoute(_extends({}, matchLocation, {
-          from: fullPath
-        }), opts);
+      get loader() {
+        let loader = router.store.loaders[id] || (() => {
+          router.setStore(s => {
+            s.loaders[id] = {
+              pending: [],
+              fetch: async loaderContext => {
+                if (!route) {
+                  return;
+                }
+                const loaderState = {
+                  loadedAt: Date.now(),
+                  loaderContext
+                };
+                router.setStore(s => {
+                  s.loaders[id].current = loaderState;
+                  s.loaders[id].latest = loaderState;
+                  s.loaders[id].pending.push(loaderState);
+                });
+                try {
+                  return await (route.options.loader == null ? void 0 : route.options.loader(loaderContext));
+                } finally {
+                  router.setStore(s => {
+                    s.loaders[id].pending = s.loaders[id].pending.filter(d => d !== loaderState);
+                  });
+                }
+              }
+            };
+          });
+          return router.store.loaders[id];
+        })();
+        return loader;
       }
+
+      // buildLink: (options) => {
+      //   return router.buildLink({
+      //     ...options,
+      //     from: fullPath,
+      //   } as any) as any
+      // },
+
+      // navigate: (options) => {
+      //   return router.navigate({
+      //     ...options,
+      //     from: fullPath,
+      //   } as any) as any
+      // },
+
+      // matchRoute: (matchLocation, opts) => {
+      //   return router.matchRoute(
+      //     {
+      //       ...matchLocation,
+      //       from: fullPath,
+      //     } as any,
+      //     opts,
+      //   ) as any
+      // },
     };
+
     router.options.createRoute == null ? void 0 : router.options.createRoute({
       router,
       route
@@ -1331,7 +1655,7 @@
   }
 
   const rootRouteId = '__root__';
-  const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId, parentPath) {
+  const createRouteConfig = function (options, children, isRoot, parentId, parentPath) {
     if (options === void 0) {
       options = {};
     }
@@ -1371,53 +1695,194 @@
       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. ");
+        invariant(false, `routeConfig.generate() is used by TanStack Router's file-based routing code generation and should not actually be called during runtime. `);
       }
     };
   };
 
+  /**
+   * 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 sharedClone(prev, next, touchAll) {
+    const things = new Map();
+    function recurse(prev, next) {
+      if (prev === next) {
+        return prev;
+      }
+      if (things.has(next)) {
+        return things.get(next);
+      }
+      const prevIsArray = Array.isArray(prev);
+      const nextIsArray = Array.isArray(next);
+      const prevIsObj = isPlainObject(prev);
+      const nextIsObj = isPlainObject(next);
+      const isArray = prevIsArray && nextIsArray;
+      const isObj = prevIsObj && nextIsObj;
+      const isSameStructure = isArray || isObj;
+
+      // Both are arrays or objects
+      if (isSameStructure) {
+        const aSize = isArray ? prev.length : Object.keys(prev).length;
+        const bItems = isArray ? next : Object.keys(next);
+        const bSize = bItems.length;
+        const copy = isArray ? [] : {};
+        let equalItems = 0;
+        for (let i = 0; i < bSize; i++) {
+          const key = isArray ? i : bItems[i];
+          if (copy[key] === prev[key]) {
+            equalItems++;
+          }
+        }
+        if (aSize === bSize && equalItems === aSize) {
+          things.set(next, prev);
+          return prev;
+        }
+        things.set(next, copy);
+        for (let i = 0; i < bSize; i++) {
+          const key = isArray ? i : bItems[i];
+          if (typeof bItems[i] === 'function') {
+            copy[key] = prev[key];
+          } else {
+            copy[key] = recurse(prev[key], next[key]);
+          }
+          if (copy[key] === prev[key]) {
+            equalItems++;
+          }
+        }
+        return copy;
+      }
+      if (nextIsArray) {
+        const copy = [];
+        things.set(next, copy);
+        for (let i = 0; i < next.length; i++) {
+          copy[i] = recurse(undefined, next[i]);
+        }
+        return copy;
+      }
+      if (nextIsObj) {
+        const copy = {};
+        things.set(next, copy);
+        const nextKeys = Object.keys(next);
+        for (let i = 0; i < nextKeys.length; i++) {
+          const key = nextKeys[i];
+          copy[key] = recurse(undefined, next[key]);
+        }
+        return copy;
+      }
+      return next;
+    }
+    return recurse(prev, 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]';
+  }
+
   const componentTypes = ['component', 'errorComponent', 'pendingComponent'];
   function createRouteMatch(router, route, opts) {
-    const routeMatch = _extends({}, route, opts, {
-      router,
+    let componentsPromise;
+    let dataPromise;
+    let latestId = '';
+    let resolve = () => {};
+    function setLoaderData(loaderData) {
+      batch(() => {
+        setStore(s => {
+          s.routeLoaderData = sharedClone(s.routeLoaderData, loaderData);
+        });
+        updateLoaderData();
+      });
+    }
+    function updateLoaderData() {
+      setStore(s => {
+        var _store$parentMatch;
+        s.loaderData = sharedClone(s.loaderData, {
+          ...((_store$parentMatch = store.parentMatch) == null ? void 0 : _store$parentMatch.store.loaderData),
+          ...s.routeLoaderData
+        });
+      });
+    }
+    const [store, setStore] = createStore({
       routeSearch: {},
       search: {},
-      childMatches: [],
       status: 'idle',
       routeLoaderData: {},
       loaderData: {},
       isFetching: false,
-      isInvalid: false,
+      invalid: false,
       invalidAt: Infinity,
-      // pendingActions: [],
-      getIsInvalid: () => {
+      get isInvalid() {
         const now = Date.now();
-        return routeMatch.isInvalid || routeMatch.invalidAt < now;
-      },
+        return this.invalid || this.invalidAt < now;
+      }
+    });
+    const routeMatch = {
+      ...route,
+      ...opts,
+      store,
+      // setStore,
+      router,
+      childMatches: [],
       __: {
-        abortController: new AbortController(),
-        latestId: '',
-        resolve: () => {},
-        notify: () => {
-          routeMatch.__.resolve();
-          routeMatch.router.notify();
+        setParentMatch: parentMatch => {
+          batch(() => {
+            setStore(s => {
+              s.parentMatch = parentMatch;
+            });
+            updateLoaderData();
+          });
         },
+        abortController: new AbortController(),
         validate: () => {
-          var _routeMatch$parentMat, _routeMatch$parentMat2;
+          var _store$parentMatch2;
           // 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.state.currentLocation.search;
+          const parentSearch = ((_store$parentMatch2 = store.parentMatch) == null ? void 0 : _store$parentMatch2.store.search) ?? router.store.currentLocation.search;
           try {
-            var _validator;
-            const prevSearch = routeMatch.routeSearch;
+            const prevSearch = store.routeSearch;
             const validator = typeof routeMatch.options.validateSearch === 'object' ? routeMatch.options.validateSearch.parse : routeMatch.options.validateSearch;
-            let nextSearch = replaceEqualDeep(prevSearch, (_validator = validator == null ? void 0 : validator(parentSearch)) != null ? _validator : {});
+            let nextSearch = sharedClone(prevSearch, (validator == null ? void 0 : validator(parentSearch)) ?? {});
+            batch(() => {
+              // Invalidate route matches when search param stability changes
+              if (prevSearch !== nextSearch) {
+                setStore(s => s.invalid = true);
+              }
 
-            // Invalidate route matches when search param stability changes
-            if (prevSearch !== nextSearch) {
-              routeMatch.isInvalid = true;
-            }
-            routeMatch.routeSearch = nextSearch;
-            routeMatch.search = replaceEqualDeep(parentSearch, _extends({}, parentSearch, nextSearch));
+              // TODO: Alright, do we need batch() here?
+              setStore(s => {
+                s.routeSearch = nextSearch;
+                s.search = sharedClone(parentSearch, {
+                  ...parentSearch,
+                  ...nextSearch
+                });
+              });
+            });
             componentTypes.map(async type => {
               const component = routeMatch.options[type];
               if (typeof routeMatch.__[type] !== 'function') {
@@ -1430,8 +1895,11 @@
               cause: err
             });
             error.code = 'INVALID_SEARCH_PARAMS';
-            routeMatch.status = 'error';
-            routeMatch.error = error;
+            setStore(s => {
+              s.status = 'error';
+              s.error = error;
+            });
+
             // Do not proceed with loading the route
             return;
           }
@@ -1442,7 +1910,7 @@
         (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
       },
       invalidate: () => {
-        routeMatch.isInvalid = true;
+        setStore(s => s.invalid = true);
       },
       hasLoaders: () => {
         return !!(route.options.loader || componentTypes.some(d => {
@@ -1457,17 +1925,17 @@
         // If this is a preload, add it to the preload cache
         if (loaderOpts != null && loaderOpts.preload && minMaxAge > 0) {
           // If the match is currently active, don't preload it
-          if (router.state.currentMatches.find(d => d.matchId === routeMatch.matchId)) {
+          if (router.store.currentMatches.find(d => d.matchId === routeMatch.matchId)) {
             return;
           }
-          router.matchCache[routeMatch.matchId] = {
+          router.store.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') {
+        if (store.status === 'success' && store.isInvalid || store.status === 'error' || store.status === 'idle') {
           const maxAge = loaderOpts != null && loaderOpts.preload ? loaderOpts == null ? void 0 : loaderOpts.maxAge : undefined;
           await routeMatch.fetch({
             maxAge
@@ -1476,29 +1944,30 @@
       },
       fetch: async opts => {
         const loadId = '' + Date.now() + Math.random();
-        routeMatch.__.latestId = loadId;
+        latestId = loadId;
         const checkLatest = async () => {
-          if (loadId !== routeMatch.__.latestId) {
+          if (loadId !== latestId) {
             // warning(true, 'Data loader is out of date!')
             return new Promise(() => {});
           }
         };
+        batch(() => {
+          // If the match was in an error state, set it
+          // to a loading state again. Otherwise, keep it
+          // as loading or resolved
+          if (store.status === 'idle') {
+            setStore(s => s.status = 'loading');
+          }
 
-        // If the match was in an error state, set it
-        // to a loading state again. Otherwise, keep it
-        // as loading or resolved
-        if (routeMatch.status === 'idle') {
-          routeMatch.status = 'loading';
-        }
-
-        // We started loading the route, so it's no longer invalid
-        routeMatch.isInvalid = false;
-        routeMatch.__.loadPromise = new Promise(async resolve => {
+          // We started loading the route, so it's no longer invalid
+          setStore(s => s.invalid = false);
+        });
+        routeMatch.__.loadPromise = new Promise(async r => {
           // We are now fetching, even if it's in the background of a
           // resolved state
-          routeMatch.isFetching = true;
-          routeMatch.__.resolve = resolve;
-          routeMatch.__.componentsPromise = (async () => {
+          setStore(s => s.isFetching = true);
+          resolve = r;
+          componentsPromise = (async () => {
             // then run all component and data loaders in parallel
             // For each component type, potentially load it asynchronously
 
@@ -1510,49 +1979,52 @@
               }
             }));
           })();
-          routeMatch.__.dataPromise = Promise.resolve().then(async () => {
+          dataPromise = Promise.resolve().then(async () => {
             try {
-              var _ref, _ref2, _opts$maxAge;
               if (routeMatch.options.loader) {
                 const data = await router.loadMatchData(routeMatch);
                 await checkLatest();
-                routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
+                setLoaderData(data);
               }
-              routeMatch.error = undefined;
-              routeMatch.status = 'success';
-              routeMatch.updatedAt = Date.now();
-              routeMatch.invalidAt = routeMatch.updatedAt + ((_ref = (_ref2 = (_opts$maxAge = opts == null ? void 0 : opts.maxAge) != null ? _opts$maxAge : routeMatch.options.loaderMaxAge) != null ? _ref2 : router.options.defaultLoaderMaxAge) != null ? _ref : 0);
-              return routeMatch.routeLoaderData;
+              setStore(s => {
+                s.error = undefined;
+                s.status = 'success';
+                s.updatedAt = Date.now();
+                s.invalidAt = s.updatedAt + ((opts == null ? void 0 : opts.maxAge) ?? routeMatch.options.loaderMaxAge ?? router.options.defaultLoaderMaxAge ?? 0);
+              });
+              return store.routeLoaderData;
             } catch (err) {
               await checkLatest();
               {
                 console.error(err);
               }
-              routeMatch.error = err;
-              routeMatch.status = 'error';
-              routeMatch.updatedAt = Date.now();
+              setStore(s => {
+                s.error = err;
+                s.status = 'error';
+                s.updatedAt = Date.now();
+              });
               throw err;
             }
           });
           const after = async () => {
             await checkLatest();
-            routeMatch.isFetching = false;
+            setStore(s => s.isFetching = false);
             delete routeMatch.__.loadPromise;
-            routeMatch.__.notify();
+            resolve();
           };
           try {
-            await Promise.all([routeMatch.__.componentsPromise, routeMatch.__.dataPromise.catch(() => {})]);
+            await Promise.all([componentsPromise, dataPromise.catch(() => {})]);
             after();
-          } catch (_unused) {
+          } catch {
             after();
           }
         });
         await routeMatch.__.loadPromise;
         await checkLatest();
       }
-    });
+    };
     if (!routeMatch.hasLoaders()) {
-      routeMatch.status = 'success';
+      setStore(s => s.status = 'success');
     }
     return routeMatch;
   }
@@ -1582,7 +2054,9 @@
   }
   function stringifySearchWith(stringify) {
     return search => {
-      search = _extends({}, search);
+      search = {
+        ...search
+      };
       if (search) {
         Object.keys(search).forEach(key => {
           const val = search[key];
@@ -1598,7 +2072,7 @@
         });
       }
       const searchStr = encode(search).toString();
-      return searchStr ? "?" + searchStr : '';
+      return searchStr ? `?${searchStr}` : '';
     };
   }
 
@@ -1617,177 +2091,277 @@
       actions: {},
       loaders: {},
       lastUpdated: Date.now(),
-      isFetching: false,
-      isPreloading: false
+      matchCache: {},
+      get isFetching() {
+        return this.status === 'loading' || this.currentMatches.some(d => d.store.isFetching);
+      },
+      get isPreloading() {
+        return Object.values(this.matchCache).some(d => d.match.store.isFetching && !this.currentMatches.find(dd => dd.matchId === d.match.matchId));
+      }
     };
   }
   function createRouter(userOptions) {
-    var _userOptions$stringif, _userOptions$parseSea;
-    const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
-    const originalOptions = _extends({
+    const originalOptions = {
       defaultLoaderGcMaxAge: 5 * 60 * 1000,
       defaultLoaderMaxAge: 0,
       defaultPreloadMaxAge: 2000,
       defaultPreloadDelay: 50,
-      context: undefined
-    }, 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 = {
+      context: undefined,
+      ...userOptions,
+      stringifySearch: (userOptions == null ? void 0 : userOptions.stringifySearch) ?? defaultStringifySearch,
+      parseSearch: (userOptions == null ? void 0 : userOptions.parseSearch) ?? defaultParseSearch
+    };
+    const [store, setStore] = createStore(getInitialRouterState());
+    let navigationPromise;
+    let startedLoadingAt = Date.now();
+    let resolveNavigation = () => {};
+    function onFocus() {
+      router.load();
+    }
+    function buildRouteTree(rootRouteConfig) {
+      const recurseRoutes = (routeConfigs, parent) => {
+        return routeConfigs.map((routeConfig, i) => {
+          const routeOptions = routeConfig.options;
+          const route = createRoute(routeConfig, routeOptions, i, parent, router);
+          const existingRoute = router.routesById[route.routeId];
+          if (existingRoute) {
+            {
+              console.warn(`Duplicate routes found with id: ${String(route.routeId)}`, router.routesById, route);
+            }
+            throw new Error();
+          }
+          router.routesById[route.routeId] = route;
+          const children = routeConfig.children;
+          route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
+          return route;
+        });
+      };
+      const routes = recurseRoutes([rootRouteConfig]);
+      return routes[0];
+    }
+    function parseLocation(location, previousLocation) {
+      const parsedSearch = router.options.parseSearch(location.search);
+      return {
+        pathname: location.pathname,
+        searchStr: location.search,
+        search: sharedClone(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
+        hash: location.hash.split('#').reverse()[0] ?? '',
+        href: `${location.pathname}${location.search}${location.hash}`,
+        state: location.state,
+        key: location.key
+      };
+    }
+    function navigate(location) {
+      const next = router.buildNext(location);
+      return commitLocation(next, location.replace);
+    }
+    function buildLocation(dest) {
+      var _last, _dest$__preSearchFilt, _dest$__preSearchFilt2, _dest$__postSearchFil;
+      if (dest === void 0) {
+        dest = {};
+      }
+      const fromPathname = dest.fromCurrent ? store.latestLocation.pathname : dest.from ?? store.latestLocation.pathname;
+      let pathname = resolvePath(router.basepath ?? '/', fromPathname, `${dest.to ?? '.'}`);
+      const fromMatches = router.matchRoutes(store.latestLocation.pathname, {
+        strictParseParams: true
+      });
+      const toMatches = router.matchRoutes(pathname);
+      const prevParams = {
+        ...((_last = last(fromMatches)) == null ? void 0 : _last.params)
+      };
+      let nextParams = (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));
+        });
+      }
+      pathname = interpolatePath(pathname, nextParams ?? {});
+
+      // Pre filters first
+      const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), store.latestLocation.search) : store.latestLocation.search;
+
+      // Then the link/navigate function
+      const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
+      : dest.search ? functionalUpdate(dest.search, preFilteredSearch) ?? {} // 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 = sharedClone(store.latestLocation.search, postFilteredSearch);
+      const searchStr = router.options.stringifySearch(search);
+      let hash = dest.hash === true ? store.latestLocation.hash : functionalUpdate(dest.hash, store.latestLocation.hash);
+      hash = hash ? `#${hash}` : '';
+      return {
+        pathname,
+        search,
+        searchStr,
+        state: store.latestLocation.state,
+        hash,
+        href: `${pathname}${searchStr}${hash}`,
+        key: dest.key
+      };
+    }
+    function commitLocation(next, replace) {
+      const id = '' + Date.now() + Math.random();
+      let nextAction = 'replace';
+      if (!replace) {
+        nextAction = 'push';
+      }
+      const isSameUrl = parseLocation(router.history.location).href === next.href;
+      if (isSameUrl && !next.key) {
+        nextAction = 'replace';
+      }
+      router.history[nextAction]({
+        pathname: next.pathname,
+        hash: next.hash,
+        search: next.searchStr
+      }, {
+        id,
+        ...next.state
+      });
+      return navigationPromise = new Promise(resolve => {
+        const previousNavigationResolve = resolveNavigation;
+        resolveNavigation = () => {
+          previousNavigationResolve();
+          resolve();
+        };
+      });
+    }
+    const router = {
       types: undefined,
       // public api
-      history,
+      history: (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory(),
+      store,
+      setStore,
       options: originalOptions,
-      listeners: [],
-      // Resolved after construction
       basepath: '',
       routeTree: undefined,
       routesById: {},
-      //
-      resolveNavigation: () => {},
-      matchCache: {},
-      state: getInitialRouterState(),
       reset: () => {
-        router.state = getInitialRouterState();
-        router.notify();
-      },
-      startedLoadingAt: Date.now(),
-      subscribe: listener => {
-        router.listeners.push(listener);
-        return () => {
-          router.listeners = router.listeners.filter(x => x !== listener);
-        };
+        setStore(s => Object.assign(s, getInitialRouterState()));
       },
       getRoute: id => {
         return router.routesById[id];
       },
-      notify: () => {
-        const isFetching = router.state.status === 'loading' || router.state.currentMatches.some(d => d.isFetching);
-        const isPreloading = Object.values(router.matchCache).some(d => d.match.isFetching && !router.state.currentMatches.find(dd => dd.matchId === d.match.matchId));
-        if (router.state.isFetching !== isFetching || router.state.isPreloading !== isPreloading) {
-          router.state = _extends({}, router.state, {
-            isFetching,
-            isPreloading
-          });
-        }
-        cascadeLoaderData(router.state.currentMatches);
-        router.listeners.forEach(listener => listener(router));
-      },
       dehydrate: () => {
         return {
-          state: _extends({}, pick(router.state, ['latestLocation', 'currentLocation', 'status', 'lastUpdated']), {
-            currentMatches: router.state.currentMatches.map(match => pick(match, ['matchId', 'status', 'routeLoaderData', 'loaderData', 'isInvalid', 'invalidAt']))
-          }),
+          store: {
+            ...pick(store, ['latestLocation', 'currentLocation', 'status', 'lastUpdated']),
+            currentMatches: store.currentMatches.map(match => ({
+              matchId: match.matchId,
+              store: pick(match.store, ['status', 'routeLoaderData', 'isInvalid', 'invalidAt'])
+            }))
+          },
           context: router.options.context
         };
       },
-      hydrate: dehydratedState => {
-        // Update the location
-        router.state.latestLocation = dehydratedState.state.latestLocation;
-        router.state.currentLocation = dehydratedState.state.currentLocation;
+      hydrate: dehydratedRouter => {
+        setStore(s => {
+          // Update the context TODO: make this part of state?
+          router.options.context = dehydratedRouter.context;
 
-        // Update the context
-        router.options.context = dehydratedState.context;
-
-        // Match the routes
-        const currentMatches = router.matchRoutes(router.state.latestLocation.pathname, {
-          strictParseParams: true
-        });
-        currentMatches.forEach((match, index) => {
-          const dehydratedMatch = dehydratedState.state.currentMatches[index];
-          invariant(dehydratedMatch, 'Oh no! Dehydrated route matches did not match the active state of the router 😬');
-          Object.assign(match, dehydratedMatch);
-        });
-        currentMatches.forEach(match => match.__.validate());
-        router.state = _extends({}, router.state, dehydratedState, {
-          currentMatches
+          // Match the routes
+          const currentMatches = router.matchRoutes(dehydratedRouter.store.latestLocation.pathname, {
+            strictParseParams: true
+          });
+          currentMatches.forEach((match, index) => {
+            const dehydratedMatch = dehydratedRouter.store.currentMatches[index];
+            invariant(dehydratedMatch && dehydratedMatch.matchId === match.matchId, 'Oh no! There was a hydration mismatch when attempting to restore the state of the router! 😬');
+            Object.assign(match, dehydratedMatch);
+          });
+          currentMatches.forEach(match => match.__.validate());
+          Object.assign(s, {
+            ...dehydratedRouter.store,
+            currentMatches
+          });
         });
       },
       mount: () => {
-        if (!router.state.currentMatches.length) {
-          router.load();
-        }
-        const unsub = router.history.listen(event => {
-          router.load(router.__.parseLocation(event.location, router.state.latestLocation));
-        });
+        // Mount only does anything on the client
+        if (!isServer) {
+          // If the router matches are empty, load the matches
+          if (!store.currentMatches.length) {
+            router.load();
+          }
+          const unsub = router.history.listen(event => {
+            router.load(parseLocation(event.location, store.latestLocation));
+          });
 
-        // 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 () => {
-          unsub();
-          if (!isServer && window.removeEventListener) {
-            // Be sure to unsubscribe if a new handler is set
-            window.removeEventListener('visibilitychange', router.onFocus);
-            window.removeEventListener('focus', router.onFocus);
+          // 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('visibilitychange', onFocus, false);
+            window.addEventListener('focus', onFocus, false);
           }
-        };
-      },
-      onFocus: () => {
-        router.load();
+          return () => {
+            unsub();
+            if (window.removeEventListener) {
+              // Be sure to unsubscribe if a new handler is set
+              window.removeEventListener('visibilitychange', onFocus);
+              window.removeEventListener('focus', onFocus);
+            }
+          };
+        }
+        return () => {};
       },
       update: opts => {
-        var _trimPath;
         const newHistory = (opts == null ? void 0 : opts.history) !== router.history;
-        if (!router.state.latestLocation || newHistory) {
+        if (!store.latestLocation || newHistory) {
           if (opts != null && opts.history) {
             router.history = opts.history;
           }
-          router.state.latestLocation = router.__.parseLocation(router.history.location);
-          router.state.currentLocation = router.state.latestLocation;
+          setStore(s => {
+            s.latestLocation = parseLocation(router.history.location);
+            s.currentLocation = s.latestLocation;
+          });
         }
         Object.assign(router.options, opts);
         const {
           basepath,
           routeConfig
         } = router.options;
-        router.basepath = "/" + ((_trimPath = trimPath(basepath != null ? basepath : '')) != null ? _trimPath : '');
+        router.basepath = `/${trimPath(basepath ?? '') ?? ''}`;
         if (routeConfig) {
           router.routesById = {};
-          router.routeTree = router.__.buildRouteTree(routeConfig);
+          router.routeTree = buildRouteTree(routeConfig);
         }
         return router;
       },
       cancelMatches: () => {
-        var _router$state$pending;
-        [...router.state.currentMatches, ...((_router$state$pending = router.state.pendingMatches) != null ? _router$state$pending : [])].forEach(match => {
+        [...store.currentMatches, ...(store.pendingMatches || [])].forEach(match => {
           match.cancel();
         });
       },
       load: async next => {
-        const id = Math.random();
-        router.startedLoadingAt = id;
-        if (next) {
-          // Ingest the new location
-          router.state.latestLocation = next;
-        }
+        let now = Date.now();
+        const startedAt = now;
+        startedLoadingAt = startedAt;
 
         // Cancel any pending matches
         router.cancelMatches();
+        let matches;
+        batch(() => {
+          if (next) {
+            // Ingest the new location
+            setStore(s => {
+              s.latestLocation = next;
+            });
+          }
 
-        // Match the routes
-        const matches = router.matchRoutes(router.state.latestLocation.pathname, {
-          strictParseParams: true
-        });
-        if (typeof document !== 'undefined') {
-          router.state = _extends({}, router.state, {
-            status: 'loading',
-            pendingMatches: matches,
-            pendingLocation: router.state.latestLocation
+          // Match the routes
+          matches = router.matchRoutes(store.latestLocation.pathname, {
+            strictParseParams: true
           });
-        } else {
-          router.state = _extends({}, router.state, {
-            status: 'loading',
-            currentMatches: matches,
-            currentLocation: router.state.latestLocation
+          console.log('set loading', matches);
+          setStore(s => {
+            s.status = 'loading';
+            s.pendingMatches = matches;
+            s.pendingLocation = store.latestLocation;
           });
-        }
-        router.notify();
+        });
 
         // Load the matches
         try {
@@ -1796,11 +2370,11 @@
           console.log(err);
           invariant(false, 'Matches failed to load due to error above ☝️. Navigation cancelled!');
         }
-        if (router.startedLoadingAt !== id) {
-          // Ignore side-effects of match loading
-          return router.navigationPromise;
+        if (startedLoadingAt !== startedAt) {
+          // Ignore side-effects of outdated side-effects
+          return navigationPromise;
         }
-        const previousMatches = router.state.currentMatches;
+        const previousMatches = store.currentMatches;
         const exiting = [],
           staying = [];
         previousMatches.forEach(d => {
@@ -1813,22 +2387,21 @@
         const entering = matches.filter(d => {
           return !previousMatches.find(dd => dd.matchId === d.matchId);
         });
-        const now = Date.now();
+        now = Date.now();
         exiting.forEach(d => {
-          var _ref, _d$options$loaderGcMa, _ref2, _d$options$loaderMaxA;
           d.__.onExit == null ? void 0 : d.__.onExit({
             params: d.params,
-            search: d.routeSearch
+            search: d.store.routeSearch
           });
 
           // Clear idle error states when match leaves
-          if (d.status === 'error' && !d.isFetching) {
-            d.status = 'idle';
-            d.error = undefined;
+          if (d.store.status === 'error' && !d.store.isFetching) {
+            d.store.status = 'idle';
+            d.store.error = undefined;
           }
-          const gc = Math.max((_ref = (_d$options$loaderGcMa = d.options.loaderGcMaxAge) != null ? _d$options$loaderGcMa : router.options.defaultLoaderGcMaxAge) != null ? _ref : 0, (_ref2 = (_d$options$loaderMaxA = d.options.loaderMaxAge) != null ? _d$options$loaderMaxA : router.options.defaultLoaderMaxAge) != null ? _ref2 : 0);
+          const gc = Math.max(d.options.loaderGcMaxAge ?? router.options.defaultLoaderGcMaxAge ?? 0, d.options.loaderMaxAge ?? router.options.defaultLoaderMaxAge ?? 0);
           if (gc > 0) {
-            router.matchCache[d.matchId] = {
+            store.matchCache[d.matchId] = {
               gc: gc == Infinity ? Number.MAX_SAFE_INTEGER : now + gc,
               match: d
             };
@@ -1837,59 +2410,64 @@
         staying.forEach(d => {
           d.options.onTransition == null ? void 0 : d.options.onTransition({
             params: d.params,
-            search: d.routeSearch
+            search: d.store.routeSearch
           });
         });
         entering.forEach(d => {
           d.__.onExit = d.options.onLoaded == null ? void 0 : d.options.onLoaded({
             params: d.params,
-            search: d.search
+            search: d.store.search
           });
-          delete router.matchCache[d.matchId];
+          delete store.matchCache[d.matchId];
         });
-        if (router.startedLoadingAt !== id) {
+        if (startedLoadingAt !== startedAt) {
           // Ignore side-effects of match loading
           return;
         }
         matches.forEach(match => {
           // Clear actions
           if (match.action) {
+            // TODO: Check reactivity here
             match.action.current = undefined;
             match.action.submissions = [];
           }
         });
-        router.state = _extends({}, router.state, {
-          status: 'idle',
-          currentLocation: router.state.latestLocation,
-          currentMatches: matches,
-          pendingLocation: undefined,
-          pendingMatches: undefined
+        setStore(s => {
+          console.log('set', matches);
+          Object.assign(s, {
+            status: 'idle',
+            currentLocation: store.latestLocation,
+            currentMatches: matches,
+            pendingLocation: undefined,
+            pendingMatches: undefined
+          });
         });
-        router.notify();
-        router.resolveNavigation();
+        resolveNavigation();
       },
       cleanMatchCache: () => {
         const now = Date.now();
-        Object.keys(router.matchCache).forEach(matchId => {
-          const entry = router.matchCache[matchId];
+        setStore(s => {
+          Object.keys(s.matchCache).forEach(matchId => {
+            const entry = s.matchCache[matchId];
 
-          // Don't remove loading matches
-          if (entry.match.status === 'loading') {
-            return;
-          }
+            // Don't remove loading matches
+            if (entry.match.store.status === 'loading') {
+              return;
+            }
 
-          // Do not remove successful matches that are still valid
-          if (entry.gc > 0 && entry.gc > now) {
-            return;
-          }
+            // Do not remove successful matches that are still valid
+            if (entry.gc > 0 && entry.gc > now) {
+              return;
+            }
 
-          // Everything else gets removed
-          delete router.matchCache[matchId];
+            // Everything else gets removed
+            delete s.matchCache[matchId];
+          });
         });
       },
-      loadRoute: async function loadRoute(navigateOpts) {
+      loadRoute: async function (navigateOpts) {
         if (navigateOpts === void 0) {
-          navigateOpts = router.state.latestLocation;
+          navigateOpts = store.latestLocation;
         }
         const next = router.buildNext(navigateOpts);
         const matches = router.matchRoutes(next.pathname, {
@@ -1898,10 +2476,9 @@
         await router.loadMatches(matches);
         return matches;
       },
-      preloadRoute: async function preloadRoute(navigateOpts, loaderOpts) {
-        var _ref3, _ref4, _loaderOpts$maxAge, _ref5, _ref6, _loaderOpts$gcMaxAge;
+      preloadRoute: async function (navigateOpts, loaderOpts) {
         if (navigateOpts === void 0) {
-          navigateOpts = router.state.latestLocation;
+          navigateOpts = store.latestLocation;
         }
         const next = router.buildNext(navigateOpts);
         const matches = router.matchRoutes(next.pathname, {
@@ -1909,28 +2486,27 @@
         });
         await router.loadMatches(matches, {
           preload: true,
-          maxAge: (_ref3 = (_ref4 = (_loaderOpts$maxAge = loaderOpts.maxAge) != null ? _loaderOpts$maxAge : router.options.defaultPreloadMaxAge) != null ? _ref4 : router.options.defaultLoaderMaxAge) != null ? _ref3 : 0,
-          gcMaxAge: (_ref5 = (_ref6 = (_loaderOpts$gcMaxAge = loaderOpts.gcMaxAge) != null ? _loaderOpts$gcMaxAge : router.options.defaultPreloadGcMaxAge) != null ? _ref6 : router.options.defaultLoaderGcMaxAge) != null ? _ref5 : 0
+          maxAge: loaderOpts.maxAge ?? router.options.defaultPreloadMaxAge ?? router.options.defaultLoaderMaxAge ?? 0,
+          gcMaxAge: loaderOpts.gcMaxAge ?? router.options.defaultPreloadGcMaxAge ?? router.options.defaultLoaderGcMaxAge ?? 0
         });
         return matches;
       },
       matchRoutes: (pathname, opts) => {
-        var _router$state$pending2;
         router.cleanMatchCache();
         const matches = [];
         if (!router.routeTree) {
           return matches;
         }
-        const existingMatches = [...router.state.currentMatches, ...((_router$state$pending2 = router.state.pendingMatches) != null ? _router$state$pending2 : [])];
+        const existingMatches = [...store.currentMatches, ...(store.pendingMatches ?? [])];
         const recurse = async routes => {
-          var _parentMatch$params, _router$options$filte, _foundRoute$childRout;
+          var _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 == null ? void 0 : parentMatch.params) ?? {};
+          const filteredRoutes = (router.options.filterRoutes == null ? void 0 : router.options.filterRoutes(routes)) ?? routes;
           let foundRoutes = [];
           const findMatchInRoutes = (parentRoutes, routes) => {
             routes.some(route => {
-              var _route$childRoutes, _route$childRoutes2, _route$options$caseSe;
+              var _route$childRoutes, _route$childRoutes2;
               if (!route.routePath && (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length) {
                 return findMatchInRoutes([...foundRoutes, route], route.childRoutes);
               }
@@ -1938,28 +2514,21 @@
               const matchParams = matchPathname(router.basepath, pathname, {
                 to: route.fullPath,
                 fuzzy,
-                caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
+                caseSensitive: route.options.caseSensitive ?? router.options.caseSensitive
               });
-
-              // console.log(
-              //   router.basepath,
-              //   route.fullPath,
-              //   fuzzy,
-              //   pathname,
-              //   matchParams,
-              // )
-
               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 == null ? void 0 : route.options.parseParams(matchParams)) ?? matchParams;
                 } catch (err) {
                   if (opts != null && opts.strictParseParams) {
                     throw err;
                   }
                 }
-                params = _extends({}, params, parsedParams);
+                params = {
+                  ...params,
+                  ...parsedParams
+                };
               }
               if (!!matchParams) {
                 foundRoutes = [...parentRoutes, route];
@@ -1973,10 +2542,10 @@
             return;
           }
           foundRoutes.forEach(foundRoute => {
-            var _router$matchCache$ma;
+            var _store$matchCache$mat;
             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 match = existingMatches.find(d => d.matchId === matchId) || ((_store$matchCache$mat = store.matchCache[matchId]) == null ? void 0 : _store$matchCache$mat.match) || createRouteMatch(router, foundRoute, {
               parentMatch,
               matchId,
               params,
@@ -1990,7 +2559,7 @@
           }
         };
         recurse([router.routeTree]);
-        cascadeLoaderData(matches);
+        linkMatches(matches);
         return matches;
       },
       loadMatches: async (resolvedMatches, loaderOpts) => {
@@ -2015,32 +2584,31 @@
         }));
         const matchPromises = resolvedMatches.map(async match => {
           var _search$__data;
-          const search = match.search;
+          const search = match.store.search;
           if ((_search$__data = search.__data) != null && _search$__data.matchId && search.__data.matchId !== match.matchId) {
             return;
           }
           match.load(loaderOpts);
-          if (match.status !== 'success' && match.__.loadPromise) {
+          if (match.store.status !== 'success' && match.__.loadPromise) {
             // Wait for the first sign of activity from the match
             await match.__.loadPromise;
           }
         });
-        router.notify();
         await Promise.all(matchPromises);
       },
       loadMatchData: async routeMatch => {
         if (isServer || !router.options.useServerData) {
-          var _await$routeMatch$opt;
-          return (_await$routeMatch$opt = await (routeMatch.options.loader == null ? void 0 : routeMatch.options.loader({
+          return (await (routeMatch.options.loader == null ? void 0 : routeMatch.options.loader({
             // parentLoaderPromise: routeMatch.parentMatch?.__.dataPromise,
             params: routeMatch.params,
-            search: routeMatch.routeSearch,
+            search: routeMatch.store.routeSearch,
             signal: routeMatch.__.abortController.signal
-          }))) != null ? _await$routeMatch$opt : {};
+          }))) || {};
         } else {
           const next = router.buildNext({
             to: '.',
-            search: d => _extends({}, d != null ? d : {}, {
+            search: d => ({
+              ...(d ?? {}),
               __data: {
                 matchId: routeMatch.matchId
               }
@@ -2069,16 +2637,15 @@
         }
       },
       invalidateRoute: opts => {
-        var _router$state$pending3;
         const next = router.buildNext(opts);
         const unloadedMatchIds = router.matchRoutes(next.pathname).map(d => d.matchId);
-        [...router.state.currentMatches, ...((_router$state$pending3 = router.state.pendingMatches) != null ? _router$state$pending3 : [])].forEach(match => {
+        [...store.currentMatches, ...(store.pendingMatches ?? [])].forEach(match => {
           if (unloadedMatchIds.includes(match.matchId)) {
             match.invalidate();
           }
         });
       },
-      reload: () => router.__.navigate({
+      reload: () => navigate({
         fromCurrent: true,
         replace: true,
         search: true
@@ -2087,26 +2654,28 @@
         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
-        });
+        location = {
+          ...location,
+          to: location.to ? router.resolvePath(location.from ?? '', location.to) : undefined
+        };
         const next = router.buildNext(location);
         if (opts != null && opts.pending) {
-          if (!router.state.pendingLocation) {
+          if (!store.pendingLocation) {
             return false;
           }
-          return !!matchPathname(router.basepath, router.state.pendingLocation.pathname, _extends({}, opts, {
+          return !!matchPathname(router.basepath, store.pendingLocation.pathname, {
+            ...opts,
             to: next.pathname
-          }));
+          });
         }
-        return !!matchPathname(router.basepath, router.state.currentLocation.pathname, _extends({}, opts, {
+        return matchPathname(router.basepath, store.currentLocation.pathname, {
+          ...opts,
           to: next.pathname
-        }));
+        });
       },
-      navigate: async _ref7 => {
+      navigate: async _ref => {
         let {
           from,
           to = '.',
@@ -2114,7 +2683,7 @@
           hash,
           replace,
           params
-        } = _ref7;
+        } = _ref;
         // If this link simply reloads the current route,
         // make sure it has a new key so it will trigger a data refresh
 
@@ -2124,11 +2693,11 @@
         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({
+        return navigate({
           from: fromString,
           to: toString,
           search,
@@ -2137,8 +2706,7 @@
           params
         });
       },
-      buildLink: _ref8 => {
-        var _preload, _ref9;
+      buildLink: _ref2 => {
         let {
           from,
           to = '.',
@@ -2153,7 +2721,7 @@
           preloadGcMaxAge: userPreloadGcMaxAge,
           preloadDelay: userPreloadDelay,
           disabled
-        } = _ref8;
+        } = _ref2;
         // If this link simply reloads the current route,
         // make sure it has a new key so it will trigger a data refresh
 
@@ -2161,7 +2729,7 @@
         // null for LinkUtils
 
         try {
-          new URL("" + to);
+          new URL(`${to}`);
           return {
             type: 'external',
             href: to
@@ -2176,15 +2744,15 @@
           replace
         };
         const next = router.buildNext(nextOpts);
-        preload = (_preload = preload) != null ? _preload : router.options.defaultPreload;
-        const preloadDelay = (_ref9 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultPreloadDelay) != null ? _ref9 : 0;
+        preload = preload ?? router.options.defaultPreload;
+        const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0;
 
         // Compare path/hash for matches
-        const pathIsEqual = router.state.currentLocation.pathname === next.pathname;
-        const currentPathSplit = router.state.currentLocation.pathname.split('/');
+        const pathIsEqual = store.currentLocation.pathname === next.pathname;
+        const currentPathSplit = store.currentLocation.pathname.split('/');
         const nextPathSplit = next.pathname.split('/');
         const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
-        const hashIsEqual = router.state.currentLocation.hash === next.hash;
+        const hashIsEqual = store.currentLocation.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;
@@ -2200,8 +2768,8 @@
               router.invalidateRoute(nextOpts);
             }
 
-            // All is well? Navigate!)
-            router.__.navigate(nextOpts);
+            // All is well? Navigate!
+            navigate(nextOpts);
           }
         };
 
@@ -2254,143 +2822,15 @@
         };
       },
       buildNext: opts => {
-        const next = router.__.buildLocation(opts);
+        const next = buildLocation(opts);
         const matches = router.matchRoutes(next.pathname);
-        const __preSearchFilters = matches.map(match => {
-          var _match$options$preSea;
-          return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
-        }).flat().filter(Boolean);
-        const __postSearchFilters = matches.map(match => {
-          var _match$options$postSe;
-          return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
-        }).flat().filter(Boolean);
-        return router.__.buildLocation(_extends({}, opts, {
+        const __preSearchFilters = matches.map(match => match.options.preSearchFilters ?? []).flat().filter(Boolean);
+        const __postSearchFilters = matches.map(match => match.options.postSearchFilters ?? []).flat().filter(Boolean);
+        return buildLocation({
+          ...opts,
           __preSearchFilters,
           __postSearchFilters
-        }));
-      },
-      __: {
-        buildRouteTree: rootRouteConfig => {
-          const recurseRoutes = (routeConfigs, parent) => {
-            return routeConfigs.map(routeConfig => {
-              const routeOptions = routeConfig.options;
-              const route = createRoute(routeConfig, routeOptions, parent, router);
-              const existingRoute = router.routesById[route.routeId];
-              if (existingRoute) {
-                {
-                  console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
-                }
-                throw new Error();
-              }
-              router.routesById[route.routeId] = route;
-              const children = routeConfig.children;
-              route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
-              return route;
-            });
-          };
-          const routes = recurseRoutes([rootRouteConfig]);
-          return routes[0];
-        },
-        parseLocation: (location, previousLocation) => {
-          var _location$hash$split$;
-          const parsedSearch = router.options.parseSearch(location.search);
-          return {
-            pathname: location.pathname,
-            searchStr: location.search,
-            search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
-            hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
-            href: "" + location.pathname + location.search + location.hash,
-            state: location.state,
-            key: location.key
-          };
-        },
-        navigate: location => {
-          const next = router.buildNext(location);
-          return router.__.commitLocation(next, location.replace);
-        },
-        buildLocation: function buildLocation(dest) {
-          var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
-          if (dest === void 0) {
-            dest = {};
-          }
-          const fromPathname = dest.fromCurrent ? router.state.latestLocation.pathname : (_dest$from = dest.from) != null ? _dest$from : router.state.latestLocation.pathname;
-          let pathname = resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
-          const fromMatches = router.matchRoutes(router.state.latestLocation.pathname, {
-            strictParseParams: true
-          });
-          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));
-            });
-          }
-          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.state.latestLocation.search) : router.state.latestLocation.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.state.latestLocation.search, postFilteredSearch);
-          const searchStr = router.options.stringifySearch(search);
-          let hash = dest.hash === true ? router.state.latestLocation.hash : functionalUpdate(dest.hash, router.state.latestLocation.hash);
-          hash = hash ? "#" + hash : '';
-          return {
-            pathname,
-            search,
-            searchStr,
-            state: router.state.latestLocation.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
-            }, _extends({
-              id
-            }, next.state));
-          } else {
-            history.push({
-              pathname: next.pathname,
-              hash: next.hash,
-              search: next.searchStr
-            }, {
-              id
-            });
-          }
-          router.navigationPromise = new Promise(resolve => {
-            const previousNavigationResolve = router.resolveNavigation;
-            router.resolveNavigation = () => {
-              previousNavigationResolve();
-              resolve();
-              delete router.navigationPromise;
-            };
-          });
-          return router.navigationPromise;
-        }
+        });
       }
     };
     router.update(userOptions);
@@ -2402,272 +2842,326 @@
   function isCtrlEvent(e) {
     return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
   }
-  function cascadeLoaderData(matches) {
+  function linkMatches(matches) {
     matches.forEach((match, index) => {
       const parent = matches[index - 1];
       if (parent) {
-        match.loaderData = replaceEqualDeep(match.loaderData, _extends({}, parent.loaderData, match.routeLoaderData));
+        match.__.setParentMatch(parent);
+      } else {
+        match.__.setParentMatch(undefined);
       }
     });
   }
 
-  const _excluded = ["type", "children", "target", "activeProps", "inactiveProps", "activeOptions", "disabled", "hash", "search", "params", "to", "preload", "preloadDelay", "preloadMaxAge", "replace", "style", "className", "onClick", "onFocus", "onMouseEnter", "onMouseLeave", "onTouchStart", "onTouchEnd"],
-    _excluded2 = ["pending", "caseSensitive", "children"],
-    _excluded3 = ["router"];
   function lazy(importer) {
     const lazyComp = /*#__PURE__*/React__namespace.lazy(importer);
-    let promise;
-    let resolvedComp;
-    const forwardedComp = /*#__PURE__*/React__namespace.forwardRef((props, ref) => {
-      const resolvedCompRef = React__namespace.useRef(resolvedComp || lazyComp);
-      return /*#__PURE__*/React__namespace.createElement(resolvedCompRef.current, _extends$2({}, ref ? {
-        ref
-      } : {}, props));
-    });
-    const finalComp = forwardedComp;
-    finalComp.preload = () => {
-      if (!promise) {
-        promise = importer().then(module => {
-          resolvedComp = module.default;
-          return resolvedComp;
-        });
+    const finalComp = lazyComp;
+    finalComp.preload = async () => {
+      {
+        await importer();
       }
-      return promise;
     };
     return finalComp;
   }
   //
 
-  function Link(props) {
+  function useLinkProps(options) {
     const router = useRouter();
-    return /*#__PURE__*/React__namespace.createElement(router.Link, props);
+    const {
+      // custom props
+      type,
+      children,
+      target,
+      activeProps = () => ({
+        className: 'active'
+      }),
+      inactiveProps = () => ({}),
+      activeOptions,
+      disabled,
+      // fromCurrent,
+      hash,
+      search,
+      params,
+      to,
+      preload,
+      preloadDelay,
+      preloadMaxAge,
+      replace,
+      // element props
+      style,
+      className,
+      onClick,
+      onFocus,
+      onMouseEnter,
+      onMouseLeave,
+      onTouchStart,
+      onTouchEnd,
+      ...rest
+    } = options;
+    const linkInfo = router.buildLink(options);
+    if (linkInfo.type === 'external') {
+      const {
+        href
+      } = linkInfo;
+      return {
+        href
+      };
+    }
+    const {
+      handleClick,
+      handleFocus,
+      handleEnter,
+      handleLeave,
+      isActive,
+      next
+    } = linkInfo;
+    const reactHandleClick = e => {
+      if (React__namespace.startTransition) {
+        // This is a hack for react < 18
+        React__namespace.startTransition(() => {
+          handleClick(e);
+        });
+      } else {
+        handleClick(e);
+      }
+    };
+    const composeHandlers = handlers => e => {
+      if (e.persist) e.persist();
+      handlers.filter(Boolean).forEach(handler => {
+        if (e.defaultPrevented) return;
+        handler(e);
+      });
+    };
+
+    // Get the active props
+    const resolvedActiveProps = isActive ? functionalUpdate(activeProps, {}) ?? {} : {};
+
+    // Get the inactive props
+    const resolvedInactiveProps = isActive ? {} : functionalUpdate(inactiveProps, {}) ?? {};
+    return {
+      ...resolvedActiveProps,
+      ...resolvedInactiveProps,
+      ...rest,
+      href: disabled ? undefined : next.href,
+      onClick: composeHandlers([onClick, reactHandleClick]),
+      onFocus: composeHandlers([onFocus, handleFocus]),
+      onMouseEnter: composeHandlers([onMouseEnter, handleEnter]),
+      onMouseLeave: composeHandlers([onMouseLeave, handleLeave]),
+      target,
+      style: {
+        ...style,
+        ...resolvedActiveProps.style,
+        ...resolvedInactiveProps.style
+      },
+      className: [className, resolvedActiveProps.className, resolvedInactiveProps.className].filter(Boolean).join(' ') || undefined,
+      ...(disabled ? {
+        role: 'link',
+        'aria-disabled': true
+      } : undefined),
+      ['data-status']: isActive ? 'active' : undefined
+    };
   }
+  const Link = /*#__PURE__*/React__namespace.forwardRef((props, ref) => {
+    const linkProps = useLinkProps(props);
+    return /*#__PURE__*/React__namespace.createElement("a", _extends$1({
+      ref: ref
+    }, linkProps, {
+      children: typeof props.children === 'function' ? props.children({
+        isActive: linkProps['data-status'] === 'active'
+      }) : props.children
+    }));
+  });
   const matchesContext = /*#__PURE__*/React__namespace.createContext(null);
   const routerContext = /*#__PURE__*/React__namespace.createContext(null);
-  function MatchesProvider(props) {
-    return /*#__PURE__*/React__namespace.createElement(matchesContext.Provider, props);
-  }
-  const useRouterSubscription = router => {
-    shim.useSyncExternalStore(cb => router.subscribe(() => cb()), () => router.state, () => router.state);
+  const EMPTY = {};
+  const __useStoreValue = (seed, selector) => {
+    const valueRef = React__namespace.useRef(EMPTY);
+
+    // If there is no selector, track the seed
+    // If there is a selector, do not track the seed
+    const getValue = () => !selector ? seed() : selector(untrack(() => seed()));
+
+    // If empty, initialize the value
+    if (valueRef.current === EMPTY) {
+      valueRef.current = sharedClone(undefined, getValue());
+    }
+
+    // Snapshot should just return the current cached value
+    const getSnapshot = React__namespace.useCallback(() => valueRef.current, []);
+    const getStore = React__namespace.useCallback(cb => {
+      // A root is necessary to track effects
+      return createRoot(() => {
+        createEffect(() => {
+          // Read and update the value
+          // getValue will handle which values are accessed and
+          // thus tracked.
+          // sharedClone will both recursively track the end result
+          // and ensure that the previous value is structurally shared
+          // into the new version.
+          valueRef.current = unwrap(
+          // Unwrap the value to get rid of any proxy structures
+          sharedClone(valueRef.current, getValue()));
+          cb();
+        });
+      });
+    }, []);
+    return shim.useSyncExternalStore(getStore, getSnapshot, getSnapshot);
   };
+  const [store, setStore] = createStore({
+    foo: 'foo',
+    bar: {
+      baz: 'baz'
+    }
+  });
+  createRoot(() => {
+    let prev;
+    createEffect(() => {
+      console.log('effect');
+      const next = sharedClone(prev, store);
+      console.log(next);
+      prev = untrack(() => next);
+    });
+  });
+  setStore(s => {
+    s.foo = '1';
+  });
+  setStore(s => {
+    s.bar.baz = '2';
+  });
   function createReactRouter(opts) {
-    const makeRouteExt = (route, router) => {
-      return {
-        useRoute: function useRoute(subRouteId) {
-          if (subRouteId === void 0) {
-            subRouteId = '.';
-          }
-          const resolvedRouteId = router.resolvePath(route.routeId, subRouteId);
-          const resolvedRoute = router.getRoute(resolvedRouteId);
-          useRouterSubscription(router);
-          invariant(resolvedRoute, "Could not find a route for route \"" + resolvedRouteId + "\"! Did you forget to add it to your route config?");
-          return resolvedRoute;
-        },
-        linkProps: options => {
-          var _functionalUpdate, _functionalUpdate2;
-          const {
-              // custom props
-
-              target,
-              activeProps = () => ({
-                className: 'active'
-              }),
-              inactiveProps = () => ({}),
-              disabled,
-              // element props
-              style,
-              className,
-              onClick,
-              onFocus,
-              onMouseEnter,
-              onMouseLeave
-            } = options,
-            rest = _objectWithoutPropertiesLoose(options, _excluded);
-          const linkInfo = route.buildLink(options);
-          if (linkInfo.type === 'external') {
-            const {
-              href
-            } = linkInfo;
-            return {
-              href
-            };
-          }
-          const {
-            handleClick,
-            handleFocus,
-            handleEnter,
-            handleLeave,
-            isActive,
-            next
-          } = linkInfo;
-          const reactHandleClick = e => {
-            if (React__namespace.startTransition)
-              // This is a hack for react < 18
-              React__namespace.startTransition(() => {
-                handleClick(e);
-              });else handleClick(e);
-          };
-          const composeHandlers = handlers => e => {
-            if (e.persist) e.persist();
-            handlers.forEach(handler => {
-              if (e.defaultPrevented) return;
-              if (handler) handler(e);
-            });
-          };
-
-          // Get the active props
-          const resolvedActiveProps = isActive ? (_functionalUpdate = functionalUpdate(activeProps, {})) != null ? _functionalUpdate : {} : {};
-
-          // Get the inactive props
-          const resolvedInactiveProps = isActive ? {} : (_functionalUpdate2 = functionalUpdate(inactiveProps, {})) != null ? _functionalUpdate2 : {};
-          return _extends$2({}, resolvedActiveProps, resolvedInactiveProps, rest, {
-            href: disabled ? undefined : next.href,
-            onClick: composeHandlers([reactHandleClick, onClick]),
-            onFocus: composeHandlers([handleFocus, onFocus]),
-            onMouseEnter: composeHandlers([handleEnter, onMouseEnter]),
-            onMouseLeave: composeHandlers([handleLeave, onMouseLeave]),
-            target,
-            style: _extends$2({}, style, resolvedActiveProps.style, resolvedInactiveProps.style),
-            className: [className, resolvedActiveProps.className, resolvedInactiveProps.className].filter(Boolean).join(' ') || undefined
-          }, disabled ? {
-            role: 'link',
-            'aria-disabled': true
-          } : undefined, {
-            ['data-status']: isActive ? 'active' : undefined
-          });
-        },
-        Link: /*#__PURE__*/React__namespace.forwardRef((props, ref) => {
-          const linkProps = route.linkProps(props);
-          useRouterSubscription(router);
-          return /*#__PURE__*/React__namespace.createElement("a", _extends$2({
-            ref: ref
-          }, linkProps, {
-            children: typeof props.children === 'function' ? props.children({
-              isActive: linkProps['data-status'] === 'active'
-            }) : props.children
-          }));
-        }),
-        MatchRoute: opts => {
-          const {
-              pending,
-              caseSensitive
-            } = opts,
-            rest = _objectWithoutPropertiesLoose(opts, _excluded2);
-          const params = route.matchRoute(rest, {
-            pending,
-            caseSensitive
-          });
-          if (!params) {
-            return null;
-          }
-          return typeof opts.children === 'function' ? opts.children(params) : opts.children;
-        }
-      };
-    };
-    const coreRouter = createRouter(_extends$2({}, opts, {
-      createRouter: router => {
-        const routerExt = {
-          useState: () => {
-            useRouterSubscription(router);
-            return router.state;
-          },
-          useMatch: (routeId, opts) => {
-            var _opts$strict;
-            useRouterSubscription(router);
-            const nearestMatch = useNearestMatch();
-            const match = router.state.currentMatches.find(d => d.routeId === routeId);
-            if ((_opts$strict = opts == null ? void 0 : opts.strict) != null ? _opts$strict : true) {
-              invariant(match, "Could not find an active match for \"" + routeId + "\"!");
-              invariant(nearestMatch.routeId == (match == null ? void 0 : match.routeId), "useMatch(\"" + (match == null ? void 0 : match.routeId) + "\") is being called in a component that is meant to render the '" + nearestMatch.routeId + "' route. Did you mean to 'useMatch(\"" + (match == null ? void 0 : match.routeId) + "\", { strict: false })' or 'useRoute(\"" + (match == null ? void 0 : match.routeId) + "\")' instead?");
-            }
-            return match;
-          }
-        };
-        const routeExt = makeRouteExt(router.getRoute(rootRouteId), router);
-        Object.assign(router, routerExt, routeExt);
-      },
-      createRoute: _ref => {
-        let {
-          router,
-          route
-        } = _ref;
-        const routeExt = makeRouteExt(route, router);
-        Object.assign(route, routeExt);
-      },
+    const coreRouter = createRouter({
+      ...opts,
       loadComponent: async component => {
-        if (component.preload && typeof document !== 'undefined') {
-          component.preload();
-          // return await component.preload()
+        if (component.preload) {
+          await component.preload();
         }
-
         return component;
       }
-    }));
+    });
     return coreRouter;
   }
-  function RouterProvider(_ref2) {
+  function RouterProvider(_ref) {
     let {
-        router
-      } = _ref2,
-      rest = _objectWithoutPropertiesLoose(_ref2, _excluded3);
+      router,
+      ...rest
+    } = _ref;
     router.update(rest);
-    useRouterSubscription(router);
-    React__namespace.useEffect(() => {
-      return router.mount();
-    }, [router]);
+    const [,, currentMatches] = __useStoreValue(() => router.store, s => [s.status, s.pendingMatches, s.currentMatches]);
+    React__namespace.useEffect(router.mount, [router]);
+    console.log('current', currentMatches);
     return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(routerContext.Provider, {
       value: {
         router: router
       }
-    }, /*#__PURE__*/React__namespace.createElement(MatchesProvider, {
-      value: [undefined, ...router.state.currentMatches]
+    }, /*#__PURE__*/React__namespace.createElement(matchesContext.Provider, {
+      value: [undefined, ...currentMatches]
     }, /*#__PURE__*/React__namespace.createElement(Outlet, null))));
   }
   function useRouter() {
     const value = React__namespace.useContext(routerContext);
     warning(!value, 'useRouter must be used inside a <Router> component!');
-    useRouterSubscription(value.router);
     return value.router;
   }
+  function useRouterStore(selector) {
+    const router = useRouter();
+    return __useStoreValue(() => router.store, selector);
+  }
   function useMatches() {
     return React__namespace.useContext(matchesContext);
   }
-  function useMatch(routeId, opts) {
+  function useMatch(opts) {
     const router = useRouter();
-    return router.useMatch(routeId, opts);
-  }
-  function useNearestMatch() {
-    const runtimeMatch = useMatches()[0];
-    invariant(runtimeMatch, "Could not find a nearest match!");
-    return runtimeMatch;
+    const nearestMatch = useMatches()[0];
+    const match = opts != null && opts.from ? router.store.currentMatches.find(d => d.routeId === (opts == null ? void 0 : opts.from)) : nearestMatch;
+    invariant(match, `Could not find ${opts != null && opts.from ? `an active match from "${opts.from}"` : 'a nearest match!'}`);
+    if ((opts == null ? void 0 : opts.strict) ?? true) {
+      invariant(nearestMatch.routeId == (match == null ? void 0 : match.routeId), `useMatch("${match == null ? void 0 : match.routeId}") is being called in a component that is meant to render the '${nearestMatch.routeId}' route. Did you mean to 'useMatch("${match == null ? void 0 : match.routeId}", { strict: false })' or 'useRoute("${match == null ? void 0 : match.routeId}")' instead?`);
+    }
+    __useStoreValue(() => match.store);
+    return match;
   }
   function useRoute(routeId) {
     const router = useRouter();
-    return router.useRoute(routeId);
+    const resolvedRoute = router.getRoute(routeId);
+    invariant(resolvedRoute, `Could not find a route for route "${routeId}"! Did you forget to add it to your route config?`);
+    return resolvedRoute;
+  }
+  function useLoaderData(opts) {
+    const match = useMatch(opts);
+    return __useStoreValue(() => match == null ? void 0 : match.store.loaderData, opts == null ? void 0 : opts.select);
   }
-  function useSearch(_routeId) {
-    return useRouter().state.currentLocation.search;
+  function useSearch(opts) {
+    const match = useMatch(opts);
+    return __useStoreValue(() => match == null ? void 0 : match.store.search, opts == null ? void 0 : opts.select);
   }
-  function linkProps(props) {
+  function useParams(opts) {
     const router = useRouter();
-    return router.linkProps(props);
+    return __useStoreValue(() => {
+      var _last;
+      return (_last = last(router.store.currentMatches)) == null ? void 0 : _last.params;
+    }, opts == null ? void 0 : opts.select);
   }
-  function MatchRoute(props) {
+  function useNavigate(defaultOpts) {
+    return opts => {
+      const router = useRouter();
+      return router.navigate({
+        ...defaultOpts,
+        ...opts
+      });
+    };
+  }
+  function useAction(opts) {
+    const route = useRoute(opts.from);
+    const action = route.action;
+    __useStoreValue(() => action);
+    return action;
+  }
+  function useMatchRoute() {
     const router = useRouter();
-    return /*#__PURE__*/React__namespace.createElement(router.MatchRoute, props);
+    return opts => {
+      const {
+        pending,
+        caseSensitive,
+        ...rest
+      } = opts;
+      return router.matchRoute(rest, {
+        pending,
+        caseSensitive
+      });
+    };
+  }
+  function MatchRoute(props) {
+    const matchRoute = useMatchRoute();
+    const params = matchRoute(props);
+    if (!params) {
+      return null;
+    }
+    return /*#__PURE__*/React__namespace.createElement(typeof props.children === 'function' ? props.children(params) : props.children, props);
   }
   function Outlet() {
-    var _ref3, _match$__$pendingComp, _match$__$errorCompon;
     const router = useRouter();
     const matches = useMatches().slice(1);
     const match = matches[0];
     const defaultPending = React__namespace.useCallback(() => null, []);
+    __useStoreValue(() => match == null ? void 0 : match.store);
+    const Inner = React__namespace.useCallback(props => {
+      if (props.match.store.status === 'error') {
+        throw props.match.store.error;
+      }
+      if (props.match.store.status === 'success') {
+        return /*#__PURE__*/React__namespace.createElement(props.match.__.component ?? router.options.defaultComponent ?? Outlet);
+      }
+      if (props.match.store.status === 'loading') {
+        throw props.match.__.loadPromise;
+      }
+      invariant(false, 'Idle routeMatch status encountered during rendering! You should never see this. File an issue!');
+    }, []);
     if (!match) {
       return null;
     }
-    const PendingComponent = (_ref3 = (_match$__$pendingComp = match.__.pendingComponent) != null ? _match$__$pendingComp : router.options.defaultPendingComponent) != null ? _ref3 : defaultPending;
-    const errorComponent = (_match$__$errorCompon = match.__.errorComponent) != null ? _match$__$errorCompon : router.options.defaultErrorComponent;
-    return /*#__PURE__*/React__namespace.createElement(MatchesProvider, {
+    const PendingComponent = match.__.pendingComponent ?? router.options.defaultPendingComponent ?? defaultPending;
+    const errorComponent = match.__.errorComponent ?? router.options.defaultErrorComponent;
+    return /*#__PURE__*/React__namespace.createElement(matchesContext.Provider, {
       value: matches
     }, /*#__PURE__*/React__namespace.createElement(React__namespace.Suspense, {
       fallback: /*#__PURE__*/React__namespace.createElement(PendingComponent, null)
@@ -2675,27 +3169,17 @@
       key: match.routeId,
       errorComponent: errorComponent,
       match: match
-    }, (() => {
-      if (match.status === 'error') {
-        throw match.error;
-      }
-      if (match.status === 'success') {
-        var _ref4, _ref5;
-        return /*#__PURE__*/React__namespace.createElement((_ref4 = (_ref5 = match.__.component) != null ? _ref5 : router.options.defaultComponent) != null ? _ref4 : Outlet);
-      }
-      throw match.__.loadPromise;
-    })())));
+    }, /*#__PURE__*/React__namespace.createElement(Inner, {
+      match: match
+    }))));
   }
   class CatchBoundary extends React__namespace.Component {
-    constructor() {
-      super(...arguments);
-      this.state = {
-        error: false,
-        info: undefined
-      };
-    }
+    state = {
+      error: false,
+      info: undefined
+    };
     componentDidCatch(error, info) {
-      console.error("Error in route match: " + this.props.match.matchId);
+      console.error(`Error in route match: ${this.props.match.matchId}`);
       console.error(error);
       this.setState({
         error,
@@ -2703,7 +3187,7 @@
       });
     }
     render() {
-      return /*#__PURE__*/React__namespace.createElement(CatchBoundaryInner, _extends$2({}, this.props, {
+      return /*#__PURE__*/React__namespace.createElement(CatchBoundaryInner, _extends$1({}, this.props, {
         errorState: this.state,
         reset: () => this.setState({})
       }));
@@ -2714,19 +3198,18 @@
   // there has to be a better way to reset error boundaries when the
   // router's location key changes.
   function CatchBoundaryInner(props) {
-    var _props$errorComponent;
     const [activeErrorState, setActiveErrorState] = React__namespace.useState(props.errorState);
     const router = useRouter();
-    const errorComponent = (_props$errorComponent = props.errorComponent) != null ? _props$errorComponent : DefaultErrorBoundary;
+    const errorComponent = props.errorComponent ?? DefaultErrorBoundary;
     React__namespace.useEffect(() => {
       if (activeErrorState) {
-        let prevKey = router.state.currentLocation.key;
-        return router.subscribe(() => {
-          if (router.state.currentLocation.key !== prevKey) {
-            prevKey = router.state.currentLocation.key;
+        let prevKey = router.store.currentLocation.key;
+        return createRoot(() => createEffect(() => {
+          if (router.store.currentLocation.key !== prevKey) {
+            prevKey = router.store.currentLocation.key;
             setActiveErrorState({});
           }
-        });
+        }));
       }
       return;
     }, [activeErrorState]);
@@ -2736,15 +3219,15 @@
       }
       props.reset();
     }, [props.errorState.error]);
-    if (activeErrorState.error) {
+    if (props.errorState.error) {
       return /*#__PURE__*/React__namespace.createElement(errorComponent, activeErrorState);
     }
     return props.children;
   }
-  function DefaultErrorBoundary(_ref6) {
+  function DefaultErrorBoundary(_ref2) {
     let {
       error
-    } = _ref6;
+    } = _ref2;
     return /*#__PURE__*/React__namespace.createElement("div", {
       style: {
         padding: '.5rem',
@@ -2777,38 +3260,61 @@
           unblock();
           transition.retry();
         } else {
-          router.state.currentLocation.pathname = window.location.pathname;
+          router.store.currentLocation.pathname = window.location.pathname;
         }
       });
       return unblock;
     }, [when, message]);
   }
-  function Prompt(_ref7) {
+  function Prompt(_ref3) {
     let {
       message,
       when,
       children
-    } = _ref7;
-    usePrompt(message, when != null ? when : true);
-    return children != null ? children : null;
+    } = _ref3;
+    usePrompt(message, when ?? true);
+    return children ?? null;
   }
 
+  // function circularStringify(obj: any) {
+  //   const seen = new Set()
+
+  //   return (
+  //     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
+  //     }) || ''
+  //   )
+  // }
+
   exports.DefaultErrorBoundary = DefaultErrorBoundary;
   exports.Link = Link;
   exports.MatchRoute = MatchRoute;
-  exports.MatchesProvider = MatchesProvider;
   exports.Outlet = Outlet;
   exports.Prompt = Prompt;
   exports.RouterProvider = RouterProvider;
+  exports.__useStoreValue = __useStoreValue;
+  exports.batch = batch;
   exports.cleanPath = cleanPath;
   exports.createBrowserHistory = createBrowserHistory;
+  exports.createEffect = createEffect;
   exports.createHashHistory = createHashHistory;
+  exports.createMemo = createMemo;
   exports.createMemoryHistory = createMemoryHistory;
   exports.createReactRouter = createReactRouter;
+  exports.createRoot = createRoot;
   exports.createRoute = createRoute;
   exports.createRouteConfig = createRouteConfig;
   exports.createRouteMatch = createRouteMatch;
   exports.createRouter = createRouter;
+  exports.createSignal = createSignal;
+  exports.createStore = createStore;
   exports.decode = decode;
   exports.defaultParseSearch = defaultParseSearch;
   exports.defaultStringifySearch = defaultStringifySearch;
@@ -2816,30 +3322,39 @@
   exports.functionalUpdate = functionalUpdate;
   exports.interpolatePath = interpolatePath;
   exports.invariant = invariant;
+  exports.isWrappable = isWrappable;
   exports.joinPaths = joinPaths;
   exports.last = last;
   exports.lazy = lazy;
-  exports.linkProps = linkProps;
   exports.matchByPath = matchByPath;
   exports.matchPathname = matchPathname;
   exports.matchesContext = matchesContext;
+  exports.onCleanup = onCleanup;
   exports.parsePathname = parsePathname;
   exports.parseSearchWith = parseSearchWith;
   exports.pick = pick;
-  exports.replaceEqualDeep = replaceEqualDeep;
   exports.resolvePath = resolvePath;
   exports.rootRouteId = rootRouteId;
   exports.routerContext = routerContext;
+  exports.sharedClone = sharedClone;
   exports.stringifySearchWith = stringifySearchWith;
   exports.trimPath = trimPath;
   exports.trimPathLeft = trimPathLeft;
   exports.trimPathRight = trimPathRight;
+  exports.untrack = untrack;
+  exports.unwrap = unwrap;
+  exports.useAction = useAction;
+  exports.useLinkProps = useLinkProps;
+  exports.useLoaderData = useLoaderData;
   exports.useMatch = useMatch;
+  exports.useMatchRoute = useMatchRoute;
   exports.useMatches = useMatches;
-  exports.useNearestMatch = useNearestMatch;
+  exports.useNavigate = useNavigate;
+  exports.useParams = useParams;
   exports.usePrompt = usePrompt;
   exports.useRoute = useRoute;
   exports.useRouter = useRouter;
+  exports.useRouterStore = useRouterStore;
   exports.useSearch = useSearch;
   exports.warning = warning;