@tanstack/react-router 0.0.1-alpha.0

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

@@ -0,0 +1,2330 @@
+/**
+ * react-router
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * router-core
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+function _extends$1() {
+  _extends$1 = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+  return _extends$1.apply(this, arguments);
+}
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+/**
+ * Actions represent the type of change to a location value.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#action
+ */
+var Action;
+
+(function (Action) {
+  /**
+   * A POP indicates a change to an arbitrary index in the history stack, such
+   * as a back or forward navigation. It does not describe the direction of the
+   * navigation, only that the current index changed.
+   *
+   * Note: This is the default action for newly created history objects.
+   */
+  Action["Pop"] = "POP";
+  /**
+   * A PUSH indicates a new entry being added to the history stack, such as when
+   * a link is clicked and a new page loads. When this happens, all subsequent
+   * entries in the stack are lost.
+   */
+
+  Action["Push"] = "PUSH";
+  /**
+   * A REPLACE indicates the entry at the current index in the history stack
+   * being replaced by a new one.
+   */
+
+  Action["Replace"] = "REPLACE";
+})(Action || (Action = {}));
+
+var readOnly = process.env.NODE_ENV !== "production" ? function (obj) {
+  return Object.freeze(obj);
+} : function (obj) {
+  return obj;
+};
+
+function warning$1(cond, message) {
+  if (!cond) {
+    // eslint-disable-next-line no-console
+    if (typeof console !== 'undefined') console.warn(message);
+
+    try {
+      // Welcome to debugging history!
+      //
+      // This error is thrown as a convenience so you can more easily
+      // find the source for a warning that appears in the console by
+      // enabling "pause on exceptions" in your JavaScript debugger.
+      throw new Error(message); // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+}
+
+var BeforeUnloadEventType = 'beforeunload';
+var HashChangeEventType = 'hashchange';
+var PopStateEventType = 'popstate';
+/**
+ * Browser history stores the location in regular URLs. This is the standard for
+ * most web apps, but it requires some configuration on the server to ensure you
+ * serve the same app at multiple URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+ */
+
+function createBrowserHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var _options = options,
+      _options$window = _options.window,
+      window = _options$window === void 0 ? document.defaultView : _options$window;
+  var globalHistory = window.history;
+
+  function getIndexAndLocation() {
+    var _window$location = window.location,
+        pathname = _window$location.pathname,
+        search = _window$location.search,
+        hash = _window$location.hash;
+    var state = globalHistory.state || {};
+    return [state.idx, readOnly({
+      pathname: pathname,
+      search: search,
+      hash: hash,
+      state: state.usr || null,
+      key: state.key || 'default'
+    })];
+  }
+
+  var blockedPopTx = null;
+
+  function handlePop() {
+    if (blockedPopTx) {
+      blockers.call(blockedPopTx);
+      blockedPopTx = null;
+    } else {
+      var nextAction = Action.Pop;
+
+      var _getIndexAndLocation = getIndexAndLocation(),
+          nextIndex = _getIndexAndLocation[0],
+          nextLocation = _getIndexAndLocation[1];
+
+      if (blockers.length) {
+        if (nextIndex != null) {
+          var delta = index - nextIndex;
+
+          if (delta) {
+            // Revert the POP
+            blockedPopTx = {
+              action: nextAction,
+              location: nextLocation,
+              retry: function retry() {
+                go(delta * -1);
+              }
+            };
+            go(delta);
+          }
+        } else {
+          // Trying to POP to a location with no index. We did not create
+          // this location, so we can't effectively block the navigation.
+          process.env.NODE_ENV !== "production" ? warning$1(false, // TODO: Write up a doc that explains our blocking strategy in
+          // detail and link to it here so people can understand better what
+          // is going on and how to avoid it.
+          "You are trying to block a POP navigation to a location that was not " + "created by the history library. The block will fail silently in " + "production, but in general you should do all navigation with the " + "history library (instead of using window.history.pushState directly) " + "to avoid this situation.") : void 0;
+        }
+      } else {
+        applyTx(nextAction);
+      }
+    }
+  }
+
+  window.addEventListener(PopStateEventType, handlePop);
+  var action = Action.Pop;
+
+  var _getIndexAndLocation2 = getIndexAndLocation(),
+      index = _getIndexAndLocation2[0],
+      location = _getIndexAndLocation2[1];
+
+  var listeners = createEvents();
+  var blockers = createEvents();
+
+  if (index == null) {
+    index = 0;
+    globalHistory.replaceState(_extends({}, globalHistory.state, {
+      idx: index
+    }), '');
+  }
+
+  function createHref(to) {
+    return typeof to === 'string' ? to : createPath(to);
+  } // state defaults to `null` because `window.history.state` does
+
+
+  function getNextLocation(to, state) {
+    if (state === void 0) {
+      state = null;
+    }
+
+    return readOnly(_extends({
+      pathname: location.pathname,
+      hash: '',
+      search: ''
+    }, typeof to === 'string' ? parsePath(to) : to, {
+      state: state,
+      key: createKey()
+    }));
+  }
+
+  function getHistoryStateAndUrl(nextLocation, index) {
+    return [{
+      usr: nextLocation.state,
+      key: nextLocation.key,
+      idx: index
+    }, createHref(nextLocation)];
+  }
+
+  function allowTx(action, location, retry) {
+    return !blockers.length || (blockers.call({
+      action: action,
+      location: location,
+      retry: retry
+    }), false);
+  }
+
+  function applyTx(nextAction) {
+    action = nextAction;
+
+    var _getIndexAndLocation3 = getIndexAndLocation();
+
+    index = _getIndexAndLocation3[0];
+    location = _getIndexAndLocation3[1];
+    listeners.call({
+      action: action,
+      location: location
+    });
+  }
+
+  function push(to, state) {
+    var nextAction = Action.Push;
+    var nextLocation = getNextLocation(to, state);
+
+    function retry() {
+      push(to, state);
+    }
+
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1),
+          historyState = _getHistoryStateAndUr[0],
+          url = _getHistoryStateAndUr[1]; // TODO: Support forced reloading
+      // try...catch because iOS limits us to 100 pushState calls :/
+
+
+      try {
+        globalHistory.pushState(historyState, '', url);
+      } catch (error) {
+        // They are going to lose state here, but there is no real
+        // way to warn them about it since the page will refresh...
+        window.location.assign(url);
+      }
+
+      applyTx(nextAction);
+    }
+  }
+
+  function replace(to, state) {
+    var nextAction = Action.Replace;
+    var nextLocation = getNextLocation(to, state);
+
+    function retry() {
+      replace(to, state);
+    }
+
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index),
+          historyState = _getHistoryStateAndUr2[0],
+          url = _getHistoryStateAndUr2[1]; // TODO: Support forced reloading
+
+
+      globalHistory.replaceState(historyState, '', url);
+      applyTx(nextAction);
+    }
+  }
+
+  function go(delta) {
+    globalHistory.go(delta);
+  }
+
+  var history = {
+    get action() {
+      return action;
+    },
+
+    get location() {
+      return location;
+    },
+
+    createHref: createHref,
+    push: push,
+    replace: replace,
+    go: go,
+    back: function back() {
+      go(-1);
+    },
+    forward: function forward() {
+      go(1);
+    },
+    listen: function listen(listener) {
+      return listeners.push(listener);
+    },
+    block: function block(blocker) {
+      var unblock = blockers.push(blocker);
+
+      if (blockers.length === 1) {
+        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+      }
+
+      return function () {
+        unblock(); // Remove the beforeunload listener so the document may
+        // still be salvageable in the pagehide event.
+        // See https://html.spec.whatwg.org/#unloading-documents
+
+        if (!blockers.length) {
+          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+        }
+      };
+    }
+  };
+  return history;
+}
+/**
+ * Hash history stores the location in window.location.hash. This makes it ideal
+ * for situations where you don't want to send the location to the server for
+ * some reason, either because you do cannot configure it or the URL space is
+ * reserved for something else.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
+ */
+
+function createHashHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var _options2 = options,
+      _options2$window = _options2.window,
+      window = _options2$window === void 0 ? document.defaultView : _options2$window;
+  var globalHistory = window.history;
+
+  function getIndexAndLocation() {
+    var _parsePath = parsePath(window.location.hash.substr(1)),
+        _parsePath$pathname = _parsePath.pathname,
+        pathname = _parsePath$pathname === void 0 ? '/' : _parsePath$pathname,
+        _parsePath$search = _parsePath.search,
+        search = _parsePath$search === void 0 ? '' : _parsePath$search,
+        _parsePath$hash = _parsePath.hash,
+        hash = _parsePath$hash === void 0 ? '' : _parsePath$hash;
+
+    var state = globalHistory.state || {};
+    return [state.idx, readOnly({
+      pathname: pathname,
+      search: search,
+      hash: hash,
+      state: state.usr || null,
+      key: state.key || 'default'
+    })];
+  }
+
+  var blockedPopTx = null;
+
+  function handlePop() {
+    if (blockedPopTx) {
+      blockers.call(blockedPopTx);
+      blockedPopTx = null;
+    } else {
+      var nextAction = Action.Pop;
+
+      var _getIndexAndLocation4 = getIndexAndLocation(),
+          nextIndex = _getIndexAndLocation4[0],
+          nextLocation = _getIndexAndLocation4[1];
+
+      if (blockers.length) {
+        if (nextIndex != null) {
+          var delta = index - nextIndex;
+
+          if (delta) {
+            // Revert the POP
+            blockedPopTx = {
+              action: nextAction,
+              location: nextLocation,
+              retry: function retry() {
+                go(delta * -1);
+              }
+            };
+            go(delta);
+          }
+        } else {
+          // Trying to POP to a location with no index. We did not create
+          // this location, so we can't effectively block the navigation.
+          process.env.NODE_ENV !== "production" ? warning$1(false, // TODO: Write up a doc that explains our blocking strategy in
+          // detail and link to it here so people can understand better
+          // what is going on and how to avoid it.
+          "You are trying to block a POP navigation to a location that was not " + "created by the history library. The block will fail silently in " + "production, but in general you should do all navigation with the " + "history library (instead of using window.history.pushState directly) " + "to avoid this situation.") : void 0;
+        }
+      } else {
+        applyTx(nextAction);
+      }
+    }
+  }
+
+  window.addEventListener(PopStateEventType, handlePop); // popstate does not fire on hashchange in IE 11 and old (trident) Edge
+  // https://developer.mozilla.org/de/docs/Web/API/Window/popstate_event
+
+  window.addEventListener(HashChangeEventType, function () {
+    var _getIndexAndLocation5 = getIndexAndLocation(),
+        nextLocation = _getIndexAndLocation5[1]; // Ignore extraneous hashchange events.
+
+
+    if (createPath(nextLocation) !== createPath(location)) {
+      handlePop();
+    }
+  });
+  var action = Action.Pop;
+
+  var _getIndexAndLocation6 = getIndexAndLocation(),
+      index = _getIndexAndLocation6[0],
+      location = _getIndexAndLocation6[1];
+
+  var listeners = createEvents();
+  var blockers = createEvents();
+
+  if (index == null) {
+    index = 0;
+    globalHistory.replaceState(_extends({}, globalHistory.state, {
+      idx: index
+    }), '');
+  }
+
+  function getBaseHref() {
+    var base = document.querySelector('base');
+    var href = '';
+
+    if (base && base.getAttribute('href')) {
+      var url = window.location.href;
+      var hashIndex = url.indexOf('#');
+      href = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    }
+
+    return href;
+  }
+
+  function createHref(to) {
+    return getBaseHref() + '#' + (typeof to === 'string' ? to : createPath(to));
+  }
+
+  function getNextLocation(to, state) {
+    if (state === void 0) {
+      state = null;
+    }
+
+    return readOnly(_extends({
+      pathname: location.pathname,
+      hash: '',
+      search: ''
+    }, typeof to === 'string' ? parsePath(to) : to, {
+      state: state,
+      key: createKey()
+    }));
+  }
+
+  function getHistoryStateAndUrl(nextLocation, index) {
+    return [{
+      usr: nextLocation.state,
+      key: nextLocation.key,
+      idx: index
+    }, createHref(nextLocation)];
+  }
+
+  function allowTx(action, location, retry) {
+    return !blockers.length || (blockers.call({
+      action: action,
+      location: location,
+      retry: retry
+    }), false);
+  }
+
+  function applyTx(nextAction) {
+    action = nextAction;
+
+    var _getIndexAndLocation7 = getIndexAndLocation();
+
+    index = _getIndexAndLocation7[0];
+    location = _getIndexAndLocation7[1];
+    listeners.call({
+      action: action,
+      location: location
+    });
+  }
+
+  function push(to, state) {
+    var nextAction = Action.Push;
+    var nextLocation = getNextLocation(to, state);
+
+    function retry() {
+      push(to, state);
+    }
+
+    process.env.NODE_ENV !== "production" ? warning$1(nextLocation.pathname.charAt(0) === '/', "Relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")") : void 0;
+
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr3 = getHistoryStateAndUrl(nextLocation, index + 1),
+          historyState = _getHistoryStateAndUr3[0],
+          url = _getHistoryStateAndUr3[1]; // TODO: Support forced reloading
+      // try...catch because iOS limits us to 100 pushState calls :/
+
+
+      try {
+        globalHistory.pushState(historyState, '', url);
+      } catch (error) {
+        // They are going to lose state here, but there is no real
+        // way to warn them about it since the page will refresh...
+        window.location.assign(url);
+      }
+
+      applyTx(nextAction);
+    }
+  }
+
+  function replace(to, state) {
+    var nextAction = Action.Replace;
+    var nextLocation = getNextLocation(to, state);
+
+    function retry() {
+      replace(to, state);
+    }
+
+    process.env.NODE_ENV !== "production" ? warning$1(nextLocation.pathname.charAt(0) === '/', "Relative pathnames are not supported in hash history.replace(" + JSON.stringify(to) + ")") : void 0;
+
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr4 = getHistoryStateAndUrl(nextLocation, index),
+          historyState = _getHistoryStateAndUr4[0],
+          url = _getHistoryStateAndUr4[1]; // TODO: Support forced reloading
+
+
+      globalHistory.replaceState(historyState, '', url);
+      applyTx(nextAction);
+    }
+  }
+
+  function go(delta) {
+    globalHistory.go(delta);
+  }
+
+  var history = {
+    get action() {
+      return action;
+    },
+
+    get location() {
+      return location;
+    },
+
+    createHref: createHref,
+    push: push,
+    replace: replace,
+    go: go,
+    back: function back() {
+      go(-1);
+    },
+    forward: function forward() {
+      go(1);
+    },
+    listen: function listen(listener) {
+      return listeners.push(listener);
+    },
+    block: function block(blocker) {
+      var unblock = blockers.push(blocker);
+
+      if (blockers.length === 1) {
+        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+      }
+
+      return function () {
+        unblock(); // Remove the beforeunload listener so the document may
+        // still be salvageable in the pagehide event.
+        // See https://html.spec.whatwg.org/#unloading-documents
+
+        if (!blockers.length) {
+          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+        }
+      };
+    }
+  };
+  return history;
+}
+/**
+ * Memory history stores the current location in memory. It is designed for use
+ * in stateful non-browser environments like tests and React Native.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#creatememoryhistory
+ */
+
+function createMemoryHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var _options3 = options,
+      _options3$initialEntr = _options3.initialEntries,
+      initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,
+      initialIndex = _options3.initialIndex;
+  var entries = initialEntries.map(function (entry) {
+    var location = readOnly(_extends({
+      pathname: '/',
+      search: '',
+      hash: '',
+      state: null,
+      key: createKey()
+    }, typeof entry === 'string' ? parsePath(entry) : entry));
+    process.env.NODE_ENV !== "production" ? warning$1(location.pathname.charAt(0) === '/', "Relative pathnames are not supported in createMemoryHistory({ initialEntries }) (invalid entry: " + JSON.stringify(entry) + ")") : void 0;
+    return location;
+  });
+  var index = clamp(initialIndex == null ? entries.length - 1 : initialIndex, 0, entries.length - 1);
+  var action = Action.Pop;
+  var location = entries[index];
+  var listeners = createEvents();
+  var blockers = createEvents();
+
+  function createHref(to) {
+    return typeof to === 'string' ? to : createPath(to);
+  }
+
+  function getNextLocation(to, state) {
+    if (state === void 0) {
+      state = null;
+    }
+
+    return readOnly(_extends({
+      pathname: location.pathname,
+      search: '',
+      hash: ''
+    }, typeof to === 'string' ? parsePath(to) : to, {
+      state: state,
+      key: createKey()
+    }));
+  }
+
+  function allowTx(action, location, retry) {
+    return !blockers.length || (blockers.call({
+      action: action,
+      location: location,
+      retry: retry
+    }), false);
+  }
+
+  function applyTx(nextAction, nextLocation) {
+    action = nextAction;
+    location = nextLocation;
+    listeners.call({
+      action: action,
+      location: location
+    });
+  }
+
+  function push(to, state) {
+    var nextAction = Action.Push;
+    var nextLocation = getNextLocation(to, state);
+
+    function retry() {
+      push(to, state);
+    }
+
+    process.env.NODE_ENV !== "production" ? warning$1(location.pathname.charAt(0) === '/', "Relative pathnames are not supported in memory history.push(" + JSON.stringify(to) + ")") : void 0;
+
+    if (allowTx(nextAction, nextLocation, retry)) {
+      index += 1;
+      entries.splice(index, entries.length, nextLocation);
+      applyTx(nextAction, nextLocation);
+    }
+  }
+
+  function replace(to, state) {
+    var nextAction = Action.Replace;
+    var nextLocation = getNextLocation(to, state);
+
+    function retry() {
+      replace(to, state);
+    }
+
+    process.env.NODE_ENV !== "production" ? warning$1(location.pathname.charAt(0) === '/', "Relative pathnames are not supported in memory history.replace(" + JSON.stringify(to) + ")") : void 0;
+
+    if (allowTx(nextAction, nextLocation, retry)) {
+      entries[index] = nextLocation;
+      applyTx(nextAction, nextLocation);
+    }
+  }
+
+  function go(delta) {
+    var nextIndex = clamp(index + delta, 0, entries.length - 1);
+    var nextAction = Action.Pop;
+    var nextLocation = entries[nextIndex];
+
+    function retry() {
+      go(delta);
+    }
+
+    if (allowTx(nextAction, nextLocation, retry)) {
+      index = nextIndex;
+      applyTx(nextAction, nextLocation);
+    }
+  }
+
+  var history = {
+    get index() {
+      return index;
+    },
+
+    get action() {
+      return action;
+    },
+
+    get location() {
+      return location;
+    },
+
+    createHref: createHref,
+    push: push,
+    replace: replace,
+    go: go,
+    back: function back() {
+      go(-1);
+    },
+    forward: function forward() {
+      go(1);
+    },
+    listen: function listen(listener) {
+      return listeners.push(listener);
+    },
+    block: function block(blocker) {
+      return blockers.push(blocker);
+    }
+  };
+  return history;
+} ////////////////////////////////////////////////////////////////////////////////
+// UTILS
+////////////////////////////////////////////////////////////////////////////////
+
+function clamp(n, lowerBound, upperBound) {
+  return Math.min(Math.max(n, lowerBound), upperBound);
+}
+
+function promptBeforeUnload(event) {
+  // Cancel the event.
+  event.preventDefault(); // Chrome (and legacy IE) requires returnValue to be set.
+
+  event.returnValue = '';
+}
+
+function createEvents() {
+  var handlers = [];
+  return {
+    get length() {
+      return handlers.length;
+    },
+
+    push: function push(fn) {
+      handlers.push(fn);
+      return function () {
+        handlers = handlers.filter(function (handler) {
+          return handler !== fn;
+        });
+      };
+    },
+    call: function call(arg) {
+      handlers.forEach(function (fn) {
+        return fn && fn(arg);
+      });
+    }
+  };
+}
+
+function createKey() {
+  return Math.random().toString(36).substr(2, 8);
+}
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createpath
+ */
+
+
+function createPath(_ref) {
+  var _ref$pathname = _ref.pathname,
+      pathname = _ref$pathname === void 0 ? '/' : _ref$pathname,
+      _ref$search = _ref.search,
+      search = _ref$search === void 0 ? '' : _ref$search,
+      _ref$hash = _ref.hash,
+      hash = _ref$hash === void 0 ? '' : _ref$hash;
+  if (search && search !== '?') pathname += search.charAt(0) === '?' ? search : '?' + search;
+  if (hash && hash !== '#') pathname += hash.charAt(0) === '#' ? hash : '#' + hash;
+  return pathname;
+}
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#parsepath
+ */
+
+function parsePath(path) {
+  var parsedPath = {};
+
+  if (path) {
+    var hashIndex = path.indexOf('#');
+
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substr(hashIndex);
+      path = path.substr(0, hashIndex);
+    }
+
+    var searchIndex = path.indexOf('?');
+
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substr(searchIndex);
+      path = path.substr(0, searchIndex);
+    }
+
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+
+  return parsedPath;
+}
+
+// @ts-nocheck
+// We're inlining qss here for compression's sake, but we've included it as a hard dependency for the MIT license it requires.
+function encode(obj, pfx) {
+  var k,
+      i,
+      tmp,
+      str = '';
+
+  for (k in obj) {
+    if ((tmp = obj[k]) !== void 0) {
+      if (Array.isArray(tmp)) {
+        for (i = 0; i < tmp.length; i++) {
+          str && (str += '&');
+          str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp[i]);
+        }
+      } else {
+        str && (str += '&');
+        str += encodeURIComponent(k) + '=' + encodeURIComponent(tmp);
+      }
+    }
+  }
+
+  return (pfx || '') + str;
+}
+
+function toValue(mix) {
+  if (!mix) return '';
+  var str = decodeURIComponent(mix);
+  if (str === 'false') return false;
+  if (str === 'true') return true;
+  return +str * 0 === 0 ? +str : str;
+}
+
+function decode(str) {
+  var tmp,
+      k,
+      out = {},
+      arr = str.split('&');
+
+  while (tmp = arr.shift()) {
+    tmp = tmp.split('=');
+    k = tmp.shift();
+
+    if (out[k] !== void 0) {
+      out[k] = [].concat(out[k], toValue(tmp.shift()));
+    } else {
+      out[k] = toValue(tmp.shift());
+    }
+  }
+
+  return out;
+}
+
+const createRouteConfig = function createRouteConfig(options, children, isRoot, parentId) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  if (isRoot === void 0) {
+    isRoot = true;
+  }
+
+  if (isRoot) {
+    options.path = rootRouteId;
+  } else {
+    warning(!options.path, 'Routes must have a path property.');
+  } // Strip the root from parentIds
+
+
+  if (parentId === rootRouteId) {
+    parentId = '';
+  }
+
+  let path = String(isRoot ? rootRouteId : options.path); // If the path is anything other than an index path, trim it up
+
+  if (path !== '/') {
+    path = trimPath(path);
+  }
+
+  let id = joinPaths([parentId, path]);
+
+  if (path === rootRouteId) {
+    path = '/';
+  }
+
+  if (id !== rootRouteId) {
+    id = joinPaths(['/', id]);
+  }
+
+  const fullPath = id === rootRouteId ? '/' : trimPathRight(id);
+  return {
+    id: id,
+    path: path,
+    fullPath: fullPath,
+    options: options,
+    children,
+    addChildren: cb => createRouteConfig(options, cb(childOptions => createRouteConfig(childOptions, undefined, false, id)), false, parentId)
+  };
+};
+const rootRouteId = '__root__';
+// Source
+// Detect if we're in the DOM
+const isDOM = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement); // This is the default history object if none is defined
+
+const createDefaultHistory = () => isDOM ? createBrowserHistory() : createMemoryHistory();
+
+function createRouter(userOptions) {
+  var _userOptions$stringif, _userOptions$parseSea;
+
+  const history = (userOptions == null ? void 0 : userOptions.history) || createDefaultHistory();
+
+  const originalOptions = _extends$1({}, userOptions, {
+    stringifySearch: (_userOptions$stringif = userOptions == null ? void 0 : userOptions.stringifySearch) != null ? _userOptions$stringif : defaultStringifySearch,
+    parseSearch: (_userOptions$parseSea = userOptions == null ? void 0 : userOptions.parseSearch) != null ? _userOptions$parseSea : defaultParseSearch
+  });
+
+  let router = {
+    options: originalOptions,
+    listeners: [],
+    // Resolved after construction
+    basepath: '',
+    routeTree: undefined,
+    routesById: {},
+    location: undefined,
+    allRouteInfo: undefined,
+    //
+    navigationPromise: Promise.resolve(),
+    resolveNavigation: () => {},
+    preloadCache: {},
+    state: {
+      status: 'idle',
+      location: null,
+      matches: [],
+      actions: {},
+      loaderData: {},
+      lastUpdated: Date.now()
+    },
+    startedLoadingAt: Date.now(),
+    subscribe: listener => {
+      router.listeners.push(listener);
+      return () => {
+        router.listeners = router.listeners.filter(x => x !== listener);
+      };
+    },
+    getRoute: id => {
+      return router.routesById[id];
+    },
+    notify: () => {
+      router.state = _extends$1({}, router.state);
+      router.listeners.forEach(listener => listener());
+    },
+    mount: () => {
+      const next = router.buildLocation({
+        to: '.',
+        search: true,
+        hash: true
+      }); // If the current location isn't updated, trigger a navigation
+      // to the current location. Otherwise, load the current location.
+
+      if (next.href !== router.location.href) {
+        return router.commitLocation(next, true);
+      } else {
+        return router.loadLocation();
+      }
+    },
+    update: opts => {
+      Object.assign(router.options, opts);
+      const {
+        basepath,
+        routeConfig
+      } = router.options;
+      router.basepath = cleanPath("/" + (basepath != null ? basepath : ''));
+
+      if (routeConfig) {
+        router.routesById = {};
+        router.routeTree = router.buildRouteTree(routeConfig);
+      }
+
+      return router;
+    },
+    destroy: history.listen(event => {
+      router.loadLocation(router.parseLocation(event.location, router.location));
+    }),
+    buildRouteTree: rootRouteConfig => {
+      const recurseRoutes = (routeConfigs, parent) => {
+        return routeConfigs.map(routeConfig => {
+          const routeOptions = routeConfig.options;
+          const route = createRoute(routeConfig, routeOptions, parent, router); // {
+          //   pendingMs: routeOptions.pendingMs ?? router.defaultPendingMs,
+          //   pendingMinMs: routeOptions.pendingMinMs ?? router.defaultPendingMinMs,
+          // }
+
+          const existingRoute = router.routesById[route.routeId];
+
+          if (existingRoute) {
+            if (process.env.NODE_ENV !== 'production') {
+              console.warn("Duplicate routes found with id: " + String(route.routeId), router.routesById, route);
+            }
+
+            throw new Error();
+          }
+          router.routesById[route.routeId] = route;
+          const children = routeConfig.children;
+          route.childRoutes = children != null && children.length ? recurseRoutes(children, route) : undefined;
+          return route;
+        });
+      };
+
+      const routes = recurseRoutes([rootRouteConfig]);
+      return routes[0];
+    },
+    parseLocation: (location, previousLocation) => {
+      var _location$hash$split$;
+
+      const parsedSearch = router.options.parseSearch(location.search);
+      return {
+        pathname: location.pathname,
+        searchStr: location.search,
+        search: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
+        hash: (_location$hash$split$ = location.hash.split('#').reverse()[0]) != null ? _location$hash$split$ : '',
+        href: "" + location.pathname + location.search + location.hash,
+        state: location.state,
+        key: location.key
+      };
+    },
+    buildLocation: function buildLocation(dest) {
+      var _dest$from, _router$basepath, _dest$to, _last, _dest$params, _dest$__preSearchFilt, _functionalUpdate, _dest$__preSearchFilt2, _dest$__postSearchFil;
+
+      if (dest === void 0) {
+        dest = {};
+      }
+
+      // const resolvedFrom: Location = {
+      //   ...router.location,
+      const fromPathname = dest.fromCurrent ? router.location.pathname : (_dest$from = dest.from) != null ? _dest$from : router.location.pathname;
+
+      let pathname = _resolvePath((_router$basepath = router.basepath) != null ? _router$basepath : '/', fromPathname, "" + ((_dest$to = dest.to) != null ? _dest$to : '.'));
+
+      const fromMatches = router.matchRoutes(router.location.pathname, {
+        strictParseParams: true
+      });
+      const toMatches = router.matchRoutes(pathname);
+      const prevParams = (_last = last(fromMatches)) == null ? void 0 : _last.params;
+      let nextParams = ((_dest$params = dest.params) != null ? _dest$params : true) === true ? prevParams : functionalUpdate(dest.params, prevParams);
+
+      if (nextParams) {
+        toMatches.map(d => d.options.stringifyParams).filter(Boolean).forEach(fn => {
+          Object.assign(nextParams, fn(nextParams));
+        });
+      }
+
+      pathname = interpolatePath(pathname, nextParams != null ? nextParams : {}); // Pre filters first
+
+      const preFilteredSearch = (_dest$__preSearchFilt = dest.__preSearchFilters) != null && _dest$__preSearchFilt.length ? dest.__preSearchFilters.reduce((prev, next) => next(prev), router.location.search) : router.location.search; // Then the link/navigate function
+
+      const destSearch = dest.search === true ? preFilteredSearch // Preserve resolvedFrom true
+      : dest.search ? (_functionalUpdate = functionalUpdate(dest.search, preFilteredSearch)) != null ? _functionalUpdate : {} // Updater
+      : (_dest$__preSearchFilt2 = dest.__preSearchFilters) != null && _dest$__preSearchFilt2.length ? preFilteredSearch // Preserve resolvedFrom filters
+      : {}; // Then post filters
+
+      const postFilteredSearch = (_dest$__postSearchFil = dest.__postSearchFilters) != null && _dest$__postSearchFil.length ? dest.__postSearchFilters.reduce((prev, next) => next(prev), destSearch) : destSearch;
+      const search = replaceEqualDeep(router.location.search, postFilteredSearch);
+      const searchStr = router.options.stringifySearch(search);
+      let hash = dest.hash === true ? router.location.hash : functionalUpdate(dest.hash, router.location.hash);
+      hash = hash ? "#" + hash : '';
+      return {
+        pathname,
+        search,
+        searchStr,
+        state: router.location.state,
+        hash,
+        href: "" + pathname + searchStr + hash,
+        key: dest.key
+      };
+    },
+    commitLocation: (next, replace) => {
+      const id = '' + Date.now() + Math.random();
+      if (router.navigateTimeout) clearTimeout(router.navigateTimeout);
+      let nextAction = 'replace';
+
+      if (!replace) {
+        nextAction = 'push';
+      }
+
+      const isSameUrl = router.parseLocation(history.location).href === next.href;
+
+      if (isSameUrl && !next.key) {
+        nextAction = 'replace';
+      }
+
+      if (nextAction === 'replace') {
+        history.replace({
+          pathname: next.pathname,
+          hash: next.hash,
+          search: next.searchStr
+        }, {
+          id
+        });
+      } 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();
+        };
+      });
+      return router.navigationPromise;
+    },
+    buildNext: opts => {
+      const next = router.buildLocation(opts);
+      const matches = router.matchRoutes(next.pathname);
+
+      const __preSearchFilters = matches.map(match => {
+        var _match$options$preSea;
+
+        return (_match$options$preSea = match.options.preSearchFilters) != null ? _match$options$preSea : [];
+      }).flat().filter(Boolean);
+
+      const __postSearchFilters = matches.map(match => {
+        var _match$options$postSe;
+
+        return (_match$options$postSe = match.options.postSearchFilters) != null ? _match$options$postSe : [];
+      }).flat().filter(Boolean);
+
+      return router.buildLocation(_extends$1({}, opts, {
+        __preSearchFilters,
+        __postSearchFilters
+      }));
+    },
+    cancelMatches: () => {
+      var _router$state$pending, _router$state$pending2;
+      [...router.state.matches, ...((_router$state$pending = (_router$state$pending2 = router.state.pending) == null ? void 0 : _router$state$pending2.matches) != null ? _router$state$pending : [])].forEach(match => {
+        match.cancel();
+      });
+    },
+    loadLocation: async next => {
+      const id = Math.random();
+      router.startedLoadingAt = id;
+
+      if (next) {
+        // Ingest the new location
+        router.location = next;
+      } // Cancel any pending matches
+
+
+      router.cancelMatches(); // Match the routes
+
+      const unloadedMatches = router.matchRoutes(location.pathname, {
+        strictParseParams: true
+      });
+      unloadedMatches.forEach((match, index) => {
+        const parent = unloadedMatches[index - 1];
+        const child = unloadedMatches[index + 1];
+        if (parent) match.__.setParentMatch(parent);
+        if (child) match.__.addChildMatch(child);
+      });
+      router.state = _extends$1({}, router.state, {
+        pending: {
+          matches: unloadedMatches,
+          location: router.location
+        }
+      });
+      router.notify(); // Load the matches
+
+      const matches = await router.loadMatches(unloadedMatches, {
+        withPending: true
+      });
+
+      if (router.startedLoadingAt !== id) {
+        // Ignore side-effects of match loading
+        return router.navigationPromise;
+      }
+
+      const previousMatches = router.state.matches;
+      previousMatches.filter(d => {
+        return !matches.find(dd => dd.matchId === d.matchId);
+      }).forEach(d => {
+        d.__.onExit == null ? void 0 : d.__.onExit({
+          params: d.params,
+          search: d.routeSearch
+        });
+      });
+      previousMatches.filter(d => {
+        return matches.find(dd => dd.matchId === d.matchId);
+      }).forEach(d => {
+        d.options.onTransition == null ? void 0 : d.options.onTransition({
+          params: d.params,
+          search: d.routeSearch
+        });
+      });
+      matches.filter(d => {
+        return !previousMatches.find(dd => dd.matchId === d.matchId);
+      }).forEach(d => {
+        d.__.onExit = d.options.onMatch == null ? void 0 : d.options.onMatch({
+          params: d.params,
+          search: d.search
+        });
+      });
+      router.state = _extends$1({}, router.state, {
+        location: router.location,
+        matches,
+        pending: undefined
+      });
+
+      if (matches.some(d => d.status === 'loading')) {
+        router.notify();
+        await Promise.all(matches.map(d => d.__.loaderPromise || Promise.resolve()));
+      }
+
+      if (router.startedLoadingAt !== id) {
+        // Ignore side-effects of match loading
+        return;
+      }
+
+      router.notify();
+      router.resolveNavigation();
+    },
+    cleanPreloadCache: () => {
+      const now = Date.now();
+      Object.keys(router.preloadCache).forEach(matchId => {
+        const entry = router.preloadCache[matchId]; // Don't remove loading matches
+
+        if (entry.match.status === 'loading') {
+          return;
+        } // Do not remove successful matches that are still valid
+
+
+        if (entry.match.updatedAt && entry.match.updatedAt + entry.maxAge > now) {
+          return;
+        } // Everything else gets removed
+
+
+        delete router.preloadCache[matchId];
+      });
+    },
+    loadRoute: async function loadRoute(navigateOpts, loaderOpts) {
+      if (navigateOpts === void 0) {
+        navigateOpts = router.location;
+      }
+
+      const next = router.buildNext(navigateOpts);
+      const matches = router.matchRoutes(next.pathname, {
+        strictParseParams: true
+      });
+      await router.loadMatches(matches, {
+        preload: true,
+        maxAge: loaderOpts.maxAge
+      });
+      return matches;
+    },
+    matchRoutes: (pathname, opts) => {
+      var _router$state$pending3, _router$state$pending4;
+
+      router.cleanPreloadCache();
+      const matches = [];
+
+      if (!router.routeTree) {
+        return matches;
+      }
+
+      const existingMatches = [...router.state.matches, ...((_router$state$pending3 = (_router$state$pending4 = router.state.pending) == null ? void 0 : _router$state$pending4.matches) != null ? _router$state$pending3 : [])];
+
+      const recurse = async (routes, parentMatch) => {
+        var _parentMatch$params, _router$options$filte, _router$preloadCache$, _route$childRoutes2;
+
+        let params = (_parentMatch$params = parentMatch == null ? void 0 : parentMatch.params) != null ? _parentMatch$params : {};
+        const filteredRoutes = (_router$options$filte = router.options.filterRoutes == null ? void 0 : router.options.filterRoutes(routes)) != null ? _router$options$filte : routes;
+        const route = filteredRoutes == null ? void 0 : filteredRoutes.find(route => {
+          var _route$childRoutes, _route$options$caseSe;
+
+          const fuzzy = !!(route.routePath !== '/' || (_route$childRoutes = route.childRoutes) != null && _route$childRoutes.length);
+          const matchParams = matchPathname(pathname, {
+            to: route.fullPath,
+            fuzzy,
+            caseSensitive: (_route$options$caseSe = route.options.caseSensitive) != null ? _route$options$caseSe : router.options.caseSensitive
+          });
+
+          if (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;
+            } catch (err) {
+              if (opts != null && opts.strictParseParams) {
+                throw err;
+              }
+            }
+
+            params = _extends$1({}, params, parsedParams);
+          }
+
+          return !!matchParams;
+        });
+
+        if (!route) {
+          return;
+        }
+
+        const interpolatedPath = interpolatePath(route.routePath, params);
+        const matchId = interpolatePath(route.routeId, params, true);
+        const match = existingMatches.find(d => d.matchId === matchId) || ((_router$preloadCache$ = router.preloadCache[matchId]) == null ? void 0 : _router$preloadCache$.match) || createRouteMatch(router, route, {
+          matchId,
+          params,
+          pathname: joinPaths([pathname, interpolatedPath])
+        });
+        matches.push(match);
+
+        if ((_route$childRoutes2 = route.childRoutes) != null && _route$childRoutes2.length) {
+          recurse(route.childRoutes, match);
+        }
+      };
+
+      recurse([router.routeTree]);
+      return matches;
+    },
+    loadMatches: async (resolvedMatches, loaderOpts) => {
+      const matchPromises = resolvedMatches.map(async match => {
+        // Validate the match (loads search params etc)
+        match.__.validate(); // If this is a preload, add it to the preload cache
+
+
+        if (loaderOpts != null && loaderOpts.preload) {
+          router.preloadCache[match.matchId] = {
+            maxAge: loaderOpts == null ? void 0 : loaderOpts.maxAge,
+            match
+          };
+        } // If the match is invalid, errored or idle, trigger it to load
+
+
+        if (match.status === 'success' && match.isInvalid || match.status === 'error' || match.status === 'idle') {
+          match.load();
+        } // If requested, start the pending timers
+
+
+        if (loaderOpts != null && loaderOpts.withPending) match.__.startPending(); // Wait for the first sign of activity from the match
+        // This might be completion, error, or a pending state
+
+        await match.__.loadPromise;
+      });
+      router.notify();
+      await Promise.all(matchPromises);
+      return resolvedMatches;
+    },
+    invalidateRoute: opts => {
+      var _router$state$pending5, _router$state$pending6;
+
+      const next = router.buildNext(opts);
+      const unloadedMatchIds = router.matchRoutes(next.pathname).map(d => d.matchId);
+      [...router.state.matches, ...((_router$state$pending5 = (_router$state$pending6 = router.state.pending) == null ? void 0 : _router$state$pending6.matches) != null ? _router$state$pending5 : [])].forEach(match => {
+        if (unloadedMatchIds.includes(match.matchId)) {
+          match.isInvalid = true;
+        }
+      });
+    },
+    reload: () => router._navigate({
+      fromCurrent: true,
+      replace: true,
+      search: true
+    }),
+    resolvePath: (from, path) => {
+      return _resolvePath(router.basepath, from, cleanPath(path));
+    },
+    matchRoute: (location, opts) => {
+      var _location$from;
+
+      // const location = router.buildNext(opts)
+      location = _extends$1({}, location, {
+        to: location.to ? router.resolvePath((_location$from = location.from) != null ? _location$from : '', location.to) : undefined
+      });
+      const next = router.buildNext(location);
+
+      if (opts != null && opts.pending) {
+        var _router$state$pending7;
+
+        if (!((_router$state$pending7 = router.state.pending) != null && _router$state$pending7.location)) {
+          return false;
+        }
+
+        return !!matchPathname(router.state.pending.location.pathname, _extends$1({}, opts, {
+          to: next.pathname
+        }));
+      }
+
+      return !!matchPathname(router.state.location.pathname, _extends$1({}, opts, {
+        to: next.pathname
+      }));
+    },
+    _navigate: location => {
+      const next = router.buildNext(location);
+      return router.commitLocation(next, location.replace);
+    },
+    navigate: async _ref => {
+      let {
+        from,
+        to = '.',
+        search,
+        hash,
+        replace
+      } = _ref;
+      // If this link simply reloads the current route,
+      // make sure it has a new key so it will trigger a data refresh
+      // If this `to` is a valid external URL, return
+      // null for LinkUtils
+      const toString = String(to);
+      const fromString = String(from);
+      let isExternal;
+
+      try {
+        new URL("" + toString);
+        isExternal = true;
+      } catch (e) {}
+
+      if (isExternal) {
+        if (process.env.NODE_ENV !== 'production') {
+          throw new Error('Attempting to navigate to external url with router.navigate!');
+        }
+
+        return;
+      }
+
+      return router._navigate({
+        from: fromString,
+        to: toString,
+        search,
+        hash
+      });
+    },
+    buildLink: _ref2 => {
+      var _preload, _ref3, _ref4;
+
+      let {
+        from,
+        to = '.',
+        search,
+        params,
+        hash,
+        target,
+        replace,
+        activeOptions,
+        preload,
+        preloadMaxAge: userPreloadMaxAge,
+        preloadDelay: userPreloadDelay,
+        disabled
+      } = _ref2;
+
+      // If this link simply reloads the current route,
+      // make sure it has a new key so it will trigger a data refresh
+      // If this `to` is a valid external URL, return
+      // null for LinkUtils
+      try {
+        new URL("" + to);
+        return {
+          type: 'external',
+          href: to
+        };
+      } catch (e) {}
+
+      const nextOpts = {
+        from,
+        to,
+        search,
+        params,
+        hash,
+        replace
+      };
+      const next = router.buildNext(nextOpts);
+      preload = (_preload = preload) != null ? _preload : router.options.defaultLinkPreload;
+      const preloadMaxAge = (_ref3 = userPreloadMaxAge != null ? userPreloadMaxAge : router.options.defaultLinkPreloadMaxAge) != null ? _ref3 : 2000;
+      const preloadDelay = (_ref4 = userPreloadDelay != null ? userPreloadDelay : router.options.defaultLinkPreloadDelay) != null ? _ref4 : 50; // Compare path/hash for matches
+
+      const pathIsEqual = router.state.location.pathname === next.pathname;
+      const currentPathSplit = router.state.location.pathname.split('/');
+      const nextPathSplit = next.pathname.split('/');
+      const pathIsFuzzyEqual = nextPathSplit.every((d, i) => d === currentPathSplit[i]);
+      const hashIsEqual = router.state.location.hash === next.hash; // Combine the matches based on user options
+
+      const pathTest = activeOptions != null && activeOptions.exact ? pathIsEqual : pathIsFuzzyEqual;
+      const hashTest = activeOptions != null && activeOptions.includeHash ? hashIsEqual : true; // The final "active" test
+
+      const isActive = pathTest && hashTest; // The click handler
+
+      const handleClick = e => {
+        if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!target || target === '_self') && e.button === 0) {
+          e.preventDefault();
+
+          if (pathIsEqual && !search && !hash) {
+            router.invalidateRoute(nextOpts);
+          } // All is well? Navigate!)
+
+
+          router._navigate(nextOpts);
+        }
+      }; // The click handler
+
+
+      const handleFocus = e => {
+        if (preload && preloadMaxAge > 0) {
+          router.loadRoute(nextOpts, {
+            maxAge: preloadMaxAge
+          });
+        }
+      };
+
+      const handleEnter = e => {
+        const target = e.target || {};
+
+        if (preload && preloadMaxAge > 0) {
+          if (target.preloadTimeout) {
+            return;
+          }
+
+          target.preloadTimeout = setTimeout(() => {
+            target.preloadTimeout = null;
+            router.loadRoute(nextOpts, {
+              maxAge: preloadMaxAge
+            });
+          }, preloadDelay);
+        }
+      };
+
+      const handleLeave = e => {
+        const target = e.target || {};
+
+        if (target.preloadTimeout) {
+          clearTimeout(target.preloadTimeout);
+          target.preloadTimeout = null;
+        }
+      };
+
+      return {
+        type: 'internal',
+        next,
+        handleFocus,
+        handleClick,
+        handleEnter,
+        handleLeave,
+        isActive,
+        disabled
+      };
+    },
+    __experimental__createSnapshot: () => {
+      return _extends$1({}, router.state, {
+        matches: router.state.matches.map(_ref5 => {
+          let {
+            routeLoaderData: loaderData,
+            matchId
+          } = _ref5;
+          return {
+            matchId,
+            loaderData
+          };
+        })
+      });
+    }
+  };
+  router.location = router.parseLocation(history.location); // router.state.location = __experimental__snapshot?.location ?? router.location
+
+  router.state.location = router.location;
+  router.update(userOptions); // Allow frameworks to hook into the router creation
+
+  router.options.createRouter == null ? void 0 : router.options.createRouter(router); // router.mount()
+
+  return router;
+}
+function createRoute(routeConfig, options, parent, router) {
+  // const id = (
+  //   options.path === rootRouteId
+  //     ? rootRouteId
+  //     : joinPaths([
+  //         parent!.id,
+  //         `${options.path?.replace(/(.)\/$/, '$1')}`,
+  //       ]).replace(new RegExp(`^${rootRouteId}`), '')
+  // ) as TRouteInfo['id']
+  const {
+    id: routeId,
+    path: routePath,
+    fullPath
+  } = routeConfig;
+
+  const action = router.state.actions[routeId] || (() => {
+    router.state.actions[routeId] = {
+      pending: [],
+      submit: async (submission, actionOpts) => {
+        var _actionOpts$invalidat;
+
+        if (!route) {
+          return;
+        }
+
+        const invalidate = (_actionOpts$invalidat = actionOpts == null ? void 0 : actionOpts.invalidate) != null ? _actionOpts$invalidat : true;
+        const actionState = {
+          submittedAt: Date.now(),
+          status: 'pending',
+          submission
+        };
+        action.latest = actionState;
+        action.pending.push(actionState);
+        router.state = _extends$1({}, router.state, {
+          action: 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 {
+          action.pending = action.pending.filter(d => d !== actionState);
+
+          if (actionState === router.state.action) {
+            router.state.action = undefined;
+          }
+
+          router.notify();
+        }
+      }
+    };
+    return router.state.actions[routeId];
+  })();
+
+  let route = {
+    routeId,
+    routePath,
+    fullPath,
+    options,
+    router,
+    childRoutes: undefined,
+    parentRoute: parent,
+    action,
+    buildLink: options => {
+      return router.buildLink(_extends$1({}, options, {
+        from: fullPath
+      }));
+    },
+    navigate: options => {
+      return router.navigate(_extends$1({}, options, {
+        from: fullPath
+      }));
+    },
+    matchRoute: (matchLocation, opts) => {
+      return router.matchRoute(_extends$1({}, matchLocation, {
+        from: fullPath
+      }), opts);
+    }
+  };
+  router.options.createRoute == null ? void 0 : router.options.createRoute({
+    router,
+    route
+  });
+  return route;
+}
+function createRouteMatch(router, route, opts) {
+  const routeMatch = _extends$1({}, route, opts, {
+    router,
+    routeSearch: {},
+    search: {},
+    childMatches: [],
+    status: 'idle',
+    routeLoaderData: {},
+    loaderData: {},
+    isPending: false,
+    isFetching: false,
+    isInvalid: false,
+    __: {
+      abortController: new AbortController(),
+      latestId: '',
+      resolve: () => {},
+      notify: () => {
+        routeMatch.__.resolve();
+
+        routeMatch.router.notify();
+      },
+      startPending: () => {
+        var _routeMatch$options$p, _routeMatch$options$p2;
+
+        const pendingMs = (_routeMatch$options$p = routeMatch.options.pendingMs) != null ? _routeMatch$options$p : router.options.defaultPendingMs;
+        const pendingMinMs = (_routeMatch$options$p2 = routeMatch.options.pendingMinMs) != null ? _routeMatch$options$p2 : router.options.defaultPendingMinMs;
+
+        if (routeMatch.__.pendingTimeout || routeMatch.status !== 'loading' || typeof pendingMs === 'undefined') {
+          return;
+        }
+
+        routeMatch.__.pendingTimeout = setTimeout(() => {
+          routeMatch.isPending = true;
+
+          routeMatch.__.resolve();
+
+          if (typeof pendingMinMs !== 'undefined') {
+            routeMatch.__.pendingMinPromise = new Promise(r => routeMatch.__.pendingMinTimeout = setTimeout(r, pendingMinMs));
+          }
+        }, pendingMs);
+      },
+      cancelPending: () => {
+        routeMatch.isPending = false;
+        clearTimeout(routeMatch.__.pendingTimeout);
+        clearTimeout(routeMatch.__.pendingMinTimeout);
+        delete routeMatch.__.pendingMinPromise;
+      },
+      setParentMatch: parentMatch => {
+        routeMatch.parentMatch = parentMatch;
+      },
+      addChildMatch: childMatch => {
+        if (routeMatch.childMatches.find(d => d.matchId === childMatch.matchId)) {
+          return;
+        }
+
+        routeMatch.childMatches.push(childMatch);
+      },
+      validate: () => {
+        var _routeMatch$parentMat, _routeMatch$parentMat2;
+
+        // Validate the search params and stabilize them
+        const parentSearch = (_routeMatch$parentMat = (_routeMatch$parentMat2 = routeMatch.parentMatch) == null ? void 0 : _routeMatch$parentMat2.search) != null ? _routeMatch$parentMat : router.location.search;
+
+        try {
+          const prevSearch = routeMatch.routeSearch;
+          let nextSearch = replaceEqualDeep(prevSearch, routeMatch.options.validateSearch == null ? void 0 : routeMatch.options.validateSearch(parentSearch)); // Invalidate route matches when search param stability changes
+
+          if (prevSearch !== nextSearch) {
+            routeMatch.isInvalid = true;
+          }
+
+          routeMatch.routeSearch = nextSearch;
+          routeMatch.search = replaceEqualDeep(parentSearch, _extends$1({}, parentSearch, nextSearch));
+        } catch (err) {
+          console.error(err);
+          const error = new Error('Invalid search params found', {
+            cause: err
+          });
+          error.code = 'INVALID_SEARCH_PARAMS';
+          routeMatch.status = 'error';
+          routeMatch.error = error; // Do not proceed with loading the route
+
+          return;
+        }
+      }
+    },
+    cancel: () => {
+      var _routeMatch$__$abortC;
+
+      (_routeMatch$__$abortC = routeMatch.__.abortController) == null ? void 0 : _routeMatch$__$abortC.abort();
+
+      routeMatch.__.cancelPending();
+    },
+    load: async () => {
+      const id = '' + Date.now() + Math.random();
+      routeMatch.__.latestId = id; // If the match was in an error state, set it
+      // to a loading state again. Otherwise, keep it
+      // as loading or resolved
+
+      if (routeMatch.status === 'error' || routeMatch.status === 'idle') {
+        routeMatch.status = 'loading';
+      } // We started loading the route, so it's no longer invalid
+
+
+      routeMatch.isInvalid = false;
+      routeMatch.__.loadPromise = new Promise(async resolve => {
+        // We are now fetching, even if it's in the background of a
+        // resolved state
+        routeMatch.isFetching = true;
+        routeMatch.__.resolve = resolve;
+
+        const loaderPromise = (async () => {
+          const importer = routeMatch.options.import; // First, run any importers
+
+          if (importer) {
+            routeMatch.__.importPromise = importer({
+              params: routeMatch.params // search: routeMatch.search,
+
+            }).then(imported => {
+              routeMatch.__ = _extends$1({}, routeMatch.__, imported);
+            });
+          } // Wait for the importer to finish before
+          // attempting to load elements and data
+
+
+          await routeMatch.__.importPromise; // Next, load the elements and data in parallel
+
+          routeMatch.__.elementsPromise = (async () => {
+            // then run all element and data loaders in parallel
+            // For each element type, potentially load it asynchronously
+            const elementTypes = ['element', 'errorElement', 'catchElement', 'pendingElement'];
+            await Promise.all(elementTypes.map(async type => {
+              const routeElement = routeMatch.options[type];
+
+              if (routeMatch.__[type]) {
+                return;
+              }
+
+              if (typeof routeElement === 'function') {
+                const res = await routeElement(routeMatch);
+                routeMatch.__[type] = res;
+              } else {
+                routeMatch.__[type] = routeMatch.options[type];
+              }
+            }));
+          })();
+
+          routeMatch.__.dataPromise = Promise.resolve().then(async () => {
+            try {
+              const data = await (routeMatch.options.loader == null ? void 0 : routeMatch.options.loader({
+                params: routeMatch.params,
+                search: routeMatch.routeSearch,
+                signal: routeMatch.__.abortController.signal
+              }));
+
+              if (id !== routeMatch.__.latestId) {
+                return routeMatch.__.loaderPromise;
+              }
+
+              routeMatch.routeLoaderData = replaceEqualDeep(routeMatch.routeLoaderData, data);
+              cascadeLoaderData(routeMatch);
+              routeMatch.error = undefined;
+              routeMatch.status = 'success';
+              routeMatch.updatedAt = Date.now();
+            } catch (err) {
+              if (id !== routeMatch.__.latestId) {
+                return routeMatch.__.loaderPromise;
+              }
+
+              if (process.env.NODE_ENV !== 'production') {
+                console.error(err);
+              }
+
+              routeMatch.error = err;
+              routeMatch.status = 'error';
+              routeMatch.updatedAt = Date.now();
+            }
+          });
+
+          try {
+            await Promise.all([routeMatch.__.elementsPromise, routeMatch.__.dataPromise]);
+
+            if (id !== routeMatch.__.latestId) {
+              return routeMatch.__.loaderPromise;
+            }
+
+            if (routeMatch.__.pendingMinPromise) {
+              await routeMatch.__.pendingMinPromise;
+              delete routeMatch.__.pendingMinPromise;
+            }
+          } finally {
+            if (id !== routeMatch.__.latestId) {
+              return routeMatch.__.loaderPromise;
+            }
+
+            routeMatch.__.cancelPending();
+
+            routeMatch.isPending = false;
+            routeMatch.isFetching = false;
+
+            routeMatch.__.notify();
+          }
+        })();
+
+        routeMatch.__.loaderPromise = loaderPromise;
+        await loaderPromise;
+
+        if (id !== routeMatch.__.latestId) {
+          return routeMatch.__.loaderPromise;
+        }
+
+        delete routeMatch.__.loaderPromise;
+      });
+      return await routeMatch.__.loadPromise;
+    }
+  });
+
+  return routeMatch;
+}
+
+function cascadeLoaderData(routeMatch) {
+  if (routeMatch.parentMatch) {
+    routeMatch.loaderData = replaceEqualDeep(routeMatch.loaderData, _extends$1({}, routeMatch.parentMatch.loaderData, routeMatch.routeLoaderData));
+  }
+
+  if (routeMatch.childMatches.length) {
+    routeMatch.childMatches.forEach(childMatch => {
+      cascadeLoaderData(childMatch);
+    });
+  }
+}
+
+function matchPathname(currentPathname, matchLocation) {
+  const pathParams = matchByPath(currentPathname, matchLocation); // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
+
+  if (matchLocation.to && !pathParams) {
+    return;
+  } // if (matchLocation.search && !searchMatched) {
+  //   return
+  // }
+
+
+  return pathParams != null ? pathParams : {};
+}
+
+function interpolatePath(path, params, leaveWildcard) {
+  const interpolatedPathSegments = parsePathname(path);
+  return joinPaths(interpolatedPathSegments.map(segment => {
+    if (segment.value === '*' && !leaveWildcard) {
+      return '';
+    }
+
+    if (segment.type === 'param') {
+      var _segment$value$substr;
+
+      return (_segment$value$substr = params[segment.value.substring(1)]) != null ? _segment$value$substr : '';
+    }
+
+    return segment.value;
+  }));
+}
+
+function warning(cond, message) {
+  if (cond) {
+    if (typeof console !== 'undefined') console.warn(message);
+
+    try {
+      throw new Error(message);
+    } catch (_unused) {}
+  }
+
+  return true;
+}
+
+function isFunction(d) {
+  return typeof d === 'function';
+}
+
+function functionalUpdate(updater, previous) {
+  if (isFunction(updater)) {
+    return updater(previous);
+  }
+
+  return updater;
+}
+
+function joinPaths(paths) {
+  return cleanPath(paths.filter(Boolean).join('/'));
+}
+
+function cleanPath(path) {
+  // remove double slashes
+  return path.replace(/\/{2,}/g, '/');
+}
+
+function trimPathLeft(path) {
+  return path === '/' ? path : path.replace(/^\/{1,}/, '');
+}
+
+function trimPathRight(path) {
+  return path === '/' ? path : path.replace(/\/{1,}$/, '');
+}
+
+function trimPath(path) {
+  return trimPathRight(trimPathLeft(path));
+}
+
+function matchByPath(from, matchLocation) {
+  var _matchLocation$to;
+
+  const baseSegments = parsePathname(from);
+  const routeSegments = parsePathname("" + ((_matchLocation$to = matchLocation.to) != null ? _matchLocation$to : '*'));
+  const params = {};
+
+  let isMatch = (() => {
+    for (let i = 0; i < Math.max(baseSegments.length, routeSegments.length); i++) {
+      const baseSegment = baseSegments[i];
+      const routeSegment = routeSegments[i];
+      const isLastRouteSegment = i === routeSegments.length - 1;
+      const isLastBaseSegment = i === baseSegments.length - 1;
+
+      if (routeSegment) {
+        if (routeSegment.type === 'wildcard') {
+          if (baseSegment != null && baseSegment.value) {
+            params['*'] = joinPaths(baseSegments.slice(i).map(d => d.value));
+            return true;
+          }
+
+          return false;
+        }
+
+        if (routeSegment.type === 'pathname') {
+          if (routeSegment.value === '/' && !(baseSegment != null && baseSegment.value)) {
+            return true;
+          }
+
+          if (baseSegment) {
+            if (matchLocation.caseSensitive) {
+              if (routeSegment.value !== baseSegment.value) {
+                return false;
+              }
+            } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
+              return false;
+            }
+          }
+        }
+
+        if (!baseSegment) {
+          return false;
+        }
+
+        if (routeSegment.type === 'param') {
+          if ((baseSegment == null ? void 0 : baseSegment.value) === '/') {
+            return false;
+          }
+
+          if (!baseSegment.value.startsWith(':')) {
+            params[routeSegment.value.substring(1)] = baseSegment.value;
+          }
+        }
+      }
+
+      if (isLastRouteSegment && !isLastBaseSegment) {
+        return !!matchLocation.fuzzy;
+      }
+    }
+
+    return true;
+  })();
+
+  return isMatch ? params : undefined;
+} // function matchBySearch(
+//   search: SearchSchema,
+//   matchLocation: MatchLocation,
+// ) {
+//   return !!(matchLocation.search && matchLocation.search(search))
+// }
+
+function parsePathname(pathname) {
+  if (!pathname) {
+    return [];
+  }
+
+  pathname = cleanPath(pathname);
+  const segments = [];
+
+  if (pathname.slice(0, 1) === '/') {
+    pathname = pathname.substring(1);
+    segments.push({
+      type: 'pathname',
+      value: '/'
+    });
+  }
+
+  if (!pathname) {
+    return segments;
+  } // Remove empty segments and '.' segments
+
+
+  const split = pathname.split('/').filter(Boolean);
+  segments.push(...split.map(part => {
+    if (part.startsWith('*')) {
+      return {
+        type: 'wildcard',
+        value: part
+      };
+    }
+
+    if (part.charAt(0) === ':') {
+      return {
+        type: 'param',
+        value: part
+      };
+    }
+
+    return {
+      type: 'pathname',
+      value: part
+    };
+  }));
+
+  if (pathname.slice(-1) === '/') {
+    pathname = pathname.substring(1);
+    segments.push({
+      type: 'pathname',
+      value: '/'
+    });
+  }
+
+  return segments;
+}
+
+function _resolvePath(basepath, base, to) {
+  base = base.replace(new RegExp("^" + basepath), '/');
+  to = to.replace(new RegExp("^" + basepath), '/');
+  let baseSegments = parsePathname(base);
+  const toSegments = parsePathname(to);
+  toSegments.forEach((toSegment, index) => {
+    if (toSegment.value === '/') {
+      if (!index) {
+        // Leading slash
+        baseSegments = [toSegment];
+      } else if (index === toSegments.length - 1) {
+        // Trailing Slash
+        baseSegments.push(toSegment);
+      } else ;
+    } else if (toSegment.value === '..') {
+      var _last2;
+
+      // Extra trailing slash? pop it off
+      if (baseSegments.length > 1 && ((_last2 = last(baseSegments)) == null ? void 0 : _last2.value) === '/') {
+        baseSegments.pop();
+      }
+
+      baseSegments.pop();
+    } else if (toSegment.value === '.') {
+      return;
+    } else {
+      baseSegments.push(toSegment);
+    }
+  });
+  const joined = joinPaths([basepath, ...baseSegments.map(d => d.value)]);
+  return cleanPath(joined);
+}
+function replaceEqualDeep(prev, next) {
+  if (prev === next) {
+    return prev;
+  }
+
+  const 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]';
+}
+
+const defaultParseSearch = parseSearchWith(JSON.parse);
+const defaultStringifySearch = stringifySearchWith(JSON.stringify);
+function parseSearchWith(parser) {
+  return searchStr => {
+    if (searchStr.substring(0, 1) === '?') {
+      searchStr = searchStr.substring(1);
+    }
+
+    let query = decode(searchStr); // Try to parse any query params that might be json
+
+    for (let key in query) {
+      const value = query[key];
+
+      if (typeof value === 'string') {
+        try {
+          query[key] = parser(value);
+        } catch (err) {//
+        }
+      }
+    }
+
+    return query;
+  };
+}
+function stringifySearchWith(stringify) {
+  return search => {
+    search = _extends$1({}, search);
+
+    if (search) {
+      Object.keys(search).forEach(key => {
+        const val = search[key];
+
+        if (typeof val === 'undefined' || val === undefined) {
+          delete search[key];
+        } else if (val && typeof val === 'object' && val !== null) {
+          try {
+            search[key] = stringify(val);
+          } catch (err) {// silent
+          }
+        }
+      });
+    }
+
+    const searchStr = encode(search).toString();
+    return searchStr ? "?" + searchStr : '';
+  };
+}
+
+function isCtrlEvent(e) {
+  return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+
+function last(arr) {
+  return arr[arr.length - 1];
+}
+
+exports.createBrowserHistory = createBrowserHistory;
+exports.createHashHistory = createHashHistory;
+exports.createMemoryHistory = createMemoryHistory;
+exports.createRoute = createRoute;
+exports.createRouteConfig = createRouteConfig;
+exports.createRouteMatch = createRouteMatch;
+exports.createRouter = createRouter;
+exports.defaultParseSearch = defaultParseSearch;
+exports.defaultStringifySearch = defaultStringifySearch;
+exports.functionalUpdate = functionalUpdate;
+exports.last = last;
+exports.matchByPath = matchByPath;
+exports.matchPathname = matchPathname;
+exports.parsePathname = parsePathname;
+exports.parseSearchWith = parseSearchWith;
+exports.replaceEqualDeep = replaceEqualDeep;
+exports.resolvePath = _resolvePath;
+exports.rootRouteId = rootRouteId;
+exports.stringifySearchWith = stringifySearchWith;
+exports.warning = warning;
+//# sourceMappingURL=index.js.map