zudoku 0.3.0-dev.21 → 0.3.0-dev.22

package/lib/router-DibNxKUP.js

@@ -0,0 +1,3008 @@
+import dr from "react";
+var Wt = { exports: {} }, nt = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Kt;
+function Pr() {
+  if (Kt) return nt;
+  Kt = 1;
+  var e = dr, t = Symbol.for("react.element"), n = Symbol.for("react.fragment"), a = Object.prototype.hasOwnProperty, o = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, h = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function f(d, c, w) {
+    var R, g = {}, E = null, I = null;
+    w !== void 0 && (E = "" + w), c.key !== void 0 && (E = "" + c.key), c.ref !== void 0 && (I = c.ref);
+    for (R in c) a.call(c, R) && !h.hasOwnProperty(R) && (g[R] = c[R]);
+    if (d && d.defaultProps) for (R in c = d.defaultProps, c) g[R] === void 0 && (g[R] = c[R]);
+    return { $$typeof: t, type: d, key: E, ref: I, props: g, _owner: o.current };
+  }
+  return nt.Fragment = n, nt.jsx = f, nt.jsxs = f, nt;
+}
+var it = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Jt;
+function xr() {
+  return Jt || (Jt = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = dr, t = Symbol.for("react.element"), n = Symbol.for("react.portal"), a = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), h = Symbol.for("react.profiler"), f = Symbol.for("react.provider"), d = Symbol.for("react.context"), c = Symbol.for("react.forward_ref"), w = Symbol.for("react.suspense"), R = Symbol.for("react.suspense_list"), g = Symbol.for("react.memo"), E = Symbol.for("react.lazy"), I = Symbol.for("react.offscreen"), j = Symbol.iterator, M = "@@iterator";
+    function A(r) {
+      if (r === null || typeof r != "object")
+        return null;
+      var s = j && r[j] || r[M];
+      return typeof s == "function" ? s : null;
+    }
+    var k = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function T(r) {
+      {
+        for (var s = arguments.length, v = new Array(s > 1 ? s - 1 : 0), y = 1; y < s; y++)
+          v[y - 1] = arguments[y];
+        pe("error", r, v);
+      }
+    }
+    function pe(r, s, v) {
+      {
+        var y = k.ReactDebugCurrentFrame, b = y.getStackAddendum();
+        b !== "" && (s += "%s", v = v.concat([b]));
+        var _ = v.map(function(D) {
+          return String(D);
+        });
+        _.unshift("Warning: " + s), Function.prototype.apply.call(console[r], console, _);
+      }
+    }
+    var Q = !1, re = !1, m = !1, ae = !1, ue = !1, U;
+    U = Symbol.for("react.module.reference");
+    function Z(r) {
+      return !!(typeof r == "string" || typeof r == "function" || r === a || r === h || ue || r === o || r === w || r === R || ae || r === I || Q || re || m || typeof r == "object" && r !== null && (r.$$typeof === E || r.$$typeof === g || r.$$typeof === f || r.$$typeof === d || r.$$typeof === c || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      r.$$typeof === U || r.getModuleId !== void 0));
+    }
+    function J(r, s, v) {
+      var y = r.displayName;
+      if (y)
+        return y;
+      var b = s.displayName || s.name || "";
+      return b !== "" ? v + "(" + b + ")" : v;
+    }
+    function ie(r) {
+      return r.displayName || "Context";
+    }
+    function V(r) {
+      if (r == null)
+        return null;
+      if (typeof r.tag == "number" && T("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof r == "function")
+        return r.displayName || r.name || null;
+      if (typeof r == "string")
+        return r;
+      switch (r) {
+        case a:
+          return "Fragment";
+        case n:
+          return "Portal";
+        case h:
+          return "Profiler";
+        case o:
+          return "StrictMode";
+        case w:
+          return "Suspense";
+        case R:
+          return "SuspenseList";
+      }
+      if (typeof r == "object")
+        switch (r.$$typeof) {
+          case d:
+            var s = r;
+            return ie(s) + ".Consumer";
+          case f:
+            var v = r;
+            return ie(v._context) + ".Provider";
+          case c:
+            return J(r, r.render, "ForwardRef");
+          case g:
+            var y = r.displayName || null;
+            return y !== null ? y : V(r.type) || "Memo";
+          case E: {
+            var b = r, _ = b._payload, D = b._init;
+            try {
+              return V(D(_));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var B = Object.assign, fe = 0, Ue, $, Ie, _e, Ee, ce, Se;
+    function Te() {
+    }
+    Te.__reactDisabledLog = !0;
+    function me() {
+      {
+        if (fe === 0) {
+          Ue = console.log, $ = console.info, Ie = console.warn, _e = console.error, Ee = console.group, ce = console.groupCollapsed, Se = console.groupEnd;
+          var r = {
+            configurable: !0,
+            enumerable: !0,
+            value: Te,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: r,
+            log: r,
+            warn: r,
+            error: r,
+            group: r,
+            groupCollapsed: r,
+            groupEnd: r
+          });
+        }
+        fe++;
+      }
+    }
+    function De() {
+      {
+        if (fe--, fe === 0) {
+          var r = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: B({}, r, {
+              value: Ue
+            }),
+            info: B({}, r, {
+              value: $
+            }),
+            warn: B({}, r, {
+              value: Ie
+            }),
+            error: B({}, r, {
+              value: _e
+            }),
+            group: B({}, r, {
+              value: Ee
+            }),
+            groupCollapsed: B({}, r, {
+              value: ce
+            }),
+            groupEnd: B({}, r, {
+              value: Se
+            })
+          });
+        }
+        fe < 0 && T("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ve = k.ReactCurrentDispatcher, Qe;
+    function Me(r, s, v) {
+      {
+        if (Qe === void 0)
+          try {
+            throw Error();
+          } catch (b) {
+            var y = b.stack.trim().match(/\n( *(at )?)/);
+            Qe = y && y[1] || "";
+          }
+        return `
+` + Qe + r;
+      }
+    }
+    var Ze = !1, Ye;
+    {
+      var Mt = typeof WeakMap == "function" ? WeakMap : Map;
+      Ye = new Mt();
+    }
+    function X(r, s) {
+      if (!r || Ze)
+        return "";
+      {
+        var v = Ye.get(r);
+        if (v !== void 0)
+          return v;
+      }
+      var y;
+      Ze = !0;
+      var b = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var _;
+      _ = ve.current, ve.current = null, me();
+      try {
+        if (s) {
+          var D = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(D.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(D, []);
+            } catch (K) {
+              y = K;
+            }
+            Reflect.construct(r, [], D);
+          } else {
+            try {
+              D.call();
+            } catch (K) {
+              y = K;
+            }
+            r.call(D.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (K) {
+            y = K;
+          }
+          r();
+        }
+      } catch (K) {
+        if (K && y && typeof K.stack == "string") {
+          for (var P = K.stack.split(`
+`), C = y.stack.split(`
+`), O = P.length - 1, L = C.length - 1; O >= 1 && L >= 0 && P[O] !== C[L]; )
+            L--;
+          for (; O >= 1 && L >= 0; O--, L--)
+            if (P[O] !== C[L]) {
+              if (O !== 1 || L !== 1)
+                do
+                  if (O--, L--, L < 0 || P[O] !== C[L]) {
+                    var q = `
+` + P[O].replace(" at new ", " at ");
+                    return r.displayName && q.includes("<anonymous>") && (q = q.replace("<anonymous>", r.displayName)), typeof r == "function" && Ye.set(r, q), q;
+                  }
+                while (O >= 1 && L >= 0);
+              break;
+            }
+        }
+      } finally {
+        Ze = !1, ve.current = _, De(), Error.prepareStackTrace = b;
+      }
+      var ee = r ? r.displayName || r.name : "", ne = ee ? Me(ee) : "";
+      return typeof r == "function" && Ye.set(r, ne), ne;
+    }
+    function Ce(r, s, v) {
+      return X(r, !1);
+    }
+    function pt(r) {
+      var s = r.prototype;
+      return !!(s && s.isReactComponent);
+    }
+    function Ve(r, s, v) {
+      if (r == null)
+        return "";
+      if (typeof r == "function")
+        return X(r, pt(r));
+      if (typeof r == "string")
+        return Me(r);
+      switch (r) {
+        case w:
+          return Me("Suspense");
+        case R:
+          return Me("SuspenseList");
+      }
+      if (typeof r == "object")
+        switch (r.$$typeof) {
+          case c:
+            return Ce(r.render);
+          case g:
+            return Ve(r.type, s, v);
+          case E: {
+            var y = r, b = y._payload, _ = y._init;
+            try {
+              return Ve(_(b), s, v);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var oe = Object.prototype.hasOwnProperty, mt = {}, vt = k.ReactDebugCurrentFrame;
+    function ke(r) {
+      if (r) {
+        var s = r._owner, v = Ve(r.type, r._source, s ? s.type : null);
+        vt.setExtraStackFrame(v);
+      } else
+        vt.setExtraStackFrame(null);
+    }
+    function Ct(r, s, v, y, b) {
+      {
+        var _ = Function.call.bind(oe);
+        for (var D in r)
+          if (_(r, D)) {
+            var P = void 0;
+            try {
+              if (typeof r[D] != "function") {
+                var C = Error((y || "React class") + ": " + v + " type `" + D + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof r[D] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw C.name = "Invariant Violation", C;
+              }
+              P = r[D](s, D, y, v, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (O) {
+              P = O;
+            }
+            P && !(P instanceof Error) && (ke(b), T("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", y || "React class", v, D, typeof P), ke(null)), P instanceof Error && !(P.message in mt) && (mt[P.message] = !0, ke(b), T("Failed %s type: %s", v, P.message), ke(null));
+          }
+      }
+    }
+    var Lt = Array.isArray;
+    function et(r) {
+      return Lt(r);
+    }
+    function jt(r) {
+      {
+        var s = typeof Symbol == "function" && Symbol.toStringTag, v = s && r[Symbol.toStringTag] || r.constructor.name || "Object";
+        return v;
+      }
+    }
+    function Ne(r) {
+      try {
+        return Le(r), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Le(r) {
+      return "" + r;
+    }
+    function tt(r) {
+      if (Ne(r))
+        return T("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", jt(r)), Le(r);
+    }
+    var Pe = k.ReactCurrentOwner, ye = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, de, rt, je;
+    je = {};
+    function Ot(r) {
+      if (oe.call(r, "ref")) {
+        var s = Object.getOwnPropertyDescriptor(r, "ref").get;
+        if (s && s.isReactWarning)
+          return !1;
+      }
+      return r.ref !== void 0;
+    }
+    function be(r) {
+      if (oe.call(r, "key")) {
+        var s = Object.getOwnPropertyDescriptor(r, "key").get;
+        if (s && s.isReactWarning)
+          return !1;
+      }
+      return r.key !== void 0;
+    }
+    function gt(r, s) {
+      if (typeof r.ref == "string" && Pe.current && s && Pe.current.stateNode !== s) {
+        var v = V(Pe.current.type);
+        je[v] || (T('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', V(Pe.current.type), r.ref), je[v] = !0);
+      }
+    }
+    function yt(r, s) {
+      {
+        var v = function() {
+          de || (de = !0, T("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", s));
+        };
+        v.isReactWarning = !0, Object.defineProperty(r, "key", {
+          get: v,
+          configurable: !0
+        });
+      }
+    }
+    function bt(r, s) {
+      {
+        var v = function() {
+          rt || (rt = !0, T("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", s));
+        };
+        v.isReactWarning = !0, Object.defineProperty(r, "ref", {
+          get: v,
+          configurable: !0
+        });
+      }
+    }
+    var Ft = function(r, s, v, y, b, _, D) {
+      var P = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: r,
+        key: s,
+        ref: v,
+        props: D,
+        // Record the component responsible for creating this element.
+        _owner: _
+      };
+      return P._store = {}, Object.defineProperty(P._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(P, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: y
+      }), Object.defineProperty(P, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: b
+      }), Object.freeze && (Object.freeze(P.props), Object.freeze(P)), P;
+    };
+    function Rt(r, s, v, y, b) {
+      {
+        var _, D = {}, P = null, C = null;
+        v !== void 0 && (tt(v), P = "" + v), be(s) && (tt(s.key), P = "" + s.key), Ot(s) && (C = s.ref, gt(s, b));
+        for (_ in s)
+          oe.call(s, _) && !ye.hasOwnProperty(_) && (D[_] = s[_]);
+        if (r && r.defaultProps) {
+          var O = r.defaultProps;
+          for (_ in O)
+            D[_] === void 0 && (D[_] = O[_]);
+        }
+        if (P || C) {
+          var L = typeof r == "function" ? r.displayName || r.name || "Unknown" : r;
+          P && yt(D, L), C && bt(D, L);
+        }
+        return Ft(r, P, C, b, y, Pe.current, D);
+      }
+    }
+    var Oe = k.ReactCurrentOwner, at = k.ReactDebugCurrentFrame;
+    function Re(r) {
+      if (r) {
+        var s = r._owner, v = Ve(r.type, r._source, s ? s.type : null);
+        at.setExtraStackFrame(v);
+      } else
+        at.setExtraStackFrame(null);
+    }
+    var Fe;
+    Fe = !1;
+    function We(r) {
+      return typeof r == "object" && r !== null && r.$$typeof === t;
+    }
+    function wt() {
+      {
+        if (Oe.current) {
+          var r = V(Oe.current.type);
+          if (r)
+            return `
+
+Check the render method of \`` + r + "`.";
+        }
+        return "";
+      }
+    }
+    function Et(r) {
+      return "";
+    }
+    var St = {};
+    function Dt(r) {
+      {
+        var s = wt();
+        if (!s) {
+          var v = typeof r == "string" ? r : r.displayName || r.name;
+          v && (s = `
+
+Check the top-level render call using <` + v + ">.");
+        }
+        return s;
+      }
+    }
+    function Ke(r, s) {
+      {
+        if (!r._store || r._store.validated || r.key != null)
+          return;
+        r._store.validated = !0;
+        var v = Dt(s);
+        if (St[v])
+          return;
+        St[v] = !0;
+        var y = "";
+        r && r._owner && r._owner !== Oe.current && (y = " It was passed a child from " + V(r._owner.type) + "."), Re(r), T('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', v, y), Re(null);
+      }
+    }
+    function ze(r, s) {
+      {
+        if (typeof r != "object")
+          return;
+        if (et(r))
+          for (var v = 0; v < r.length; v++) {
+            var y = r[v];
+            We(y) && Ke(y, s);
+          }
+        else if (We(r))
+          r._store && (r._store.validated = !0);
+        else if (r) {
+          var b = A(r);
+          if (typeof b == "function" && b !== r.entries)
+            for (var _ = b.call(r), D; !(D = _.next()).done; )
+              We(D.value) && Ke(D.value, s);
+        }
+      }
+    }
+    function At(r) {
+      {
+        var s = r.type;
+        if (s == null || typeof s == "string")
+          return;
+        var v;
+        if (typeof s == "function")
+          v = s.propTypes;
+        else if (typeof s == "object" && (s.$$typeof === c || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        s.$$typeof === g))
+          v = s.propTypes;
+        else
+          return;
+        if (v) {
+          var y = V(s);
+          Ct(v, r.props, "prop", y, r);
+        } else if (s.PropTypes !== void 0 && !Fe) {
+          Fe = !0;
+          var b = V(s);
+          T("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", b || "Unknown");
+        }
+        typeof s.getDefaultProps == "function" && !s.getDefaultProps.isReactClassApproved && T("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Ut(r) {
+      {
+        for (var s = Object.keys(r.props), v = 0; v < s.length; v++) {
+          var y = s[v];
+          if (y !== "children" && y !== "key") {
+            Re(r), T("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", y), Re(null);
+            break;
+          }
+        }
+        r.ref !== null && (Re(r), T("Invalid attribute `ref` supplied to `React.Fragment`."), Re(null));
+      }
+    }
+    var i = {};
+    function l(r, s, v, y, b, _) {
+      {
+        var D = Z(r);
+        if (!D) {
+          var P = "";
+          (r === void 0 || typeof r == "object" && r !== null && Object.keys(r).length === 0) && (P += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var C = Et();
+          C ? P += C : P += wt();
+          var O;
+          r === null ? O = "null" : et(r) ? O = "array" : r !== void 0 && r.$$typeof === t ? (O = "<" + (V(r.type) || "Unknown") + " />", P = " Did you accidentally export a JSX literal instead of a component?") : O = typeof r, T("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", O, P);
+        }
+        var L = Rt(r, s, v, b, _);
+        if (L == null)
+          return L;
+        if (D) {
+          var q = s.children;
+          if (q !== void 0)
+            if (y)
+              if (et(q)) {
+                for (var ee = 0; ee < q.length; ee++)
+                  ze(q[ee], r);
+                Object.freeze && Object.freeze(q);
+              } else
+                T("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              ze(q, r);
+        }
+        if (oe.call(s, "key")) {
+          var ne = V(r), K = Object.keys(s).filter(function(Je) {
+            return Je !== "key";
+          }), we = K.length > 0 ? "{key: someKey, " + K.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!i[ne + we]) {
+            var he = K.length > 0 ? "{" + K.join(": ..., ") + ": ...}" : "{}";
+            T(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, we, ne, he, ne), i[ne + we] = !0;
+          }
+        }
+        return r === a ? Ut(L) : At(L), L;
+      }
+    }
+    function u(r, s, v) {
+      return l(r, s, v, !0);
+    }
+    function p(r, s, v) {
+      return l(r, s, v, !1);
+    }
+    var S = p, x = u;
+    it.Fragment = a, it.jsx = S, it.jsxs = x;
+  }()), it;
+}
+process.env.NODE_ENV === "production" ? Wt.exports = Pr() : Wt.exports = xr();
+var Da = Wt.exports;
+/**
+ * @remix-run/router v1.17.1
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * 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 H() {
+  return H = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var n = arguments[t];
+      for (var a in n)
+        Object.prototype.hasOwnProperty.call(n, a) && (e[a] = n[a]);
+    }
+    return e;
+  }, H.apply(this, arguments);
+}
+var G;
+(function(e) {
+  e.Pop = "POP", e.Push = "PUSH", e.Replace = "REPLACE";
+})(G || (G = {}));
+const Gt = "popstate";
+function Pa(e) {
+  e === void 0 && (e = {});
+  function t(a, o) {
+    let {
+      pathname: h,
+      search: f,
+      hash: d
+    } = a.location;
+    return ct(
+      "",
+      {
+        pathname: h,
+        search: f,
+        hash: d
+      },
+      // state defaults to `null` because `window.history.state` does
+      o.state && o.state.usr || null,
+      o.state && o.state.key || "default"
+    );
+  }
+  function n(a, o) {
+    return typeof o == "string" ? o : ht(o);
+  }
+  return Tr(t, n, null, e);
+}
+function N(e, t) {
+  if (e === !1 || e === null || typeof e > "u")
+    throw new Error(t);
+}
+function qe(e, t) {
+  if (!e) {
+    typeof console < "u" && console.warn(t);
+    try {
+      throw new Error(t);
+    } catch {
+    }
+  }
+}
+function _r() {
+  return Math.random().toString(36).substr(2, 8);
+}
+function Xt(e, t) {
+  return {
+    usr: e.state,
+    key: e.key,
+    idx: t
+  };
+}
+function ct(e, t, n, a) {
+  return n === void 0 && (n = null), H({
+    pathname: typeof e == "string" ? e : e.pathname,
+    search: "",
+    hash: ""
+  }, typeof t == "string" ? He(t) : t, {
+    state: n,
+    // TODO: This could be cleaned up.  push/replace should probably just take
+    // full Locations now and avoid the need to run through this flow at all
+    // But that's a pretty big refactor to the current test suite so going to
+    // keep as is for the time being and just let any incoming keys take precedence
+    key: t && t.key || a || _r()
+  });
+}
+function ht(e) {
+  let {
+    pathname: t = "/",
+    search: n = "",
+    hash: a = ""
+  } = e;
+  return n && n !== "?" && (t += n.charAt(0) === "?" ? n : "?" + n), a && a !== "#" && (t += a.charAt(0) === "#" ? a : "#" + a), t;
+}
+function He(e) {
+  let t = {};
+  if (e) {
+    let n = e.indexOf("#");
+    n >= 0 && (t.hash = e.substr(n), e = e.substr(0, n));
+    let a = e.indexOf("?");
+    a >= 0 && (t.search = e.substr(a), e = e.substr(0, a)), e && (t.pathname = e);
+  }
+  return t;
+}
+function Tr(e, t, n, a) {
+  a === void 0 && (a = {});
+  let {
+    window: o = document.defaultView,
+    v5Compat: h = !1
+  } = a, f = o.history, d = G.Pop, c = null, w = R();
+  w == null && (w = 0, f.replaceState(H({}, f.state, {
+    idx: w
+  }), ""));
+  function R() {
+    return (f.state || {
+      idx: null
+    }).idx;
+  }
+  function g() {
+    d = G.Pop;
+    let A = R(), k = A == null ? null : A - w;
+    w = A, c && c({
+      action: d,
+      location: M.location,
+      delta: k
+    });
+  }
+  function E(A, k) {
+    d = G.Push;
+    let T = ct(M.location, A, k);
+    w = R() + 1;
+    let pe = Xt(T, w), Q = M.createHref(T);
+    try {
+      f.pushState(pe, "", Q);
+    } catch (re) {
+      if (re instanceof DOMException && re.name === "DataCloneError")
+        throw re;
+      o.location.assign(Q);
+    }
+    h && c && c({
+      action: d,
+      location: M.location,
+      delta: 1
+    });
+  }
+  function I(A, k) {
+    d = G.Replace;
+    let T = ct(M.location, A, k);
+    w = R();
+    let pe = Xt(T, w), Q = M.createHref(T);
+    f.replaceState(pe, "", Q), h && c && c({
+      action: d,
+      location: M.location,
+      delta: 0
+    });
+  }
+  function j(A) {
+    let k = o.location.origin !== "null" ? o.location.origin : o.location.href, T = typeof A == "string" ? A : ht(A);
+    return T = T.replace(/ $/, "%20"), N(k, "No window.location.(origin|href) available to create URL for href: " + T), new URL(T, k);
+  }
+  let M = {
+    get action() {
+      return d;
+    },
+    get location() {
+      return e(o, f);
+    },
+    listen(A) {
+      if (c)
+        throw new Error("A history only accepts one active listener");
+      return o.addEventListener(Gt, g), c = A, () => {
+        o.removeEventListener(Gt, g), c = null;
+      };
+    },
+    createHref(A) {
+      return t(o, A);
+    },
+    createURL: j,
+    encodeLocation(A) {
+      let k = j(A);
+      return {
+        pathname: k.pathname,
+        search: k.search,
+        hash: k.hash
+      };
+    },
+    push: E,
+    replace: I,
+    go(A) {
+      return f.go(A);
+    }
+  };
+  return M;
+}
+var z;
+(function(e) {
+  e.data = "data", e.deferred = "deferred", e.redirect = "redirect", e.error = "error";
+})(z || (z = {}));
+const Mr = /* @__PURE__ */ new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
+function Cr(e) {
+  return e.index === !0;
+}
+function dt(e, t, n, a) {
+  return n === void 0 && (n = []), a === void 0 && (a = {}), e.map((o, h) => {
+    let f = [...n, String(h)], d = typeof o.id == "string" ? o.id : f.join("-");
+    if (N(o.index !== !0 || !o.children, "Cannot specify children on an index route"), N(!a[d], 'Found a route id collision on id "' + d + `".  Route id's must be globally unique within Data Router usages`), Cr(o)) {
+      let c = H({}, o, t(o), {
+        id: d
+      });
+      return a[d] = c, c;
+    } else {
+      let c = H({}, o, t(o), {
+        id: d,
+        children: void 0
+      });
+      return a[d] = c, o.children && (c.children = dt(o.children, t, f, a)), c;
+    }
+  });
+}
+function Xe(e, t, n) {
+  return n === void 0 && (n = "/"), _t(e, t, n, !1);
+}
+function _t(e, t, n, a) {
+  let o = typeof t == "string" ? He(t) : t, h = Tt(o.pathname || "/", n);
+  if (h == null)
+    return null;
+  let f = hr(e);
+  jr(f);
+  let d = null;
+  for (let c = 0; d == null && c < f.length; ++c) {
+    let w = $r(h);
+    d = zr(f[c], w, a);
+  }
+  return d;
+}
+function Lr(e, t) {
+  let {
+    route: n,
+    pathname: a,
+    params: o
+  } = e;
+  return {
+    id: n.id,
+    pathname: a,
+    params: o,
+    data: t[n.id],
+    handle: n.handle
+  };
+}
+function hr(e, t, n, a) {
+  t === void 0 && (t = []), n === void 0 && (n = []), a === void 0 && (a = "");
+  let o = (h, f, d) => {
+    let c = {
+      relativePath: d === void 0 ? h.path || "" : d,
+      caseSensitive: h.caseSensitive === !0,
+      childrenIndex: f,
+      route: h
+    };
+    c.relativePath.startsWith("/") && (N(c.relativePath.startsWith(a), 'Absolute route path "' + c.relativePath + '" nested under path ' + ('"' + a + '" is not valid. An absolute child route path ') + "must start with the combined path of all its parent routes."), c.relativePath = c.relativePath.slice(a.length));
+    let w = ut([a, c.relativePath]), R = n.concat(c);
+    h.children && h.children.length > 0 && (N(
+      // Our types know better, but runtime JS may not!
+      // @ts-expect-error
+      h.index !== !0,
+      "Index routes must not have child routes. Please remove " + ('all child routes from route path "' + w + '".')
+    ), hr(h.children, t, R, w)), !(h.path == null && !h.index) && t.push({
+      path: w,
+      score: Nr(w, h.index),
+      routesMeta: R
+    });
+  };
+  return e.forEach((h, f) => {
+    var d;
+    if (h.path === "" || !((d = h.path) != null && d.includes("?")))
+      o(h, f);
+    else
+      for (let c of pr(h.path))
+        o(h, f, c);
+  }), t;
+}
+function pr(e) {
+  let t = e.split("/");
+  if (t.length === 0) return [];
+  let [n, ...a] = t, o = n.endsWith("?"), h = n.replace(/\?$/, "");
+  if (a.length === 0)
+    return o ? [h, ""] : [h];
+  let f = pr(a.join("/")), d = [];
+  return d.push(...f.map((c) => c === "" ? h : [h, c].join("/"))), o && d.push(...f), d.map((c) => e.startsWith("/") && c === "" ? "/" : c);
+}
+function jr(e) {
+  e.sort((t, n) => t.score !== n.score ? n.score - t.score : Wr(t.routesMeta.map((a) => a.childrenIndex), n.routesMeta.map((a) => a.childrenIndex)));
+}
+const Or = /^:[\w-]+$/, Fr = 3, Ar = 2, Ur = 1, Ir = 10, kr = -2, qt = (e) => e === "*";
+function Nr(e, t) {
+  let n = e.split("/"), a = n.length;
+  return n.some(qt) && (a += kr), t && (a += Ar), n.filter((o) => !qt(o)).reduce((o, h) => o + (Or.test(h) ? Fr : h === "" ? Ur : Ir), a);
+}
+function Wr(e, t) {
+  return e.length === t.length && e.slice(0, -1).every((a, o) => a === t[o]) ? (
+    // If two routes are siblings, we should try to match the earlier sibling
+    // first. This allows people to have fine-grained control over the matching
+    // behavior by simply putting routes with identical paths in the order they
+    // want them tried.
+    e[e.length - 1] - t[t.length - 1]
+  ) : (
+    // Otherwise, it doesn't really make sense to rank non-siblings by index,
+    // so they sort equally.
+    0
+  );
+}
+function zr(e, t, n) {
+  n === void 0 && (n = !1);
+  let {
+    routesMeta: a
+  } = e, o = {}, h = "/", f = [];
+  for (let d = 0; d < a.length; ++d) {
+    let c = a[d], w = d === a.length - 1, R = h === "/" ? t : t.slice(h.length) || "/", g = Qt({
+      path: c.relativePath,
+      caseSensitive: c.caseSensitive,
+      end: w
+    }, R), E = c.route;
+    if (!g && w && n && !a[a.length - 1].route.index && (g = Qt({
+      path: c.relativePath,
+      caseSensitive: c.caseSensitive,
+      end: !1
+    }, R)), !g)
+      return null;
+    Object.assign(o, g.params), f.push({
+      // TODO: Can this as be avoided?
+      params: o,
+      pathname: ut([h, g.pathname]),
+      pathnameBase: Jr(ut([h, g.pathnameBase])),
+      route: E
+    }), g.pathnameBase !== "/" && (h = ut([h, g.pathnameBase]));
+  }
+  return f;
+}
+function Qt(e, t) {
+  typeof e == "string" && (e = {
+    path: e,
+    caseSensitive: !1,
+    end: !0
+  });
+  let [n, a] = Br(e.path, e.caseSensitive, e.end), o = t.match(n);
+  if (!o) return null;
+  let h = o[0], f = h.replace(/(.)\/+$/, "$1"), d = o.slice(1);
+  return {
+    params: a.reduce((w, R, g) => {
+      let {
+        paramName: E,
+        isOptional: I
+      } = R;
+      if (E === "*") {
+        let M = d[g] || "";
+        f = h.slice(0, h.length - M.length).replace(/(.)\/+$/, "$1");
+      }
+      const j = d[g];
+      return I && !j ? w[E] = void 0 : w[E] = (j || "").replace(/%2F/g, "/"), w;
+    }, {}),
+    pathname: h,
+    pathnameBase: f,
+    pattern: e
+  };
+}
+function Br(e, t, n) {
+  t === void 0 && (t = !1), n === void 0 && (n = !0), qe(e === "*" || !e.endsWith("*") || e.endsWith("/*"), 'Route path "' + e + '" will be treated as if it were ' + ('"' + e.replace(/\*$/, "/*") + '" because the `*` character must ') + "always follow a `/` in the pattern. To get rid of this warning, " + ('please change the route path to "' + e.replace(/\*$/, "/*") + '".'));
+  let a = [], o = "^" + e.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(/\/:([\w-]+)(\?)?/g, (f, d, c) => (a.push({
+    paramName: d,
+    isOptional: c != null
+  }), c ? "/?([^\\/]+)?" : "/([^\\/]+)"));
+  return e.endsWith("*") ? (a.push({
+    paramName: "*"
+  }), o += e === "*" || e === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$") : n ? o += "\\/*$" : e !== "" && e !== "/" && (o += "(?:(?=\\/|$))"), [new RegExp(o, t ? void 0 : "i"), a];
+}
+function $r(e) {
+  try {
+    return e.split("/").map((t) => decodeURIComponent(t).replace(/\//g, "%2F")).join("/");
+  } catch (t) {
+    return qe(!1, 'The URL path "' + e + '" could not be decoded because it is is a malformed URL segment. This is probably due to a bad percent ' + ("encoding (" + t + ").")), e;
+  }
+}
+function Tt(e, t) {
+  if (t === "/") return e;
+  if (!e.toLowerCase().startsWith(t.toLowerCase()))
+    return null;
+  let n = t.endsWith("/") ? t.length - 1 : t.length, a = e.charAt(n);
+  return a && a !== "/" ? null : e.slice(n) || "/";
+}
+function Hr(e, t) {
+  t === void 0 && (t = "/");
+  let {
+    pathname: n,
+    search: a = "",
+    hash: o = ""
+  } = typeof e == "string" ? He(e) : e;
+  return {
+    pathname: n ? n.startsWith("/") ? n : Yr(n, t) : t,
+    search: Gr(a),
+    hash: Xr(o)
+  };
+}
+function Yr(e, t) {
+  let n = t.replace(/\/+$/, "").split("/");
+  return e.split("/").forEach((o) => {
+    o === ".." ? n.length > 1 && n.pop() : o !== "." && n.push(o);
+  }), n.length > 1 ? n.join("/") : "/";
+}
+function It(e, t, n, a) {
+  return "Cannot include a '" + e + "' character in a manually specified " + ("`to." + t + "` field [" + JSON.stringify(a) + "].  Please separate it out to the ") + ("`to." + n + "` field. Alternatively you may provide the full path as ") + 'a string in <Link to="..."> and the router will parse it for you.';
+}
+function mr(e) {
+  return e.filter((t, n) => n === 0 || t.route.path && t.route.path.length > 0);
+}
+function Vr(e, t) {
+  let n = mr(e);
+  return t ? n.map((a, o) => o === n.length - 1 ? a.pathname : a.pathnameBase) : n.map((a) => a.pathnameBase);
+}
+function Kr(e, t, n, a) {
+  a === void 0 && (a = !1);
+  let o;
+  typeof e == "string" ? o = He(e) : (o = H({}, e), N(!o.pathname || !o.pathname.includes("?"), It("?", "pathname", "search", o)), N(!o.pathname || !o.pathname.includes("#"), It("#", "pathname", "hash", o)), N(!o.search || !o.search.includes("#"), It("#", "search", "hash", o)));
+  let h = e === "" || o.pathname === "", f = h ? "/" : o.pathname, d;
+  if (f == null)
+    d = n;
+  else {
+    let g = t.length - 1;
+    if (!a && f.startsWith("..")) {
+      let E = f.split("/");
+      for (; E[0] === ".."; )
+        E.shift(), g -= 1;
+      o.pathname = E.join("/");
+    }
+    d = g >= 0 ? t[g] : "/";
+  }
+  let c = Hr(o, d), w = f && f !== "/" && f.endsWith("/"), R = (h || f === ".") && n.endsWith("/");
+  return !c.pathname.endsWith("/") && (w || R) && (c.pathname += "/"), c;
+}
+const ut = (e) => e.join("/").replace(/\/\/+/g, "/"), Jr = (e) => e.replace(/\/+$/, "").replace(/^\/*/, "/"), Gr = (e) => !e || e === "?" ? "" : e.startsWith("?") ? e : "?" + e, Xr = (e) => !e || e === "#" ? "" : e.startsWith("#") ? e : "#" + e;
+class vr {
+  constructor(t, n, a, o) {
+    o === void 0 && (o = !1), this.status = t, this.statusText = n || "", this.internal = o, a instanceof Error ? (this.data = a.toString(), this.error = a) : this.data = a;
+  }
+}
+function $t(e) {
+  return e != null && typeof e.status == "number" && typeof e.statusText == "string" && typeof e.internal == "boolean" && "data" in e;
+}
+const gr = ["post", "put", "patch", "delete"], qr = new Set(gr), Qr = ["get", ...gr], Zr = new Set(Qr), ea = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]), ta = /* @__PURE__ */ new Set([307, 308]), kt = {
+  state: "idle",
+  location: void 0,
+  formMethod: void 0,
+  formAction: void 0,
+  formEncType: void 0,
+  formData: void 0,
+  json: void 0,
+  text: void 0
+}, ra = {
+  state: "idle",
+  data: void 0,
+  formMethod: void 0,
+  formAction: void 0,
+  formEncType: void 0,
+  formData: void 0,
+  json: void 0,
+  text: void 0
+}, ot = {
+  state: "unblocked",
+  proceed: void 0,
+  reset: void 0,
+  location: void 0
+}, Ht = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i, aa = (e) => ({
+  hasErrorBoundary: !!e.hasErrorBoundary
+}), yr = "remix-router-transitions";
+function xa(e) {
+  const t = e.window ? e.window : typeof window < "u" ? window : void 0, n = typeof t < "u" && typeof t.document < "u" && typeof t.document.createElement < "u", a = !n;
+  N(e.routes.length > 0, "You must provide a non-empty routes array to createRouter");
+  let o;
+  if (e.mapRouteProperties)
+    o = e.mapRouteProperties;
+  else if (e.detectErrorBoundary) {
+    let i = e.detectErrorBoundary;
+    o = (l) => ({
+      hasErrorBoundary: i(l)
+    });
+  } else
+    o = aa;
+  let h = {}, f = dt(e.routes, o, void 0, h), d, c = e.basename || "/", w = e.unstable_dataStrategy || sa, R = e.unstable_patchRoutesOnMiss, g = H({
+    v7_fetcherPersist: !1,
+    v7_normalizeFormMethod: !1,
+    v7_partialHydration: !1,
+    v7_prependBasename: !1,
+    v7_relativeSplatPath: !1,
+    unstable_skipActionErrorRevalidation: !1
+  }, e.future), E = null, I = /* @__PURE__ */ new Set(), j = null, M = null, A = null, k = e.hydrationData != null, T = Xe(f, e.history.location, c), pe = null;
+  if (T == null && !R) {
+    let i = te(404, {
+      pathname: e.history.location.pathname
+    }), {
+      matches: l,
+      route: u
+    } = sr(f);
+    T = l, pe = {
+      [u.id]: i
+    };
+  }
+  T && R && Ke(T, f, e.history.location.pathname).active && (T = null);
+  let Q;
+  if (!T)
+    Q = !1, T = [];
+  else if (T.some((i) => i.route.lazy))
+    Q = !1;
+  else if (!T.some((i) => i.route.loader))
+    Q = !0;
+  else if (g.v7_partialHydration) {
+    let i = e.hydrationData ? e.hydrationData.loaderData : null, l = e.hydrationData ? e.hydrationData.errors : null, u = (p) => p.route.loader ? typeof p.route.loader == "function" && p.route.loader.hydrate === !0 ? !1 : i && i[p.route.id] !== void 0 || l && l[p.route.id] !== void 0 : !0;
+    if (l) {
+      let p = T.findIndex((S) => l[S.route.id] !== void 0);
+      Q = T.slice(0, p + 1).every(u);
+    } else
+      Q = T.every(u);
+  } else
+    Q = e.hydrationData != null;
+  let re, m = {
+    historyAction: e.history.action,
+    location: e.history.location,
+    matches: T,
+    initialized: Q,
+    navigation: kt,
+    // Don't restore on initial updateState() if we were SSR'd
+    restoreScrollPosition: e.hydrationData != null ? !1 : null,
+    preventScrollReset: !1,
+    revalidation: "idle",
+    loaderData: e.hydrationData && e.hydrationData.loaderData || {},
+    actionData: e.hydrationData && e.hydrationData.actionData || null,
+    errors: e.hydrationData && e.hydrationData.errors || pe,
+    fetchers: /* @__PURE__ */ new Map(),
+    blockers: /* @__PURE__ */ new Map()
+  }, ae = G.Pop, ue = !1, U, Z = !1, J = /* @__PURE__ */ new Map(), ie = null, V = !1, B = !1, fe = [], Ue = [], $ = /* @__PURE__ */ new Map(), Ie = 0, _e = -1, Ee = /* @__PURE__ */ new Map(), ce = /* @__PURE__ */ new Set(), Se = /* @__PURE__ */ new Map(), Te = /* @__PURE__ */ new Map(), me = /* @__PURE__ */ new Set(), De = /* @__PURE__ */ new Map(), ve = /* @__PURE__ */ new Map(), Qe = /* @__PURE__ */ new Map(), Me = !1;
+  function Ze() {
+    if (E = e.history.listen((i) => {
+      let {
+        action: l,
+        location: u,
+        delta: p
+      } = i;
+      if (Me) {
+        Me = !1;
+        return;
+      }
+      qe(ve.size === 0 || p != null, "You are trying to use a blocker on a POP navigation to a location that was not created by @remix-run/router. This will fail silently in production. This can happen if you are navigating outside the router via `window.history.pushState`/`window.location.hash` instead of using router navigation APIs.  This can also happen if you are using createHashRouter and the user manually changes the URL.");
+      let S = at({
+        currentLocation: m.location,
+        nextLocation: u,
+        historyAction: l
+      });
+      if (S && p != null) {
+        Me = !0, e.history.go(p * -1), Oe(S, {
+          state: "blocked",
+          location: u,
+          proceed() {
+            Oe(S, {
+              state: "proceeding",
+              proceed: void 0,
+              reset: void 0,
+              location: u
+            }), e.history.go(p);
+          },
+          reset() {
+            let x = new Map(m.blockers);
+            x.set(S, ot), X({
+              blockers: x
+            });
+          }
+        });
+        return;
+      }
+      return oe(l, u);
+    }), n) {
+      wa(t, J);
+      let i = () => Ea(t, J);
+      t.addEventListener("pagehide", i), ie = () => t.removeEventListener("pagehide", i);
+    }
+    return m.initialized || oe(G.Pop, m.location, {
+      initialHydration: !0
+    }), re;
+  }
+  function Ye() {
+    E && E(), ie && ie(), I.clear(), U && U.abort(), m.fetchers.forEach((i, l) => je(l)), m.blockers.forEach((i, l) => Rt(l));
+  }
+  function Mt(i) {
+    return I.add(i), () => I.delete(i);
+  }
+  function X(i, l) {
+    l === void 0 && (l = {}), m = H({}, m, i);
+    let u = [], p = [];
+    g.v7_fetcherPersist && m.fetchers.forEach((S, x) => {
+      S.state === "idle" && (me.has(x) ? p.push(x) : u.push(x));
+    }), [...I].forEach((S) => S(m, {
+      deletedFetchers: p,
+      unstable_viewTransitionOpts: l.viewTransitionOpts,
+      unstable_flushSync: l.flushSync === !0
+    })), g.v7_fetcherPersist && (u.forEach((S) => m.fetchers.delete(S)), p.forEach((S) => je(S)));
+  }
+  function Ce(i, l, u) {
+    var p, S;
+    let {
+      flushSync: x
+    } = u === void 0 ? {} : u, r = m.actionData != null && m.navigation.formMethod != null && ge(m.navigation.formMethod) && m.navigation.state === "loading" && ((p = i.state) == null ? void 0 : p._isRedirect) !== !0, s;
+    l.actionData ? Object.keys(l.actionData).length > 0 ? s = l.actionData : s = null : r ? s = m.actionData : s = null;
+    let v = l.loaderData ? or(m.loaderData, l.loaderData, l.matches || [], l.errors) : m.loaderData, y = m.blockers;
+    y.size > 0 && (y = new Map(y), y.forEach((D, P) => y.set(P, ot)));
+    let b = ue === !0 || m.navigation.formMethod != null && ge(m.navigation.formMethod) && ((S = i.state) == null ? void 0 : S._isRedirect) !== !0;
+    d && (f = d, d = void 0), V || ae === G.Pop || (ae === G.Push ? e.history.push(i, i.state) : ae === G.Replace && e.history.replace(i, i.state));
+    let _;
+    if (ae === G.Pop) {
+      let D = J.get(m.location.pathname);
+      D && D.has(i.pathname) ? _ = {
+        currentLocation: m.location,
+        nextLocation: i
+      } : J.has(i.pathname) && (_ = {
+        currentLocation: i,
+        nextLocation: m.location
+      });
+    } else if (Z) {
+      let D = J.get(m.location.pathname);
+      D ? D.add(i.pathname) : (D = /* @__PURE__ */ new Set([i.pathname]), J.set(m.location.pathname, D)), _ = {
+        currentLocation: m.location,
+        nextLocation: i
+      };
+    }
+    X(H({}, l, {
+      actionData: s,
+      loaderData: v,
+      historyAction: ae,
+      location: i,
+      initialized: !0,
+      navigation: kt,
+      revalidation: "idle",
+      restoreScrollPosition: Dt(i, l.matches || m.matches),
+      preventScrollReset: b,
+      blockers: y
+    }), {
+      viewTransitionOpts: _,
+      flushSync: x === !0
+    }), ae = G.Pop, ue = !1, Z = !1, V = !1, B = !1, fe = [], Ue = [];
+  }
+  async function pt(i, l) {
+    if (typeof i == "number") {
+      e.history.go(i);
+      return;
+    }
+    let u = zt(m.location, m.matches, c, g.v7_prependBasename, i, g.v7_relativeSplatPath, l == null ? void 0 : l.fromRouteId, l == null ? void 0 : l.relative), {
+      path: p,
+      submission: S,
+      error: x
+    } = Zt(g.v7_normalizeFormMethod, !1, u, l), r = m.location, s = ct(m.location, p, l && l.state);
+    s = H({}, s, e.history.encodeLocation(s));
+    let v = l && l.replace != null ? l.replace : void 0, y = G.Push;
+    v === !0 ? y = G.Replace : v === !1 || S != null && ge(S.formMethod) && S.formAction === m.location.pathname + m.location.search && (y = G.Replace);
+    let b = l && "preventScrollReset" in l ? l.preventScrollReset === !0 : void 0, _ = (l && l.unstable_flushSync) === !0, D = at({
+      currentLocation: r,
+      nextLocation: s,
+      historyAction: y
+    });
+    if (D) {
+      Oe(D, {
+        state: "blocked",
+        location: s,
+        proceed() {
+          Oe(D, {
+            state: "proceeding",
+            proceed: void 0,
+            reset: void 0,
+            location: s
+          }), pt(i, l);
+        },
+        reset() {
+          let P = new Map(m.blockers);
+          P.set(D, ot), X({
+            blockers: P
+          });
+        }
+      });
+      return;
+    }
+    return await oe(y, s, {
+      submission: S,
+      // Send through the formData serialization error if we have one so we can
+      // render at the right error boundary after we match routes
+      pendingError: x,
+      preventScrollReset: b,
+      replace: l && l.replace,
+      enableViewTransition: l && l.unstable_viewTransition,
+      flushSync: _
+    });
+  }
+  function Ve() {
+    if (Pe(), X({
+      revalidation: "loading"
+    }), m.navigation.state !== "submitting") {
+      if (m.navigation.state === "idle") {
+        oe(m.historyAction, m.location, {
+          startUninterruptedRevalidation: !0
+        });
+        return;
+      }
+      oe(ae || m.historyAction, m.navigation.location, {
+        overrideNavigation: m.navigation
+      });
+    }
+  }
+  async function oe(i, l, u) {
+    U && U.abort(), U = null, ae = i, V = (u && u.startUninterruptedRevalidation) === !0, St(m.location, m.matches), ue = (u && u.preventScrollReset) === !0, Z = (u && u.enableViewTransition) === !0;
+    let p = d || f, S = u && u.overrideNavigation, x = Xe(p, l, c), r = (u && u.flushSync) === !0, s = Ke(x, p, l.pathname);
+    if (s.active && s.matches && (x = s.matches), !x) {
+      let {
+        error: C,
+        notFoundMatches: O,
+        route: L
+      } = Re(l.pathname);
+      Ce(l, {
+        matches: O,
+        loaderData: {},
+        errors: {
+          [L.id]: C
+        }
+      }, {
+        flushSync: r
+      });
+      return;
+    }
+    if (m.initialized && !B && pa(m.location, l) && !(u && u.submission && ge(u.submission.formMethod))) {
+      Ce(l, {
+        matches: x
+      }, {
+        flushSync: r
+      });
+      return;
+    }
+    U = new AbortController();
+    let v = Ge(e.history, l, U.signal, u && u.submission), y;
+    if (u && u.pendingError)
+      y = [ft(x).route.id, {
+        type: z.error,
+        error: u.pendingError
+      }];
+    else if (u && u.submission && ge(u.submission.formMethod)) {
+      let C = await mt(v, l, u.submission, x, s.active, {
+        replace: u.replace,
+        flushSync: r
+      });
+      if (C.shortCircuited)
+        return;
+      if (C.pendingActionResult) {
+        let [O, L] = C.pendingActionResult;
+        if (se(L) && $t(L.error) && L.error.status === 404) {
+          U = null, Ce(l, {
+            matches: C.matches,
+            loaderData: {},
+            errors: {
+              [O]: L.error
+            }
+          });
+          return;
+        }
+      }
+      x = C.matches || x, y = C.pendingActionResult, S = Nt(l, u.submission), r = !1, s.active = !1, v = Ge(e.history, v.url, v.signal);
+    }
+    let {
+      shortCircuited: b,
+      matches: _,
+      loaderData: D,
+      errors: P
+    } = await vt(v, l, x, s.active, S, u && u.submission, u && u.fetcherSubmission, u && u.replace, u && u.initialHydration === !0, r, y);
+    b || (U = null, Ce(l, H({
+      matches: _ || x
+    }, lr(y), {
+      loaderData: D,
+      errors: P
+    })));
+  }
+  async function mt(i, l, u, p, S, x) {
+    x === void 0 && (x = {}), Pe();
+    let r = ba(l, u);
+    if (X({
+      navigation: r
+    }, {
+      flushSync: x.flushSync === !0
+    }), S) {
+      let y = await ze(p, l.pathname, i.signal);
+      if (y.type === "aborted")
+        return {
+          shortCircuited: !0
+        };
+      if (y.type === "error") {
+        let {
+          error: b,
+          notFoundMatches: _,
+          route: D
+        } = Fe(l.pathname, y);
+        return {
+          matches: _,
+          pendingActionResult: [D.id, {
+            type: z.error,
+            error: b
+          }]
+        };
+      } else if (y.matches)
+        p = y.matches;
+      else {
+        let {
+          notFoundMatches: b,
+          error: _,
+          route: D
+        } = Re(l.pathname);
+        return {
+          matches: b,
+          pendingActionResult: [D.id, {
+            type: z.error,
+            error: _
+          }]
+        };
+      }
+    }
+    let s, v = st(p, l);
+    if (!v.route.action && !v.route.lazy)
+      s = {
+        type: z.error,
+        error: te(405, {
+          method: i.method,
+          pathname: l.pathname,
+          routeId: v.route.id
+        })
+      };
+    else if (s = (await Le("action", i, [v], p))[0], i.signal.aborted)
+      return {
+        shortCircuited: !0
+      };
+    if ($e(s)) {
+      let y;
+      return x && x.replace != null ? y = x.replace : y = ar(s.response.headers.get("Location"), new URL(i.url), c) === m.location.pathname + m.location.search, await Ne(i, s, {
+        submission: u,
+        replace: y
+      }), {
+        shortCircuited: !0
+      };
+    }
+    if (Be(s))
+      throw te(400, {
+        type: "defer-action"
+      });
+    if (se(s)) {
+      let y = ft(p, v.route.id);
+      return (x && x.replace) !== !0 && (ae = G.Push), {
+        matches: p,
+        pendingActionResult: [y.route.id, s]
+      };
+    }
+    return {
+      matches: p,
+      pendingActionResult: [v.route.id, s]
+    };
+  }
+  async function vt(i, l, u, p, S, x, r, s, v, y, b) {
+    let _ = S || Nt(l, x), D = x || r || cr(_), P = !V && (!g.v7_partialHydration || !v);
+    if (p) {
+      if (P) {
+        let Y = ke(b);
+        X(H({
+          navigation: _
+        }, Y !== void 0 ? {
+          actionData: Y
+        } : {}), {
+          flushSync: y
+        });
+      }
+      let F = await ze(u, l.pathname, i.signal);
+      if (F.type === "aborted")
+        return {
+          shortCircuited: !0
+        };
+      if (F.type === "error") {
+        let {
+          error: Y,
+          notFoundMatches: le,
+          route: W
+        } = Fe(l.pathname, F);
+        return {
+          matches: le,
+          loaderData: {},
+          errors: {
+            [W.id]: Y
+          }
+        };
+      } else if (F.matches)
+        u = F.matches;
+      else {
+        let {
+          error: Y,
+          notFoundMatches: le,
+          route: W
+        } = Re(l.pathname);
+        return {
+          matches: le,
+          loaderData: {},
+          errors: {
+            [W.id]: Y
+          }
+        };
+      }
+    }
+    let C = d || f, [O, L] = er(e.history, m, u, D, l, g.v7_partialHydration && v === !0, g.unstable_skipActionErrorRevalidation, B, fe, Ue, me, Se, ce, C, c, b);
+    if (We((F) => !(u && u.some((Y) => Y.route.id === F)) || O && O.some((Y) => Y.route.id === F)), _e = ++Ie, O.length === 0 && L.length === 0) {
+      let F = yt();
+      return Ce(l, H({
+        matches: u,
+        loaderData: {},
+        // Commit pending error if we're short circuiting
+        errors: b && se(b[1]) ? {
+          [b[0]]: b[1].error
+        } : null
+      }, lr(b), F ? {
+        fetchers: new Map(m.fetchers)
+      } : {}), {
+        flushSync: y
+      }), {
+        shortCircuited: !0
+      };
+    }
+    if (P) {
+      let F = {};
+      if (!p) {
+        F.navigation = _;
+        let Y = ke(b);
+        Y !== void 0 && (F.actionData = Y);
+      }
+      L.length > 0 && (F.fetchers = Ct(L)), X(F, {
+        flushSync: y
+      });
+    }
+    L.forEach((F) => {
+      $.has(F.key) && be(F.key), F.controller && $.set(F.key, F.controller);
+    });
+    let q = () => L.forEach((F) => be(F.key));
+    U && U.signal.addEventListener("abort", q);
+    let {
+      loaderResults: ee,
+      fetcherResults: ne
+    } = await tt(m.matches, u, O, L, i);
+    if (i.signal.aborted)
+      return {
+        shortCircuited: !0
+      };
+    U && U.signal.removeEventListener("abort", q), L.forEach((F) => $.delete(F.key));
+    let K = ur([...ee, ...ne]);
+    if (K) {
+      if (K.idx >= O.length) {
+        let F = L[K.idx - O.length].key;
+        ce.add(F);
+      }
+      return await Ne(i, K.result, {
+        replace: s
+      }), {
+        shortCircuited: !0
+      };
+    }
+    let {
+      loaderData: we,
+      errors: he
+    } = ir(m, u, O, ee, b, L, ne, De);
+    De.forEach((F, Y) => {
+      F.subscribe((le) => {
+        (le || F.done) && De.delete(Y);
+      });
+    }), g.v7_partialHydration && v && m.errors && Object.entries(m.errors).filter((F) => {
+      let [Y] = F;
+      return !O.some((le) => le.route.id === Y);
+    }).forEach((F) => {
+      let [Y, le] = F;
+      he = Object.assign(he || {}, {
+        [Y]: le
+      });
+    });
+    let Je = yt(), Pt = bt(_e), xt = Je || Pt || L.length > 0;
+    return H({
+      matches: u,
+      loaderData: we,
+      errors: he
+    }, xt ? {
+      fetchers: new Map(m.fetchers)
+    } : {});
+  }
+  function ke(i) {
+    if (i && !se(i[1]))
+      return {
+        [i[0]]: i[1].data
+      };
+    if (m.actionData)
+      return Object.keys(m.actionData).length === 0 ? null : m.actionData;
+  }
+  function Ct(i) {
+    return i.forEach((l) => {
+      let u = m.fetchers.get(l.key), p = lt(void 0, u ? u.data : void 0);
+      m.fetchers.set(l.key, p);
+    }), new Map(m.fetchers);
+  }
+  function Lt(i, l, u, p) {
+    if (a)
+      throw new Error("router.fetch() was called during the server render, but it shouldn't be. You are likely calling a useFetcher() method in the body of your component. Try moving it to a useEffect or a callback.");
+    $.has(i) && be(i);
+    let S = (p && p.unstable_flushSync) === !0, x = d || f, r = zt(m.location, m.matches, c, g.v7_prependBasename, u, g.v7_relativeSplatPath, l, p == null ? void 0 : p.relative), s = Xe(x, r, c), v = Ke(s, x, r);
+    if (v.active && v.matches && (s = v.matches), !s) {
+      de(i, l, te(404, {
+        pathname: r
+      }), {
+        flushSync: S
+      });
+      return;
+    }
+    let {
+      path: y,
+      submission: b,
+      error: _
+    } = Zt(g.v7_normalizeFormMethod, !0, r, p);
+    if (_) {
+      de(i, l, _, {
+        flushSync: S
+      });
+      return;
+    }
+    let D = st(s, y);
+    if (ue = (p && p.preventScrollReset) === !0, b && ge(b.formMethod)) {
+      et(i, l, y, D, s, v.active, S, b);
+      return;
+    }
+    Se.set(i, {
+      routeId: l,
+      path: y
+    }), jt(i, l, y, D, s, v.active, S, b);
+  }
+  async function et(i, l, u, p, S, x, r, s) {
+    Pe(), Se.delete(i);
+    function v(W) {
+      if (!W.route.action && !W.route.lazy) {
+        let xe = te(405, {
+          method: s.formMethod,
+          pathname: u,
+          routeId: l
+        });
+        return de(i, l, xe, {
+          flushSync: r
+        }), !0;
+      }
+      return !1;
+    }
+    if (!x && v(p))
+      return;
+    let y = m.fetchers.get(i);
+    ye(i, Ra(s, y), {
+      flushSync: r
+    });
+    let b = new AbortController(), _ = Ge(e.history, u, b.signal, s);
+    if (x) {
+      let W = await ze(S, u, _.signal);
+      if (W.type === "aborted")
+        return;
+      if (W.type === "error") {
+        let {
+          error: xe
+        } = Fe(u, W);
+        de(i, l, xe, {
+          flushSync: r
+        });
+        return;
+      } else if (W.matches) {
+        if (S = W.matches, p = st(S, u), v(p))
+          return;
+      } else {
+        de(i, l, te(404, {
+          pathname: u
+        }), {
+          flushSync: r
+        });
+        return;
+      }
+    }
+    $.set(i, b);
+    let D = Ie, C = (await Le("action", _, [p], S))[0];
+    if (_.signal.aborted) {
+      $.get(i) === b && $.delete(i);
+      return;
+    }
+    if (g.v7_fetcherPersist && me.has(i)) {
+      if ($e(C) || se(C)) {
+        ye(i, Ae(void 0));
+        return;
+      }
+    } else {
+      if ($e(C))
+        if ($.delete(i), _e > D) {
+          ye(i, Ae(void 0));
+          return;
+        } else
+          return ce.add(i), ye(i, lt(s)), Ne(_, C, {
+            fetcherSubmission: s
+          });
+      if (se(C)) {
+        de(i, l, C.error);
+        return;
+      }
+    }
+    if (Be(C))
+      throw te(400, {
+        type: "defer-action"
+      });
+    let O = m.navigation.location || m.location, L = Ge(e.history, O, b.signal), q = d || f, ee = m.navigation.state !== "idle" ? Xe(q, m.navigation.location, c) : m.matches;
+    N(ee, "Didn't find any matches after fetcher action");
+    let ne = ++Ie;
+    Ee.set(i, ne);
+    let K = lt(s, C.data);
+    m.fetchers.set(i, K);
+    let [we, he] = er(e.history, m, ee, s, O, !1, g.unstable_skipActionErrorRevalidation, B, fe, Ue, me, Se, ce, q, c, [p.route.id, C]);
+    he.filter((W) => W.key !== i).forEach((W) => {
+      let xe = W.key, Vt = m.fetchers.get(xe), Dr = lt(void 0, Vt ? Vt.data : void 0);
+      m.fetchers.set(xe, Dr), $.has(xe) && be(xe), W.controller && $.set(xe, W.controller);
+    }), X({
+      fetchers: new Map(m.fetchers)
+    });
+    let Je = () => he.forEach((W) => be(W.key));
+    b.signal.addEventListener("abort", Je);
+    let {
+      loaderResults: Pt,
+      fetcherResults: xt
+    } = await tt(m.matches, ee, we, he, L);
+    if (b.signal.aborted)
+      return;
+    b.signal.removeEventListener("abort", Je), Ee.delete(i), $.delete(i), he.forEach((W) => $.delete(W.key));
+    let F = ur([...Pt, ...xt]);
+    if (F) {
+      if (F.idx >= we.length) {
+        let W = he[F.idx - we.length].key;
+        ce.add(W);
+      }
+      return Ne(L, F.result);
+    }
+    let {
+      loaderData: Y,
+      errors: le
+    } = ir(m, m.matches, we, Pt, void 0, he, xt, De);
+    if (m.fetchers.has(i)) {
+      let W = Ae(C.data);
+      m.fetchers.set(i, W);
+    }
+    bt(ne), m.navigation.state === "loading" && ne > _e ? (N(ae, "Expected pending action"), U && U.abort(), Ce(m.navigation.location, {
+      matches: ee,
+      loaderData: Y,
+      errors: le,
+      fetchers: new Map(m.fetchers)
+    })) : (X({
+      errors: le,
+      loaderData: or(m.loaderData, Y, ee, le),
+      fetchers: new Map(m.fetchers)
+    }), B = !1);
+  }
+  async function jt(i, l, u, p, S, x, r, s) {
+    let v = m.fetchers.get(i);
+    ye(i, lt(s, v ? v.data : void 0), {
+      flushSync: r
+    });
+    let y = new AbortController(), b = Ge(e.history, u, y.signal);
+    if (x) {
+      let C = await ze(S, u, b.signal);
+      if (C.type === "aborted")
+        return;
+      if (C.type === "error") {
+        let {
+          error: O
+        } = Fe(u, C);
+        de(i, l, O, {
+          flushSync: r
+        });
+        return;
+      } else if (C.matches)
+        S = C.matches, p = st(S, u);
+      else {
+        de(i, l, te(404, {
+          pathname: u
+        }), {
+          flushSync: r
+        });
+        return;
+      }
+    }
+    $.set(i, y);
+    let _ = Ie, P = (await Le("loader", b, [p], S))[0];
+    if (Be(P) && (P = await Sr(P, b.signal, !0) || P), $.get(i) === y && $.delete(i), !b.signal.aborted) {
+      if (me.has(i)) {
+        ye(i, Ae(void 0));
+        return;
+      }
+      if ($e(P))
+        if (_e > _) {
+          ye(i, Ae(void 0));
+          return;
+        } else {
+          ce.add(i), await Ne(b, P);
+          return;
+        }
+      if (se(P)) {
+        de(i, l, P.error);
+        return;
+      }
+      N(!Be(P), "Unhandled fetcher deferred data"), ye(i, Ae(P.data));
+    }
+  }
+  async function Ne(i, l, u) {
+    let {
+      submission: p,
+      fetcherSubmission: S,
+      replace: x
+    } = u === void 0 ? {} : u;
+    l.response.headers.has("X-Remix-Revalidate") && (B = !0);
+    let r = l.response.headers.get("Location");
+    N(r, "Expected a Location header on the redirect Response"), r = ar(r, new URL(i.url), c);
+    let s = ct(m.location, r, {
+      _isRedirect: !0
+    });
+    if (n) {
+      let P = !1;
+      if (l.response.headers.has("X-Remix-Reload-Document"))
+        P = !0;
+      else if (Ht.test(r)) {
+        const C = e.history.createURL(r);
+        P = // Hard reload if it's an absolute URL to a new origin
+        C.origin !== t.location.origin || // Hard reload if it's an absolute URL that does not match our basename
+        Tt(C.pathname, c) == null;
+      }
+      if (P) {
+        x ? t.location.replace(r) : t.location.assign(r);
+        return;
+      }
+    }
+    U = null;
+    let v = x === !0 ? G.Replace : G.Push, {
+      formMethod: y,
+      formAction: b,
+      formEncType: _
+    } = m.navigation;
+    !p && !S && y && b && _ && (p = cr(m.navigation));
+    let D = p || S;
+    if (ta.has(l.response.status) && D && ge(D.formMethod))
+      await oe(v, s, {
+        submission: H({}, D, {
+          formAction: r
+        }),
+        // Preserve this flag across redirects
+        preventScrollReset: ue
+      });
+    else {
+      let P = Nt(s, p);
+      await oe(v, s, {
+        overrideNavigation: P,
+        // Send fetcher submissions through for shouldRevalidate
+        fetcherSubmission: S,
+        // Preserve this flag across redirects
+        preventScrollReset: ue
+      });
+    }
+  }
+  async function Le(i, l, u, p) {
+    try {
+      let S = await ua(w, i, l, u, p, h, o);
+      return await Promise.all(S.map((x, r) => {
+        if (va(x)) {
+          let s = x.result;
+          return {
+            type: z.redirect,
+            response: da(s, l, u[r].route.id, p, c, g.v7_relativeSplatPath)
+          };
+        }
+        return ca(x);
+      }));
+    } catch (S) {
+      return u.map(() => ({
+        type: z.error,
+        error: S
+      }));
+    }
+  }
+  async function tt(i, l, u, p, S) {
+    let [x, ...r] = await Promise.all([u.length ? Le("loader", S, u, l) : [], ...p.map((s) => {
+      if (s.matches && s.match && s.controller) {
+        let v = Ge(e.history, s.path, s.controller.signal);
+        return Le("loader", v, [s.match], s.matches).then((y) => y[0]);
+      } else
+        return Promise.resolve({
+          type: z.error,
+          error: te(404, {
+            pathname: s.path
+          })
+        });
+    })]);
+    return await Promise.all([fr(i, u, x, x.map(() => S.signal), !1, m.loaderData), fr(i, p.map((s) => s.match), r, p.map((s) => s.controller ? s.controller.signal : null), !0)]), {
+      loaderResults: x,
+      fetcherResults: r
+    };
+  }
+  function Pe() {
+    B = !0, fe.push(...We()), Se.forEach((i, l) => {
+      $.has(l) && (Ue.push(l), be(l));
+    });
+  }
+  function ye(i, l, u) {
+    u === void 0 && (u = {}), m.fetchers.set(i, l), X({
+      fetchers: new Map(m.fetchers)
+    }, {
+      flushSync: (u && u.flushSync) === !0
+    });
+  }
+  function de(i, l, u, p) {
+    p === void 0 && (p = {});
+    let S = ft(m.matches, l);
+    je(i), X({
+      errors: {
+        [S.route.id]: u
+      },
+      fetchers: new Map(m.fetchers)
+    }, {
+      flushSync: (p && p.flushSync) === !0
+    });
+  }
+  function rt(i) {
+    return g.v7_fetcherPersist && (Te.set(i, (Te.get(i) || 0) + 1), me.has(i) && me.delete(i)), m.fetchers.get(i) || ra;
+  }
+  function je(i) {
+    let l = m.fetchers.get(i);
+    $.has(i) && !(l && l.state === "loading" && Ee.has(i)) && be(i), Se.delete(i), Ee.delete(i), ce.delete(i), me.delete(i), m.fetchers.delete(i);
+  }
+  function Ot(i) {
+    if (g.v7_fetcherPersist) {
+      let l = (Te.get(i) || 0) - 1;
+      l <= 0 ? (Te.delete(i), me.add(i)) : Te.set(i, l);
+    } else
+      je(i);
+    X({
+      fetchers: new Map(m.fetchers)
+    });
+  }
+  function be(i) {
+    let l = $.get(i);
+    N(l, "Expected fetch controller: " + i), l.abort(), $.delete(i);
+  }
+  function gt(i) {
+    for (let l of i) {
+      let u = rt(l), p = Ae(u.data);
+      m.fetchers.set(l, p);
+    }
+  }
+  function yt() {
+    let i = [], l = !1;
+    for (let u of ce) {
+      let p = m.fetchers.get(u);
+      N(p, "Expected fetcher: " + u), p.state === "loading" && (ce.delete(u), i.push(u), l = !0);
+    }
+    return gt(i), l;
+  }
+  function bt(i) {
+    let l = [];
+    for (let [u, p] of Ee)
+      if (p < i) {
+        let S = m.fetchers.get(u);
+        N(S, "Expected fetcher: " + u), S.state === "loading" && (be(u), Ee.delete(u), l.push(u));
+      }
+    return gt(l), l.length > 0;
+  }
+  function Ft(i, l) {
+    let u = m.blockers.get(i) || ot;
+    return ve.get(i) !== l && ve.set(i, l), u;
+  }
+  function Rt(i) {
+    m.blockers.delete(i), ve.delete(i);
+  }
+  function Oe(i, l) {
+    let u = m.blockers.get(i) || ot;
+    N(u.state === "unblocked" && l.state === "blocked" || u.state === "blocked" && l.state === "blocked" || u.state === "blocked" && l.state === "proceeding" || u.state === "blocked" && l.state === "unblocked" || u.state === "proceeding" && l.state === "unblocked", "Invalid blocker state transition: " + u.state + " -> " + l.state);
+    let p = new Map(m.blockers);
+    p.set(i, l), X({
+      blockers: p
+    });
+  }
+  function at(i) {
+    let {
+      currentLocation: l,
+      nextLocation: u,
+      historyAction: p
+    } = i;
+    if (ve.size === 0)
+      return;
+    ve.size > 1 && qe(!1, "A router only supports one blocker at a time");
+    let S = Array.from(ve.entries()), [x, r] = S[S.length - 1], s = m.blockers.get(x);
+    if (!(s && s.state === "proceeding") && r({
+      currentLocation: l,
+      nextLocation: u,
+      historyAction: p
+    }))
+      return x;
+  }
+  function Re(i) {
+    let l = te(404, {
+      pathname: i
+    }), u = d || f, {
+      matches: p,
+      route: S
+    } = sr(u);
+    return We(), {
+      notFoundMatches: p,
+      route: S,
+      error: l
+    };
+  }
+  function Fe(i, l) {
+    let u = l.partialMatches, p = u[u.length - 1].route, S = te(400, {
+      type: "route-discovery",
+      routeId: p.id,
+      pathname: i,
+      message: l.error != null && "message" in l.error ? l.error : String(l.error)
+    });
+    return {
+      notFoundMatches: u,
+      route: p,
+      error: S
+    };
+  }
+  function We(i) {
+    let l = [];
+    return De.forEach((u, p) => {
+      (!i || i(p)) && (u.cancel(), l.push(p), De.delete(p));
+    }), l;
+  }
+  function wt(i, l, u) {
+    if (j = i, A = l, M = u || null, !k && m.navigation === kt) {
+      k = !0;
+      let p = Dt(m.location, m.matches);
+      p != null && X({
+        restoreScrollPosition: p
+      });
+    }
+    return () => {
+      j = null, A = null, M = null;
+    };
+  }
+  function Et(i, l) {
+    return M && M(i, l.map((p) => Lr(p, m.loaderData))) || i.key;
+  }
+  function St(i, l) {
+    if (j && A) {
+      let u = Et(i, l);
+      j[u] = A();
+    }
+  }
+  function Dt(i, l) {
+    if (j) {
+      let u = Et(i, l), p = j[u];
+      if (typeof p == "number")
+        return p;
+    }
+    return null;
+  }
+  function Ke(i, l, u) {
+    if (R)
+      if (i) {
+        let p = i[i.length - 1].route;
+        if (p.path && (p.path === "*" || p.path.endsWith("/*")))
+          return {
+            active: !0,
+            matches: _t(l, u, c, !0)
+          };
+      } else
+        return {
+          active: !0,
+          matches: _t(l, u, c, !0) || []
+        };
+    return {
+      active: !1,
+      matches: null
+    };
+  }
+  async function ze(i, l, u) {
+    let p = i, S = p.length > 0 ? p[p.length - 1].route : null;
+    for (; ; ) {
+      let x = d == null, r = d || f;
+      try {
+        await la(R, l, p, r, h, o, Qe, u);
+      } catch (b) {
+        return {
+          type: "error",
+          error: b,
+          partialMatches: p
+        };
+      } finally {
+        x && (f = [...f]);
+      }
+      if (u.aborted)
+        return {
+          type: "aborted"
+        };
+      let s = Xe(r, l, c), v = !1;
+      if (s) {
+        let b = s[s.length - 1].route;
+        if (b.index)
+          return {
+            type: "success",
+            matches: s
+          };
+        if (b.path && b.path.length > 0)
+          if (b.path === "*")
+            v = !0;
+          else
+            return {
+              type: "success",
+              matches: s
+            };
+      }
+      let y = _t(r, l, c, !0);
+      if (!y || p.map((b) => b.route.id).join("-") === y.map((b) => b.route.id).join("-"))
+        return {
+          type: "success",
+          matches: v ? s : null
+        };
+      if (p = y, S = p[p.length - 1].route, S.path === "*")
+        return {
+          type: "success",
+          matches: p
+        };
+    }
+  }
+  function At(i) {
+    h = {}, d = dt(i, o, void 0, h);
+  }
+  function Ut(i, l) {
+    let u = d == null;
+    Rr(i, l, d || f, h, o), u && (f = [...f], X({}));
+  }
+  return re = {
+    get basename() {
+      return c;
+    },
+    get future() {
+      return g;
+    },
+    get state() {
+      return m;
+    },
+    get routes() {
+      return f;
+    },
+    get window() {
+      return t;
+    },
+    initialize: Ze,
+    subscribe: Mt,
+    enableScrollRestoration: wt,
+    navigate: pt,
+    fetch: Lt,
+    revalidate: Ve,
+    // Passthrough to history-aware createHref used by useHref so we get proper
+    // hash-aware URLs in DOM paths
+    createHref: (i) => e.history.createHref(i),
+    encodeLocation: (i) => e.history.encodeLocation(i),
+    getFetcher: rt,
+    deleteFetcher: Ot,
+    dispose: Ye,
+    getBlocker: Ft,
+    deleteBlocker: Rt,
+    patchRoutes: Ut,
+    _internalFetchControllers: $,
+    _internalActiveDeferreds: De,
+    // TODO: Remove setRoutes, it's temporary to avoid dealing with
+    // updating the tree while validating the update algorithm.
+    _internalSetRoutes: At
+  }, re;
+}
+function na(e) {
+  return e != null && ("formData" in e && e.formData != null || "body" in e && e.body !== void 0);
+}
+function zt(e, t, n, a, o, h, f, d) {
+  let c, w;
+  if (f) {
+    c = [];
+    for (let g of t)
+      if (c.push(g), g.route.id === f) {
+        w = g;
+        break;
+      }
+  } else
+    c = t, w = t[t.length - 1];
+  let R = Kr(o || ".", Vr(c, h), Tt(e.pathname, n) || e.pathname, d === "path");
+  return o == null && (R.search = e.search, R.hash = e.hash), (o == null || o === "" || o === ".") && w && w.route.index && !Yt(R.search) && (R.search = R.search ? R.search.replace(/^\?/, "?index&") : "?index"), a && n !== "/" && (R.pathname = R.pathname === "/" ? n : ut([n, R.pathname])), ht(R);
+}
+function Zt(e, t, n, a) {
+  if (!a || !na(a))
+    return {
+      path: n
+    };
+  if (a.formMethod && !ya(a.formMethod))
+    return {
+      path: n,
+      error: te(405, {
+        method: a.formMethod
+      })
+    };
+  let o = () => ({
+    path: n,
+    error: te(400, {
+      type: "invalid-body"
+    })
+  }), h = a.formMethod || "get", f = e ? h.toUpperCase() : h.toLowerCase(), d = wr(n);
+  if (a.body !== void 0) {
+    if (a.formEncType === "text/plain") {
+      if (!ge(f))
+        return o();
+      let E = typeof a.body == "string" ? a.body : a.body instanceof FormData || a.body instanceof URLSearchParams ? (
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
+        Array.from(a.body.entries()).reduce((I, j) => {
+          let [M, A] = j;
+          return "" + I + M + "=" + A + `
+`;
+        }, "")
+      ) : String(a.body);
+      return {
+        path: n,
+        submission: {
+          formMethod: f,
+          formAction: d,
+          formEncType: a.formEncType,
+          formData: void 0,
+          json: void 0,
+          text: E
+        }
+      };
+    } else if (a.formEncType === "application/json") {
+      if (!ge(f))
+        return o();
+      try {
+        let E = typeof a.body == "string" ? JSON.parse(a.body) : a.body;
+        return {
+          path: n,
+          submission: {
+            formMethod: f,
+            formAction: d,
+            formEncType: a.formEncType,
+            formData: void 0,
+            json: E,
+            text: void 0
+          }
+        };
+      } catch {
+        return o();
+      }
+    }
+  }
+  N(typeof FormData == "function", "FormData is not available in this environment");
+  let c, w;
+  if (a.formData)
+    c = Bt(a.formData), w = a.formData;
+  else if (a.body instanceof FormData)
+    c = Bt(a.body), w = a.body;
+  else if (a.body instanceof URLSearchParams)
+    c = a.body, w = nr(c);
+  else if (a.body == null)
+    c = new URLSearchParams(), w = new FormData();
+  else
+    try {
+      c = new URLSearchParams(a.body), w = nr(c);
+    } catch {
+      return o();
+    }
+  let R = {
+    formMethod: f,
+    formAction: d,
+    formEncType: a && a.formEncType || "application/x-www-form-urlencoded",
+    formData: w,
+    json: void 0,
+    text: void 0
+  };
+  if (ge(R.formMethod))
+    return {
+      path: n,
+      submission: R
+    };
+  let g = He(n);
+  return t && g.search && Yt(g.search) && c.append("index", ""), g.search = "?" + c, {
+    path: ht(g),
+    submission: R
+  };
+}
+function ia(e, t) {
+  let n = e;
+  if (t) {
+    let a = e.findIndex((o) => o.route.id === t);
+    a >= 0 && (n = e.slice(0, a));
+  }
+  return n;
+}
+function er(e, t, n, a, o, h, f, d, c, w, R, g, E, I, j, M) {
+  let A = M ? se(M[1]) ? M[1].error : M[1].data : void 0, k = e.createURL(t.location), T = e.createURL(o), pe = M && se(M[1]) ? M[0] : void 0, Q = pe ? ia(n, pe) : n, re = M ? M[1].statusCode : void 0, m = f && re && re >= 400, ae = Q.filter((U, Z) => {
+    let {
+      route: J
+    } = U;
+    if (J.lazy)
+      return !0;
+    if (J.loader == null)
+      return !1;
+    if (h)
+      return typeof J.loader != "function" || J.loader.hydrate ? !0 : t.loaderData[J.id] === void 0 && // Don't re-run if the loader ran and threw an error
+      (!t.errors || t.errors[J.id] === void 0);
+    if (oa(t.loaderData, t.matches[Z], U) || c.some((B) => B === U.route.id))
+      return !0;
+    let ie = t.matches[Z], V = U;
+    return tr(U, H({
+      currentUrl: k,
+      currentParams: ie.params,
+      nextUrl: T,
+      nextParams: V.params
+    }, a, {
+      actionResult: A,
+      unstable_actionStatus: re,
+      defaultShouldRevalidate: m ? !1 : (
+        // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+        d || k.pathname + k.search === T.pathname + T.search || // Search params affect all loaders
+        k.search !== T.search || br(ie, V)
+      )
+    }));
+  }), ue = [];
+  return g.forEach((U, Z) => {
+    if (h || !n.some((fe) => fe.route.id === U.routeId) || R.has(Z))
+      return;
+    let J = Xe(I, U.path, j);
+    if (!J) {
+      ue.push({
+        key: Z,
+        routeId: U.routeId,
+        path: U.path,
+        matches: null,
+        match: null,
+        controller: null
+      });
+      return;
+    }
+    let ie = t.fetchers.get(Z), V = st(J, U.path), B = !1;
+    E.has(Z) ? B = !1 : w.includes(Z) ? B = !0 : ie && ie.state !== "idle" && ie.data === void 0 ? B = d : B = tr(V, H({
+      currentUrl: k,
+      currentParams: t.matches[t.matches.length - 1].params,
+      nextUrl: T,
+      nextParams: n[n.length - 1].params
+    }, a, {
+      actionResult: A,
+      unstable_actionStatus: re,
+      defaultShouldRevalidate: m ? !1 : d
+    })), B && ue.push({
+      key: Z,
+      routeId: U.routeId,
+      path: U.path,
+      matches: J,
+      match: V,
+      controller: new AbortController()
+    });
+  }), [ae, ue];
+}
+function oa(e, t, n) {
+  let a = (
+    // [a] -> [a, b]
+    !t || // [a, b] -> [a, c]
+    n.route.id !== t.route.id
+  ), o = e[n.route.id] === void 0;
+  return a || o;
+}
+function br(e, t) {
+  let n = e.route.path;
+  return (
+    // param change for this match, /users/123 -> /users/456
+    e.pathname !== t.pathname || // splat param changed, which is not present in match.path
+    // e.g. /files/images/avatar.jpg -> files/finances.xls
+    n != null && n.endsWith("*") && e.params["*"] !== t.params["*"]
+  );
+}
+function tr(e, t) {
+  if (e.route.shouldRevalidate) {
+    let n = e.route.shouldRevalidate(t);
+    if (typeof n == "boolean")
+      return n;
+  }
+  return t.defaultShouldRevalidate;
+}
+async function la(e, t, n, a, o, h, f, d) {
+  let c = [t, ...n.map((w) => w.route.id)].join("-");
+  try {
+    let w = f.get(c);
+    w || (w = e({
+      path: t,
+      matches: n,
+      patch: (R, g) => {
+        d.aborted || Rr(R, g, a, o, h);
+      }
+    }), f.set(c, w)), w && ma(w) && await w;
+  } finally {
+    f.delete(c);
+  }
+}
+function Rr(e, t, n, a, o) {
+  if (e) {
+    var h;
+    let f = a[e];
+    N(f, "No route found to patch children into: routeId = " + e);
+    let d = dt(t, o, [e, "patch", String(((h = f.children) == null ? void 0 : h.length) || "0")], a);
+    f.children ? f.children.push(...d) : f.children = d;
+  } else {
+    let f = dt(t, o, ["patch", String(n.length || "0")], a);
+    n.push(...f);
+  }
+}
+async function rr(e, t, n) {
+  if (!e.lazy)
+    return;
+  let a = await e.lazy();
+  if (!e.lazy)
+    return;
+  let o = n[e.id];
+  N(o, "No route found in manifest");
+  let h = {};
+  for (let f in a) {
+    let c = o[f] !== void 0 && // This property isn't static since it should always be updated based
+    // on the route updates
+    f !== "hasErrorBoundary";
+    qe(!c, 'Route "' + o.id + '" has a static property "' + f + '" defined but its lazy function is also returning a value for this property. ' + ('The lazy route property "' + f + '" will be ignored.')), !c && !Mr.has(f) && (h[f] = a[f]);
+  }
+  Object.assign(o, h), Object.assign(o, H({}, t(o), {
+    lazy: void 0
+  }));
+}
+function sa(e) {
+  return Promise.all(e.matches.map((t) => t.resolve()));
+}
+async function ua(e, t, n, a, o, h, f, d) {
+  let c = a.reduce((g, E) => g.add(E.route.id), /* @__PURE__ */ new Set()), w = /* @__PURE__ */ new Set(), R = await e({
+    matches: o.map((g) => {
+      let E = c.has(g.route.id);
+      return H({}, g, {
+        shouldLoad: E,
+        resolve: (j) => (w.add(g.route.id), E ? fa(t, n, g, h, f, j, d) : Promise.resolve({
+          type: z.data,
+          result: void 0
+        }))
+      });
+    }),
+    request: n,
+    params: o[0].params,
+    context: d
+  });
+  return o.forEach((g) => N(w.has(g.route.id), '`match.resolve()` was not called for route id "' + g.route.id + '". You must call `match.resolve()` on every match passed to `dataStrategy` to ensure all routes are properly loaded.')), R.filter((g, E) => c.has(o[E].route.id));
+}
+async function fa(e, t, n, a, o, h, f) {
+  let d, c, w = (R) => {
+    let g, E = new Promise((M, A) => g = A);
+    c = () => g(), t.signal.addEventListener("abort", c);
+    let I = (M) => typeof R != "function" ? Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ('"' + e + '" [routeId: ' + n.route.id + "]"))) : R({
+      request: t,
+      params: n.params,
+      context: f
+    }, ...M !== void 0 ? [M] : []), j;
+    return h ? j = h((M) => I(M)) : j = (async () => {
+      try {
+        return {
+          type: "data",
+          result: await I()
+        };
+      } catch (M) {
+        return {
+          type: "error",
+          result: M
+        };
+      }
+    })(), Promise.race([j, E]);
+  };
+  try {
+    let R = n.route[e];
+    if (n.route.lazy)
+      if (R) {
+        let g, [E] = await Promise.all([
+          // If the handler throws, don't let it immediately bubble out,
+          // since we need to let the lazy() execution finish so we know if this
+          // route has a boundary that can handle the error
+          w(R).catch((I) => {
+            g = I;
+          }),
+          rr(n.route, o, a)
+        ]);
+        if (g !== void 0)
+          throw g;
+        d = E;
+      } else if (await rr(n.route, o, a), R = n.route[e], R)
+        d = await w(R);
+      else if (e === "action") {
+        let g = new URL(t.url), E = g.pathname + g.search;
+        throw te(405, {
+          method: t.method,
+          pathname: E,
+          routeId: n.route.id
+        });
+      } else
+        return {
+          type: z.data,
+          result: void 0
+        };
+    else if (R)
+      d = await w(R);
+    else {
+      let g = new URL(t.url), E = g.pathname + g.search;
+      throw te(404, {
+        pathname: E
+      });
+    }
+    N(d.result !== void 0, "You defined " + (e === "action" ? "an action" : "a loader") + " for route " + ('"' + n.route.id + "\" but didn't return anything from your `" + e + "` ") + "function. Please return a value or `null`.");
+  } catch (R) {
+    return {
+      type: z.error,
+      result: R
+    };
+  } finally {
+    c && t.signal.removeEventListener("abort", c);
+  }
+  return d;
+}
+async function ca(e) {
+  let {
+    result: t,
+    type: n,
+    status: a
+  } = e;
+  if (Er(t)) {
+    let f;
+    try {
+      let d = t.headers.get("Content-Type");
+      d && /\bapplication\/json\b/.test(d) ? t.body == null ? f = null : f = await t.json() : f = await t.text();
+    } catch (d) {
+      return {
+        type: z.error,
+        error: d
+      };
+    }
+    return n === z.error ? {
+      type: z.error,
+      error: new vr(t.status, t.statusText, f),
+      statusCode: t.status,
+      headers: t.headers
+    } : {
+      type: z.data,
+      data: f,
+      statusCode: t.status,
+      headers: t.headers
+    };
+  }
+  if (n === z.error)
+    return {
+      type: z.error,
+      error: t,
+      statusCode: $t(t) ? t.status : a
+    };
+  if (ga(t)) {
+    var o, h;
+    return {
+      type: z.deferred,
+      deferredData: t,
+      statusCode: (o = t.init) == null ? void 0 : o.status,
+      headers: ((h = t.init) == null ? void 0 : h.headers) && new Headers(t.init.headers)
+    };
+  }
+  return {
+    type: z.data,
+    data: t,
+    statusCode: a
+  };
+}
+function da(e, t, n, a, o, h) {
+  let f = e.headers.get("Location");
+  if (N(f, "Redirects returned/thrown from loaders/actions must have a Location header"), !Ht.test(f)) {
+    let d = a.slice(0, a.findIndex((c) => c.route.id === n) + 1);
+    f = zt(new URL(t.url), d, o, !0, f, h), e.headers.set("Location", f);
+  }
+  return e;
+}
+function ar(e, t, n) {
+  if (Ht.test(e)) {
+    let a = e, o = a.startsWith("//") ? new URL(t.protocol + a) : new URL(a), h = Tt(o.pathname, n) != null;
+    if (o.origin === t.origin && h)
+      return o.pathname + o.search + o.hash;
+  }
+  return e;
+}
+function Ge(e, t, n, a) {
+  let o = e.createURL(wr(t)).toString(), h = {
+    signal: n
+  };
+  if (a && ge(a.formMethod)) {
+    let {
+      formMethod: f,
+      formEncType: d
+    } = a;
+    h.method = f.toUpperCase(), d === "application/json" ? (h.headers = new Headers({
+      "Content-Type": d
+    }), h.body = JSON.stringify(a.json)) : d === "text/plain" ? h.body = a.text : d === "application/x-www-form-urlencoded" && a.formData ? h.body = Bt(a.formData) : h.body = a.formData;
+  }
+  return new Request(o, h);
+}
+function Bt(e) {
+  let t = new URLSearchParams();
+  for (let [n, a] of e.entries())
+    t.append(n, typeof a == "string" ? a : a.name);
+  return t;
+}
+function nr(e) {
+  let t = new FormData();
+  for (let [n, a] of e.entries())
+    t.append(n, a);
+  return t;
+}
+function ha(e, t, n, a, o, h) {
+  let f = {}, d = null, c, w = !1, R = {}, g = a && se(a[1]) ? a[1].error : void 0;
+  return n.forEach((E, I) => {
+    let j = t[I].route.id;
+    if (N(!$e(E), "Cannot handle redirect results in processLoaderData"), se(E)) {
+      let M = E.error;
+      g !== void 0 && (M = g, g = void 0), d = d || {};
+      {
+        let A = ft(e, j);
+        d[A.route.id] == null && (d[A.route.id] = M);
+      }
+      f[j] = void 0, w || (w = !0, c = $t(E.error) ? E.error.status : 500), E.headers && (R[j] = E.headers);
+    } else
+      Be(E) ? (o.set(j, E.deferredData), f[j] = E.deferredData.data, E.statusCode != null && E.statusCode !== 200 && !w && (c = E.statusCode), E.headers && (R[j] = E.headers)) : (f[j] = E.data, E.statusCode && E.statusCode !== 200 && !w && (c = E.statusCode), E.headers && (R[j] = E.headers));
+  }), g !== void 0 && a && (d = {
+    [a[0]]: g
+  }, f[a[0]] = void 0), {
+    loaderData: f,
+    errors: d,
+    statusCode: c || 200,
+    loaderHeaders: R
+  };
+}
+function ir(e, t, n, a, o, h, f, d) {
+  let {
+    loaderData: c,
+    errors: w
+  } = ha(t, n, a, o, d);
+  for (let R = 0; R < h.length; R++) {
+    let {
+      key: g,
+      match: E,
+      controller: I
+    } = h[R];
+    N(f !== void 0 && f[R] !== void 0, "Did not find corresponding fetcher result");
+    let j = f[R];
+    if (!(I && I.signal.aborted))
+      if (se(j)) {
+        let M = ft(e.matches, E == null ? void 0 : E.route.id);
+        w && w[M.route.id] || (w = H({}, w, {
+          [M.route.id]: j.error
+        })), e.fetchers.delete(g);
+      } else if ($e(j))
+        N(!1, "Unhandled fetcher revalidation redirect");
+      else if (Be(j))
+        N(!1, "Unhandled fetcher deferred data");
+      else {
+        let M = Ae(j.data);
+        e.fetchers.set(g, M);
+      }
+  }
+  return {
+    loaderData: c,
+    errors: w
+  };
+}
+function or(e, t, n, a) {
+  let o = H({}, t);
+  for (let h of n) {
+    let f = h.route.id;
+    if (t.hasOwnProperty(f) ? t[f] !== void 0 && (o[f] = t[f]) : e[f] !== void 0 && h.route.loader && (o[f] = e[f]), a && a.hasOwnProperty(f))
+      break;
+  }
+  return o;
+}
+function lr(e) {
+  return e ? se(e[1]) ? {
+    // Clear out prior actionData on errors
+    actionData: {}
+  } : {
+    actionData: {
+      [e[0]]: e[1].data
+    }
+  } : {};
+}
+function ft(e, t) {
+  return (t ? e.slice(0, e.findIndex((a) => a.route.id === t) + 1) : [...e]).reverse().find((a) => a.route.hasErrorBoundary === !0) || e[0];
+}
+function sr(e) {
+  let t = e.length === 1 ? e[0] : e.find((n) => n.index || !n.path || n.path === "/") || {
+    id: "__shim-error-route__"
+  };
+  return {
+    matches: [{
+      params: {},
+      pathname: "",
+      pathnameBase: "",
+      route: t
+    }],
+    route: t
+  };
+}
+function te(e, t) {
+  let {
+    pathname: n,
+    routeId: a,
+    method: o,
+    type: h,
+    message: f
+  } = t === void 0 ? {} : t, d = "Unknown Server Error", c = "Unknown @remix-run/router error";
+  return e === 400 ? (d = "Bad Request", h === "route-discovery" ? c = 'Unable to match URL "' + n + '" - the `children()` function for ' + ("route `" + a + "` threw the following error:\n" + f) : o && n && a ? c = "You made a " + o + ' request to "' + n + '" but ' + ('did not provide a `loader` for route "' + a + '", ') + "so there is no way to handle the request." : h === "defer-action" ? c = "defer() is not supported in actions" : h === "invalid-body" && (c = "Unable to encode submission body")) : e === 403 ? (d = "Forbidden", c = 'Route "' + a + '" does not match URL "' + n + '"') : e === 404 ? (d = "Not Found", c = 'No route matches URL "' + n + '"') : e === 405 && (d = "Method Not Allowed", o && n && a ? c = "You made a " + o.toUpperCase() + ' request to "' + n + '" but ' + ('did not provide an `action` for route "' + a + '", ') + "so there is no way to handle the request." : o && (c = 'Invalid request method "' + o.toUpperCase() + '"')), new vr(e || 500, d, new Error(c), !0);
+}
+function ur(e) {
+  for (let t = e.length - 1; t >= 0; t--) {
+    let n = e[t];
+    if ($e(n))
+      return {
+        result: n,
+        idx: t
+      };
+  }
+}
+function wr(e) {
+  let t = typeof e == "string" ? He(e) : e;
+  return ht(H({}, t, {
+    hash: ""
+  }));
+}
+function pa(e, t) {
+  return e.pathname !== t.pathname || e.search !== t.search ? !1 : e.hash === "" ? t.hash !== "" : e.hash === t.hash ? !0 : t.hash !== "";
+}
+function ma(e) {
+  return typeof e == "object" && e != null && "then" in e;
+}
+function va(e) {
+  return Er(e.result) && ea.has(e.result.status);
+}
+function Be(e) {
+  return e.type === z.deferred;
+}
+function se(e) {
+  return e.type === z.error;
+}
+function $e(e) {
+  return (e && e.type) === z.redirect;
+}
+function ga(e) {
+  let t = e;
+  return t && typeof t == "object" && typeof t.data == "object" && typeof t.subscribe == "function" && typeof t.cancel == "function" && typeof t.resolveData == "function";
+}
+function Er(e) {
+  return e != null && typeof e.status == "number" && typeof e.statusText == "string" && typeof e.headers == "object" && typeof e.body < "u";
+}
+function ya(e) {
+  return Zr.has(e.toLowerCase());
+}
+function ge(e) {
+  return qr.has(e.toLowerCase());
+}
+async function fr(e, t, n, a, o, h) {
+  for (let f = 0; f < n.length; f++) {
+    let d = n[f], c = t[f];
+    if (!c)
+      continue;
+    let w = e.find((g) => g.route.id === c.route.id), R = w != null && !br(w, c) && (h && h[c.route.id]) !== void 0;
+    if (Be(d) && (o || R)) {
+      let g = a[f];
+      N(g, "Expected an AbortSignal for revalidating fetcher deferred result"), await Sr(d, g, o).then((E) => {
+        E && (n[f] = E || n[f]);
+      });
+    }
+  }
+}
+async function Sr(e, t, n) {
+  if (n === void 0 && (n = !1), !await e.deferredData.resolveData(t)) {
+    if (n)
+      try {
+        return {
+          type: z.data,
+          data: e.deferredData.unwrappedData
+        };
+      } catch (o) {
+        return {
+          type: z.error,
+          error: o
+        };
+      }
+    return {
+      type: z.data,
+      data: e.deferredData.data
+    };
+  }
+}
+function Yt(e) {
+  return new URLSearchParams(e).getAll("index").some((t) => t === "");
+}
+function st(e, t) {
+  let n = typeof t == "string" ? He(t).search : t.search;
+  if (e[e.length - 1].route.index && Yt(n || ""))
+    return e[e.length - 1];
+  let a = mr(e);
+  return a[a.length - 1];
+}
+function cr(e) {
+  let {
+    formMethod: t,
+    formAction: n,
+    formEncType: a,
+    text: o,
+    formData: h,
+    json: f
+  } = e;
+  if (!(!t || !n || !a)) {
+    if (o != null)
+      return {
+        formMethod: t,
+        formAction: n,
+        formEncType: a,
+        formData: void 0,
+        json: void 0,
+        text: o
+      };
+    if (h != null)
+      return {
+        formMethod: t,
+        formAction: n,
+        formEncType: a,
+        formData: h,
+        json: void 0,
+        text: void 0
+      };
+    if (f !== void 0)
+      return {
+        formMethod: t,
+        formAction: n,
+        formEncType: a,
+        formData: void 0,
+        json: f,
+        text: void 0
+      };
+  }
+}
+function Nt(e, t) {
+  return t ? {
+    state: "loading",
+    location: e,
+    formMethod: t.formMethod,
+    formAction: t.formAction,
+    formEncType: t.formEncType,
+    formData: t.formData,
+    json: t.json,
+    text: t.text
+  } : {
+    state: "loading",
+    location: e,
+    formMethod: void 0,
+    formAction: void 0,
+    formEncType: void 0,
+    formData: void 0,
+    json: void 0,
+    text: void 0
+  };
+}
+function ba(e, t) {
+  return {
+    state: "submitting",
+    location: e,
+    formMethod: t.formMethod,
+    formAction: t.formAction,
+    formEncType: t.formEncType,
+    formData: t.formData,
+    json: t.json,
+    text: t.text
+  };
+}
+function lt(e, t) {
+  return e ? {
+    state: "loading",
+    formMethod: e.formMethod,
+    formAction: e.formAction,
+    formEncType: e.formEncType,
+    formData: e.formData,
+    json: e.json,
+    text: e.text,
+    data: t
+  } : {
+    state: "loading",
+    formMethod: void 0,
+    formAction: void 0,
+    formEncType: void 0,
+    formData: void 0,
+    json: void 0,
+    text: void 0,
+    data: t
+  };
+}
+function Ra(e, t) {
+  return {
+    state: "submitting",
+    formMethod: e.formMethod,
+    formAction: e.formAction,
+    formEncType: e.formEncType,
+    formData: e.formData,
+    json: e.json,
+    text: e.text,
+    data: t ? t.data : void 0
+  };
+}
+function Ae(e) {
+  return {
+    state: "idle",
+    formMethod: void 0,
+    formAction: void 0,
+    formEncType: void 0,
+    formData: void 0,
+    json: void 0,
+    text: void 0,
+    data: e
+  };
+}
+function wa(e, t) {
+  try {
+    let n = e.sessionStorage.getItem(yr);
+    if (n) {
+      let a = JSON.parse(n);
+      for (let [o, h] of Object.entries(a || {}))
+        h && Array.isArray(h) && t.set(o, new Set(h || []));
+    }
+  } catch {
+  }
+}
+function Ea(e, t) {
+  if (t.size > 0) {
+    let n = {};
+    for (let [a, o] of t)
+      n[a] = [...o];
+    try {
+      e.sessionStorage.setItem(yr, JSON.stringify(n));
+    } catch (a) {
+      qe(!1, "Failed to save applied view transitions in sessionStorage (" + a + ").");
+    }
+  }
+}
+export {
+  G as A,
+  vr as E,
+  ut as a,
+  xa as b,
+  ht as c,
+  Pa as d,
+  Xe as e,
+  $t as f,
+  Vr as g,
+  N as i,
+  Da as j,
+  Qt as m,
+  He as p,
+  Kr as r,
+  Tt as s,
+  qe as w
+};