zudoku 0.1.1-dev.50 → 0.1.1-dev.52

package/lib/DevPortalProvider-Dn9HNUG9.js

@@ -0,0 +1,4559 @@
+var vn = (e) => {
+  throw TypeError(e);
+};
+var Nr = (e, t, r) => t.has(e) || vn("Cannot " + r);
+var E = (e, t, r) => (Nr(e, t, "read from private field"), r ? r.call(e) : t.get(e)), H = (e, t, r) => t.has(e) ? vn("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, r), I = (e, t, r, n) => (Nr(e, t, "write to private field"), n ? n.call(e, r) : t.set(e, r), r), Y = (e, t, r) => (Nr(e, t, "access private method"), r);
+import * as D from "react";
+import $n, { createContext as Ea, useContext as Ra } from "react";
+var fo = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function ho(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+function po(e) {
+  if (e.__esModule) return e;
+  var t = e.default;
+  if (typeof t == "function") {
+    var r = function n() {
+      return this instanceof n ? Reflect.construct(t, arguments, this.constructor) : t.apply(this, arguments);
+    };
+    r.prototype = t.prototype;
+  } else r = {};
+  return Object.defineProperty(r, "__esModule", { value: !0 }), Object.keys(e).forEach(function(n) {
+    var a = Object.getOwnPropertyDescriptor(e, n);
+    Object.defineProperty(r, n, a.get ? a : {
+      enumerable: !0,
+      get: function() {
+        return e[n];
+      }
+    });
+  }), r;
+}
+var Ir = { exports: {} }, Wt = {};
+/**
+ * @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 mn;
+function wa() {
+  if (mn) return Wt;
+  mn = 1;
+  var e = $n, t = Symbol.for("react.element"), r = Symbol.for("react.fragment"), n = Object.prototype.hasOwnProperty, a = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, u = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function o(f, c, y) {
+    var m, l = {}, v = null, O = null;
+    y !== void 0 && (v = "" + y), c.key !== void 0 && (v = "" + c.key), c.ref !== void 0 && (O = c.ref);
+    for (m in c) n.call(c, m) && !u.hasOwnProperty(m) && (l[m] = c[m]);
+    if (f && f.defaultProps) for (m in c = f.defaultProps, c) l[m] === void 0 && (l[m] = c[m]);
+    return { $$typeof: t, type: f, key: v, ref: O, props: l, _owner: a.current };
+  }
+  return Wt.Fragment = r, Wt.jsx = o, Wt.jsxs = o, Wt;
+}
+var zt = {};
+/**
+ * @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 yn;
+function Sa() {
+  return yn || (yn = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = $n, t = Symbol.for("react.element"), r = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), a = Symbol.for("react.strict_mode"), u = Symbol.for("react.profiler"), o = Symbol.for("react.provider"), f = Symbol.for("react.context"), c = Symbol.for("react.forward_ref"), y = Symbol.for("react.suspense"), m = Symbol.for("react.suspense_list"), l = Symbol.for("react.memo"), v = Symbol.for("react.lazy"), O = Symbol.for("react.offscreen"), F = Symbol.iterator, C = "@@iterator";
+    function L(i) {
+      if (i === null || typeof i != "object")
+        return null;
+      var h = F && i[F] || i[C];
+      return typeof h == "function" ? h : null;
+    }
+    var _ = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function P(i) {
+      {
+        for (var h = arguments.length, R = new Array(h > 1 ? h - 1 : 0), w = 1; w < h; w++)
+          R[w - 1] = arguments[w];
+        $("error", i, R);
+      }
+    }
+    function $(i, h, R) {
+      {
+        var w = _.ReactDebugCurrentFrame, S = w.getStackAddendum();
+        S !== "" && (h += "%s", R = R.concat([S]));
+        var j = R.map(function(T) {
+          return String(T);
+        });
+        j.unshift("Warning: " + h), Function.prototype.apply.call(console[i], console, j);
+      }
+    }
+    var G = !1, re = !1, b = !1, oe = !1, q = !1, W;
+    W = Symbol.for("react.module.reference");
+    function ce(i) {
+      return !!(typeof i == "string" || typeof i == "function" || i === n || i === u || q || i === a || i === y || i === m || oe || i === O || G || re || b || typeof i == "object" && i !== null && (i.$$typeof === v || i.$$typeof === l || i.$$typeof === o || i.$$typeof === f || i.$$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.
+      i.$$typeof === W || i.getModuleId !== void 0));
+    }
+    function se(i, h, R) {
+      var w = i.displayName;
+      if (w)
+        return w;
+      var S = h.displayName || h.name || "";
+      return S !== "" ? R + "(" + S + ")" : R;
+    }
+    function ge(i) {
+      return i.displayName || "Context";
+    }
+    function ne(i) {
+      if (i == null)
+        return null;
+      if (typeof i.tag == "number" && P("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof i == "function")
+        return i.displayName || i.name || null;
+      if (typeof i == "string")
+        return i;
+      switch (i) {
+        case n:
+          return "Fragment";
+        case r:
+          return "Portal";
+        case u:
+          return "Profiler";
+        case a:
+          return "StrictMode";
+        case y:
+          return "Suspense";
+        case m:
+          return "SuspenseList";
+      }
+      if (typeof i == "object")
+        switch (i.$$typeof) {
+          case f:
+            var h = i;
+            return ge(h) + ".Consumer";
+          case o:
+            var R = i;
+            return ge(R._context) + ".Provider";
+          case c:
+            return se(i, i.render, "ForwardRef");
+          case l:
+            var w = i.displayName || null;
+            return w !== null ? w : ne(i.type) || "Memo";
+          case v: {
+            var S = i, j = S._payload, T = S._init;
+            try {
+              return ne(T(j));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var X = Object.assign, we = 0, it, Z, ot, He, Ie, Se, ke;
+    function Ke() {
+    }
+    Ke.__reactDisabledLog = !0;
+    function Pe() {
+      {
+        if (we === 0) {
+          it = console.log, Z = console.info, ot = console.warn, He = console.error, Ie = console.group, Se = console.groupCollapsed, ke = console.groupEnd;
+          var i = {
+            configurable: !0,
+            enumerable: !0,
+            value: Ke,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: i,
+            log: i,
+            warn: i,
+            error: i,
+            group: i,
+            groupCollapsed: i,
+            groupEnd: i
+          });
+        }
+        we++;
+      }
+    }
+    function Be() {
+      {
+        if (we--, we === 0) {
+          var i = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: X({}, i, {
+              value: it
+            }),
+            info: X({}, i, {
+              value: Z
+            }),
+            warn: X({}, i, {
+              value: ot
+            }),
+            error: X({}, i, {
+              value: He
+            }),
+            group: X({}, i, {
+              value: Ie
+            }),
+            groupCollapsed: X({}, i, {
+              value: Se
+            }),
+            groupEnd: X({}, i, {
+              value: ke
+            })
+          });
+        }
+        we < 0 && P("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var Oe = _.ReactCurrentDispatcher, Ut;
+    function qe(i, h, R) {
+      {
+        if (Ut === void 0)
+          try {
+            throw Error();
+          } catch (S) {
+            var w = S.stack.trim().match(/\n( *(at )?)/);
+            Ut = w && w[1] || "";
+          }
+        return `
+` + Ut + i;
+      }
+    }
+    var At = !1, Et;
+    {
+      var Dr = typeof WeakMap == "function" ? WeakMap : Map;
+      Et = new Dr();
+    }
+    function le(i, h) {
+      if (!i || At)
+        return "";
+      {
+        var R = Et.get(i);
+        if (R !== void 0)
+          return R;
+      }
+      var w;
+      At = !0;
+      var S = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var j;
+      j = Oe.current, Oe.current = null, Pe();
+      try {
+        if (h) {
+          var T = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(T.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(T, []);
+            } catch (ae) {
+              w = ae;
+            }
+            Reflect.construct(i, [], T);
+          } else {
+            try {
+              T.call();
+            } catch (ae) {
+              w = ae;
+            }
+            i.call(T.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (ae) {
+            w = ae;
+          }
+          i();
+        }
+      } catch (ae) {
+        if (ae && w && typeof ae.stack == "string") {
+          for (var M = ae.stack.split(`
+`), A = w.stack.split(`
+`), B = M.length - 1, k = A.length - 1; B >= 1 && k >= 0 && M[B] !== A[k]; )
+            k--;
+          for (; B >= 1 && k >= 0; B--, k--)
+            if (M[B] !== A[k]) {
+              if (B !== 1 || k !== 1)
+                do
+                  if (B--, k--, k < 0 || M[B] !== A[k]) {
+                    var ue = `
+` + M[B].replace(" at new ", " at ");
+                    return i.displayName && ue.includes("<anonymous>") && (ue = ue.replace("<anonymous>", i.displayName)), typeof i == "function" && Et.set(i, ue), ue;
+                  }
+                while (B >= 1 && k >= 0);
+              break;
+            }
+        }
+      } finally {
+        At = !1, Oe.current = j, Be(), Error.prepareStackTrace = S;
+      }
+      var he = i ? i.displayName || i.name : "", me = he ? qe(he) : "";
+      return typeof i == "function" && Et.set(i, me), me;
+    }
+    function Ye(i, h, R) {
+      return le(i, !1);
+    }
+    function ar(i) {
+      var h = i.prototype;
+      return !!(h && h.isReactComponent);
+    }
+    function Rt(i, h, R) {
+      if (i == null)
+        return "";
+      if (typeof i == "function")
+        return le(i, ar(i));
+      if (typeof i == "string")
+        return qe(i);
+      switch (i) {
+        case y:
+          return qe("Suspense");
+        case m:
+          return qe("SuspenseList");
+      }
+      if (typeof i == "object")
+        switch (i.$$typeof) {
+          case c:
+            return Ye(i.render);
+          case l:
+            return Rt(i.type, h, R);
+          case v: {
+            var w = i, S = w._payload, j = w._init;
+            try {
+              return Rt(j(S), h, R);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var be = Object.prototype.hasOwnProperty, ir = {}, or = _.ReactDebugCurrentFrame;
+    function st(i) {
+      if (i) {
+        var h = i._owner, R = Rt(i.type, i._source, h ? h.type : null);
+        or.setExtraStackFrame(R);
+      } else
+        or.setExtraStackFrame(null);
+    }
+    function xr(i, h, R, w, S) {
+      {
+        var j = Function.call.bind(be);
+        for (var T in i)
+          if (j(i, T)) {
+            var M = void 0;
+            try {
+              if (typeof i[T] != "function") {
+                var A = Error((w || "React class") + ": " + R + " type `" + T + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof i[T] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw A.name = "Invariant Violation", A;
+              }
+              M = i[T](h, T, w, R, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (B) {
+              M = B;
+            }
+            M && !(M instanceof Error) && (st(S), P("%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).", w || "React class", R, T, typeof M), st(null)), M instanceof Error && !(M.message in ir) && (ir[M.message] = !0, st(S), P("Failed %s type: %s", R, M.message), st(null));
+          }
+      }
+    }
+    var Pr = Array.isArray;
+    function It(i) {
+      return Pr(i);
+    }
+    function Or(i) {
+      {
+        var h = typeof Symbol == "function" && Symbol.toStringTag, R = h && i[Symbol.toStringTag] || i.constructor.name || "Object";
+        return R;
+      }
+    }
+    function lt(i) {
+      try {
+        return Qe(i), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Qe(i) {
+      return "" + i;
+    }
+    function kt(i) {
+      if (lt(i))
+        return P("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Or(i)), Qe(i);
+    }
+    var Ve = _.ReactCurrentOwner, Me = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Ce, Bt, Je;
+    Je = {};
+    function _r(i) {
+      if (be.call(i, "ref")) {
+        var h = Object.getOwnPropertyDescriptor(i, "ref").get;
+        if (h && h.isReactWarning)
+          return !1;
+      }
+      return i.ref !== void 0;
+    }
+    function Ne(i) {
+      if (be.call(i, "key")) {
+        var h = Object.getOwnPropertyDescriptor(i, "key").get;
+        if (h && h.isReactWarning)
+          return !1;
+      }
+      return i.key !== void 0;
+    }
+    function sr(i, h) {
+      if (typeof i.ref == "string" && Ve.current && h && Ve.current.stateNode !== h) {
+        var R = ne(Ve.current.type);
+        Je[R] || (P('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', ne(Ve.current.type), i.ref), Je[R] = !0);
+      }
+    }
+    function lr(i, h) {
+      {
+        var R = function() {
+          Ce || (Ce = !0, P("%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)", h));
+        };
+        R.isReactWarning = !0, Object.defineProperty(i, "key", {
+          get: R,
+          configurable: !0
+        });
+      }
+    }
+    function ur(i, h) {
+      {
+        var R = function() {
+          Bt || (Bt = !0, P("%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)", h));
+        };
+        R.isReactWarning = !0, Object.defineProperty(i, "ref", {
+          get: R,
+          configurable: !0
+        });
+      }
+    }
+    var Fr = function(i, h, R, w, S, j, T) {
+      var M = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: i,
+        key: h,
+        ref: R,
+        props: T,
+        // Record the component responsible for creating this element.
+        _owner: j
+      };
+      return M._store = {}, Object.defineProperty(M._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(M, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: w
+      }), Object.defineProperty(M, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: S
+      }), Object.freeze && (Object.freeze(M.props), Object.freeze(M)), M;
+    };
+    function cr(i, h, R, w, S) {
+      {
+        var j, T = {}, M = null, A = null;
+        R !== void 0 && (kt(R), M = "" + R), Ne(h) && (kt(h.key), M = "" + h.key), _r(h) && (A = h.ref, sr(h, S));
+        for (j in h)
+          be.call(h, j) && !Me.hasOwnProperty(j) && (T[j] = h[j]);
+        if (i && i.defaultProps) {
+          var B = i.defaultProps;
+          for (j in B)
+            T[j] === void 0 && (T[j] = B[j]);
+        }
+        if (M || A) {
+          var k = typeof i == "function" ? i.displayName || i.name || "Unknown" : i;
+          M && lr(T, k), A && ur(T, k);
+        }
+        return Fr(i, M, A, S, w, Ve.current, T);
+      }
+    }
+    var Ge = _.ReactCurrentOwner, Vt = _.ReactDebugCurrentFrame;
+    function Le(i) {
+      if (i) {
+        var h = i._owner, R = Rt(i.type, i._source, h ? h.type : null);
+        Vt.setExtraStackFrame(R);
+      } else
+        Vt.setExtraStackFrame(null);
+    }
+    var Xe;
+    Xe = !1;
+    function ut(i) {
+      return typeof i == "object" && i !== null && i.$$typeof === t;
+    }
+    function dr() {
+      {
+        if (Ge.current) {
+          var i = ne(Ge.current.type);
+          if (i)
+            return `
+
+Check the render method of \`` + i + "`.";
+        }
+        return "";
+      }
+    }
+    function fr(i) {
+      return "";
+    }
+    var hr = {};
+    function pr(i) {
+      {
+        var h = dr();
+        if (!h) {
+          var R = typeof i == "string" ? i : i.displayName || i.name;
+          R && (h = `
+
+Check the top-level render call using <` + R + ">.");
+        }
+        return h;
+      }
+    }
+    function wt(i, h) {
+      {
+        if (!i._store || i._store.validated || i.key != null)
+          return;
+        i._store.validated = !0;
+        var R = pr(h);
+        if (hr[R])
+          return;
+        hr[R] = !0;
+        var w = "";
+        i && i._owner && i._owner !== Ge.current && (w = " It was passed a child from " + ne(i._owner.type) + "."), Le(i), P('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', R, w), Le(null);
+      }
+    }
+    function ct(i, h) {
+      {
+        if (typeof i != "object")
+          return;
+        if (It(i))
+          for (var R = 0; R < i.length; R++) {
+            var w = i[R];
+            ut(w) && wt(w, h);
+          }
+        else if (ut(i))
+          i._store && (i._store.validated = !0);
+        else if (i) {
+          var S = L(i);
+          if (typeof S == "function" && S !== i.entries)
+            for (var j = S.call(i), T; !(T = j.next()).done; )
+              ut(T.value) && wt(T.value, h);
+        }
+      }
+    }
+    function Tr(i) {
+      {
+        var h = i.type;
+        if (h == null || typeof h == "string")
+          return;
+        var R;
+        if (typeof h == "function")
+          R = h.propTypes;
+        else if (typeof h == "object" && (h.$$typeof === c || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        h.$$typeof === l))
+          R = h.propTypes;
+        else
+          return;
+        if (R) {
+          var w = ne(h);
+          xr(R, i.props, "prop", w, i);
+        } else if (h.PropTypes !== void 0 && !Xe) {
+          Xe = !0;
+          var S = ne(h);
+          P("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", S || "Unknown");
+        }
+        typeof h.getDefaultProps == "function" && !h.getDefaultProps.isReactClassApproved && P("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Mr(i) {
+      {
+        for (var h = Object.keys(i.props), R = 0; R < h.length; R++) {
+          var w = h[R];
+          if (w !== "children" && w !== "key") {
+            Le(i), P("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", w), Le(null);
+            break;
+          }
+        }
+        i.ref !== null && (Le(i), P("Invalid attribute `ref` supplied to `React.Fragment`."), Le(null));
+      }
+    }
+    var s = {};
+    function d(i, h, R, w, S, j) {
+      {
+        var T = ce(i);
+        if (!T) {
+          var M = "";
+          (i === void 0 || typeof i == "object" && i !== null && Object.keys(i).length === 0) && (M += " 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 A = fr();
+          A ? M += A : M += dr();
+          var B;
+          i === null ? B = "null" : It(i) ? B = "array" : i !== void 0 && i.$$typeof === t ? (B = "<" + (ne(i.type) || "Unknown") + " />", M = " Did you accidentally export a JSX literal instead of a component?") : B = typeof i, P("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", B, M);
+        }
+        var k = cr(i, h, R, S, j);
+        if (k == null)
+          return k;
+        if (T) {
+          var ue = h.children;
+          if (ue !== void 0)
+            if (w)
+              if (It(ue)) {
+                for (var he = 0; he < ue.length; he++)
+                  ct(ue[he], i);
+                Object.freeze && Object.freeze(ue);
+              } else
+                P("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
+              ct(ue, i);
+        }
+        if (be.call(h, "key")) {
+          var me = ne(i), ae = Object.keys(h).filter(function(St) {
+            return St !== "key";
+          }), je = ae.length > 0 ? "{key: someKey, " + ae.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!s[me + je]) {
+            var De = ae.length > 0 ? "{" + ae.join(": ..., ") + ": ...}" : "{}";
+            P(`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} />`, je, me, De, me), s[me + je] = !0;
+          }
+        }
+        return i === n ? Mr(k) : Tr(k), k;
+      }
+    }
+    function p(i, h, R) {
+      return d(i, h, R, !0);
+    }
+    function g(i, h, R) {
+      return d(i, h, R, !1);
+    }
+    var x = g, N = p;
+    zt.Fragment = n, zt.jsx = x, zt.jsxs = N;
+  }()), zt;
+}
+process.env.NODE_ENV === "production" ? Ir.exports = wa() : Ir.exports = Sa();
+var Ca = Ir.exports, nn = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(e) {
+    return this.listeners.add(e), this.onSubscribe(), () => {
+      this.listeners.delete(e), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, Lt = typeof window > "u" || "Deno" in globalThis;
+function kr() {
+}
+function vo(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Br(e) {
+  return typeof e == "number" && e >= 0 && e !== 1 / 0;
+}
+function Hn(e, t) {
+  return Math.max(e + (t || 0) - Date.now(), 0);
+}
+function yr(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Te(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function mo(e, t) {
+  const {
+    type: r = "all",
+    exact: n,
+    fetchStatus: a,
+    predicate: u,
+    queryKey: o,
+    stale: f
+  } = e;
+  if (o) {
+    if (n) {
+      if (t.queryHash !== Da(o, t.options))
+        return !1;
+    } else if (!an(t.queryKey, o))
+      return !1;
+  }
+  if (r !== "all") {
+    const c = t.isActive();
+    if (r === "active" && !c || r === "inactive" && c)
+      return !1;
+  }
+  return !(typeof f == "boolean" && t.isStale() !== f || a && a !== t.state.fetchStatus || u && !u(t));
+}
+function yo(e, t) {
+  const { exact: r, status: n, predicate: a, mutationKey: u } = e;
+  if (u) {
+    if (!t.options.mutationKey)
+      return !1;
+    if (r) {
+      if (Vr(t.options.mutationKey) !== Vr(u))
+        return !1;
+    } else if (!an(t.options.mutationKey, u))
+      return !1;
+  }
+  return !(n && t.state.status !== n || a && !a(t));
+}
+function Da(e, t) {
+  return ((t == null ? void 0 : t.queryKeyHashFn) || Vr)(e);
+}
+function Vr(e) {
+  return JSON.stringify(
+    e,
+    (t, r) => zr(r) ? Object.keys(r).sort().reduce((n, a) => (n[a] = r[a], n), {}) : r
+  );
+}
+function an(e, t) {
+  return e === t ? !0 : typeof e != typeof t ? !1 : e && t && typeof e == "object" && typeof t == "object" ? !Object.keys(t).some((r) => !an(e[r], t[r])) : !1;
+}
+function Kn(e, t) {
+  if (e === t)
+    return e;
+  const r = gn(e) && gn(t);
+  if (r || zr(e) && zr(t)) {
+    const n = r ? e : Object.keys(e), a = n.length, u = r ? t : Object.keys(t), o = u.length, f = r ? [] : {};
+    let c = 0;
+    for (let y = 0; y < o; y++) {
+      const m = r ? y : u[y];
+      (!r && n.includes(m) || r) && e[m] === void 0 && t[m] === void 0 ? (f[m] = void 0, c++) : (f[m] = Kn(e[m], t[m]), f[m] === e[m] && e[m] !== void 0 && c++);
+    }
+    return a === o && c === a ? e : f;
+  }
+  return t;
+}
+function Wr(e, t) {
+  if (!t || Object.keys(e).length !== Object.keys(t).length)
+    return !1;
+  for (const r in e)
+    if (e[r] !== t[r])
+      return !1;
+  return !0;
+}
+function gn(e) {
+  return Array.isArray(e) && e.length === Object.keys(e).length;
+}
+function zr(e) {
+  if (!bn(e))
+    return !1;
+  const t = e.constructor;
+  if (t === void 0)
+    return !0;
+  const r = t.prototype;
+  return !(!bn(r) || !r.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+}
+function bn(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function xa(e) {
+  return new Promise((t) => {
+    setTimeout(t, e);
+  });
+}
+function $r(e, t, r) {
+  return typeof r.structuralSharing == "function" ? r.structuralSharing(e, t) : r.structuralSharing !== !1 ? Kn(e, t) : t;
+}
+function go(e, t, r = 0) {
+  const n = [...e, t];
+  return r && n.length > r ? n.slice(1) : n;
+}
+function bo(e, t, r = 0) {
+  const n = [t, ...e];
+  return r && n.length > r ? n.slice(0, -1) : n;
+}
+var Hr = Symbol(), Pa = (e, t) => (process.env.NODE_ENV !== "production" && e.queryFn === Hr && console.error(
+  `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${e.queryHash}'`
+), !e.queryFn && (t != null && t.initialPromise) ? () => t.initialPromise : !e.queryFn || e.queryFn === Hr ? () => Promise.reject(new Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn), pt, et, Dt, kn, Oa = (kn = class extends nn {
+  constructor() {
+    super();
+    H(this, pt);
+    H(this, et);
+    H(this, Dt);
+    I(this, Dt, (t) => {
+      if (!Lt && window.addEventListener) {
+        const r = () => t();
+        return window.addEventListener("visibilitychange", r, !1), () => {
+          window.removeEventListener("visibilitychange", r);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    E(this, et) || this.setEventListener(E(this, Dt));
+  }
+  onUnsubscribe() {
+    var t;
+    this.hasListeners() || ((t = E(this, et)) == null || t.call(this), I(this, et, void 0));
+  }
+  setEventListener(t) {
+    var r;
+    I(this, Dt, t), (r = E(this, et)) == null || r.call(this), I(this, et, t((n) => {
+      typeof n == "boolean" ? this.setFocused(n) : this.onFocus();
+    }));
+  }
+  setFocused(t) {
+    E(this, pt) !== t && (I(this, pt, t), this.onFocus());
+  }
+  onFocus() {
+    const t = this.isFocused();
+    this.listeners.forEach((r) => {
+      r(t);
+    });
+  }
+  isFocused() {
+    var t;
+    return typeof E(this, pt) == "boolean" ? E(this, pt) : ((t = globalThis.document) == null ? void 0 : t.visibilityState) !== "hidden";
+  }
+}, pt = new WeakMap(), et = new WeakMap(), Dt = new WeakMap(), kn), qn = new Oa(), xt, tt, Pt, Bn, _a = (Bn = class extends nn {
+  constructor() {
+    super();
+    H(this, xt, !0);
+    H(this, tt);
+    H(this, Pt);
+    I(this, Pt, (t) => {
+      if (!Lt && window.addEventListener) {
+        const r = () => t(!0), n = () => t(!1);
+        return window.addEventListener("online", r, !1), window.addEventListener("offline", n, !1), () => {
+          window.removeEventListener("online", r), window.removeEventListener("offline", n);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    E(this, tt) || this.setEventListener(E(this, Pt));
+  }
+  onUnsubscribe() {
+    var t;
+    this.hasListeners() || ((t = E(this, tt)) == null || t.call(this), I(this, tt, void 0));
+  }
+  setEventListener(t) {
+    var r;
+    I(this, Pt, t), (r = E(this, tt)) == null || r.call(this), I(this, tt, t(this.setOnline.bind(this)));
+  }
+  setOnline(t) {
+    E(this, xt) !== t && (I(this, xt, t), this.listeners.forEach((n) => {
+      n(t);
+    }));
+  }
+  isOnline() {
+    return E(this, xt);
+  }
+}, xt = new WeakMap(), tt = new WeakMap(), Pt = new WeakMap(), Bn), Yn = new _a();
+function Fa(e) {
+  return Math.min(1e3 * 2 ** e, 3e4);
+}
+function Qn(e) {
+  return (e ?? "online") === "online" ? Yn.isOnline() : !0;
+}
+var Jn = class {
+  constructor(e) {
+    this.revert = e == null ? void 0 : e.revert, this.silent = e == null ? void 0 : e.silent;
+  }
+};
+function Lr(e) {
+  return e instanceof Jn;
+}
+function Ta(e) {
+  let t = !1, r = 0, n = !1, a, u, o;
+  const f = new Promise((_, P) => {
+    u = _, o = P;
+  }), c = (_) => {
+    var P;
+    n || (F(new Jn(_)), (P = e.abort) == null || P.call(e));
+  }, y = () => {
+    t = !0;
+  }, m = () => {
+    t = !1;
+  }, l = () => qn.isFocused() && (e.networkMode === "always" || Yn.isOnline()) && e.canRun(), v = () => Qn(e.networkMode) && e.canRun(), O = (_) => {
+    var P;
+    n || (n = !0, (P = e.onSuccess) == null || P.call(e, _), a == null || a(), u(_));
+  }, F = (_) => {
+    var P;
+    n || (n = !0, (P = e.onError) == null || P.call(e, _), a == null || a(), o(_));
+  }, C = () => new Promise((_) => {
+    var P;
+    a = ($) => {
+      (n || l()) && _($);
+    }, (P = e.onPause) == null || P.call(e);
+  }).then(() => {
+    var _;
+    a = void 0, n || (_ = e.onContinue) == null || _.call(e);
+  }), L = () => {
+    if (n)
+      return;
+    let _;
+    const P = r === 0 ? e.initialPromise : void 0;
+    try {
+      _ = P ?? e.fn();
+    } catch ($) {
+      _ = Promise.reject($);
+    }
+    Promise.resolve(_).then(O).catch(($) => {
+      var q;
+      if (n)
+        return;
+      const G = e.retry ?? (Lt ? 0 : 3), re = e.retryDelay ?? Fa, b = typeof re == "function" ? re(r, $) : re, oe = G === !0 || typeof G == "number" && r < G || typeof G == "function" && G(r, $);
+      if (t || !oe) {
+        F($);
+        return;
+      }
+      r++, (q = e.onFail) == null || q.call(e, r, $), xa(b).then(() => l() ? void 0 : C()).then(() => {
+        t ? F($) : L();
+      });
+    });
+  };
+  return {
+    promise: f,
+    cancel: c,
+    continue: () => (a == null || a(), f),
+    cancelRetry: y,
+    continueRetry: m,
+    canStart: v,
+    start: () => (v() ? L() : C().then(L), f)
+  };
+}
+function Ma() {
+  let e = [], t = 0, r = (v) => {
+    v();
+  }, n = (v) => {
+    v();
+  }, a = (v) => setTimeout(v, 0);
+  const u = (v) => {
+    a = v;
+  }, o = (v) => {
+    let O;
+    t++;
+    try {
+      O = v();
+    } finally {
+      t--, t || y();
+    }
+    return O;
+  }, f = (v) => {
+    t ? e.push(v) : a(() => {
+      r(v);
+    });
+  }, c = (v) => (...O) => {
+    f(() => {
+      v(...O);
+    });
+  }, y = () => {
+    const v = e;
+    e = [], v.length && a(() => {
+      n(() => {
+        v.forEach((O) => {
+          r(O);
+        });
+      });
+    });
+  };
+  return {
+    batch: o,
+    batchCalls: c,
+    schedule: f,
+    setNotifyFunction: (v) => {
+      r = v;
+    },
+    setBatchNotifyFunction: (v) => {
+      n = v;
+    },
+    setScheduler: u
+  };
+}
+var on = Ma(), vt, Vn, Na = (Vn = class {
+  constructor() {
+    H(this, vt);
+  }
+  destroy() {
+    this.clearGcTimeout();
+  }
+  scheduleGc() {
+    this.clearGcTimeout(), Br(this.gcTime) && I(this, vt, setTimeout(() => {
+      this.optionalRemove();
+    }, this.gcTime));
+  }
+  updateGcTime(e) {
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      e ?? (Lt ? 1 / 0 : 5 * 60 * 1e3)
+    );
+  }
+  clearGcTimeout() {
+    E(this, vt) && (clearTimeout(E(this, vt)), I(this, vt, void 0));
+  }
+}, vt = new WeakMap(), Vn), Ot, _t, xe, de, Xt, mt, _e, ze, Wn, Eo = (Wn = class extends Na {
+  constructor(t) {
+    super();
+    H(this, _e);
+    H(this, Ot);
+    H(this, _t);
+    H(this, xe);
+    H(this, de);
+    H(this, Xt);
+    H(this, mt);
+    I(this, mt, !1), I(this, Xt, t.defaultOptions), this.setOptions(t.options), this.observers = [], I(this, xe, t.cache), this.queryKey = t.queryKey, this.queryHash = t.queryHash, I(this, Ot, t.state || La(this.options)), this.state = E(this, Ot), this.scheduleGc();
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  get promise() {
+    var t;
+    return (t = E(this, de)) == null ? void 0 : t.promise;
+  }
+  setOptions(t) {
+    this.options = { ...E(this, Xt), ...t }, this.updateGcTime(this.options.gcTime);
+  }
+  optionalRemove() {
+    !this.observers.length && this.state.fetchStatus === "idle" && E(this, xe).remove(this);
+  }
+  setData(t, r) {
+    const n = $r(this.state.data, t, this.options);
+    return Y(this, _e, ze).call(this, {
+      data: n,
+      type: "success",
+      dataUpdatedAt: r == null ? void 0 : r.updatedAt,
+      manual: r == null ? void 0 : r.manual
+    }), n;
+  }
+  setState(t, r) {
+    Y(this, _e, ze).call(this, { type: "setState", state: t, setStateOptions: r });
+  }
+  cancel(t) {
+    var n, a;
+    const r = (n = E(this, de)) == null ? void 0 : n.promise;
+    return (a = E(this, de)) == null || a.cancel(t), r ? r.then(kr).catch(kr) : Promise.resolve();
+  }
+  destroy() {
+    super.destroy(), this.cancel({ silent: !0 });
+  }
+  reset() {
+    this.destroy(), this.setState(E(this, Ot));
+  }
+  isActive() {
+    return this.observers.some(
+      (t) => Te(t.options.enabled, this) !== !1
+    );
+  }
+  isDisabled() {
+    return this.getObserversCount() > 0 && !this.isActive();
+  }
+  isStale() {
+    return this.state.isInvalidated ? !0 : this.getObserversCount() > 0 ? this.observers.some(
+      (t) => t.getCurrentResult().isStale
+    ) : this.state.data === void 0;
+  }
+  isStaleByTime(t = 0) {
+    return this.state.isInvalidated || this.state.data === void 0 || !Hn(this.state.dataUpdatedAt, t);
+  }
+  onFocus() {
+    var r;
+    const t = this.observers.find((n) => n.shouldFetchOnWindowFocus());
+    t == null || t.refetch({ cancelRefetch: !1 }), (r = E(this, de)) == null || r.continue();
+  }
+  onOnline() {
+    var r;
+    const t = this.observers.find((n) => n.shouldFetchOnReconnect());
+    t == null || t.refetch({ cancelRefetch: !1 }), (r = E(this, de)) == null || r.continue();
+  }
+  addObserver(t) {
+    this.observers.includes(t) || (this.observers.push(t), this.clearGcTimeout(), E(this, xe).notify({ type: "observerAdded", query: this, observer: t }));
+  }
+  removeObserver(t) {
+    this.observers.includes(t) && (this.observers = this.observers.filter((r) => r !== t), this.observers.length || (E(this, de) && (E(this, mt) ? E(this, de).cancel({ revert: !0 }) : E(this, de).cancelRetry()), this.scheduleGc()), E(this, xe).notify({ type: "observerRemoved", query: this, observer: t }));
+  }
+  getObserversCount() {
+    return this.observers.length;
+  }
+  invalidate() {
+    this.state.isInvalidated || Y(this, _e, ze).call(this, { type: "invalidate" });
+  }
+  fetch(t, r) {
+    var c, y, m;
+    if (this.state.fetchStatus !== "idle") {
+      if (this.state.data !== void 0 && (r != null && r.cancelRefetch))
+        this.cancel({ silent: !0 });
+      else if (E(this, de))
+        return E(this, de).continueRetry(), E(this, de).promise;
+    }
+    if (t && this.setOptions(t), !this.options.queryFn) {
+      const l = this.observers.find((v) => v.options.queryFn);
+      l && this.setOptions(l.options);
+    }
+    process.env.NODE_ENV !== "production" && (Array.isArray(this.options.queryKey) || console.error(
+      "As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']"
+    ));
+    const n = new AbortController(), a = (l) => {
+      Object.defineProperty(l, "signal", {
+        enumerable: !0,
+        get: () => (I(this, mt, !0), n.signal)
+      });
+    }, u = () => {
+      const l = Pa(this.options, r), v = {
+        queryKey: this.queryKey,
+        meta: this.meta
+      };
+      return a(v), I(this, mt, !1), this.options.persister ? this.options.persister(
+        l,
+        v,
+        this
+      ) : l(v);
+    }, o = {
+      fetchOptions: r,
+      options: this.options,
+      queryKey: this.queryKey,
+      state: this.state,
+      fetchFn: u
+    };
+    a(o), (c = this.options.behavior) == null || c.onFetch(
+      o,
+      this
+    ), I(this, _t, this.state), (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((y = o.fetchOptions) == null ? void 0 : y.meta)) && Y(this, _e, ze).call(this, { type: "fetch", meta: (m = o.fetchOptions) == null ? void 0 : m.meta });
+    const f = (l) => {
+      var v, O, F, C;
+      Lr(l) && l.silent || Y(this, _e, ze).call(this, {
+        type: "error",
+        error: l
+      }), Lr(l) || ((O = (v = E(this, xe).config).onError) == null || O.call(
+        v,
+        l,
+        this
+      ), (C = (F = E(this, xe).config).onSettled) == null || C.call(
+        F,
+        this.state.data,
+        l,
+        this
+      )), this.isFetchingOptimistic || this.scheduleGc(), this.isFetchingOptimistic = !1;
+    };
+    return I(this, de, Ta({
+      initialPromise: r == null ? void 0 : r.initialPromise,
+      fn: o.fetchFn,
+      abort: n.abort.bind(n),
+      onSuccess: (l) => {
+        var v, O, F, C;
+        if (l === void 0) {
+          process.env.NODE_ENV !== "production" && console.error(
+            `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`
+          ), f(new Error(`${this.queryHash} data is undefined`));
+          return;
+        }
+        this.setData(l), (O = (v = E(this, xe).config).onSuccess) == null || O.call(v, l, this), (C = (F = E(this, xe).config).onSettled) == null || C.call(
+          F,
+          l,
+          this.state.error,
+          this
+        ), this.isFetchingOptimistic || this.scheduleGc(), this.isFetchingOptimistic = !1;
+      },
+      onError: f,
+      onFail: (l, v) => {
+        Y(this, _e, ze).call(this, { type: "failed", failureCount: l, error: v });
+      },
+      onPause: () => {
+        Y(this, _e, ze).call(this, { type: "pause" });
+      },
+      onContinue: () => {
+        Y(this, _e, ze).call(this, { type: "continue" });
+      },
+      retry: o.options.retry,
+      retryDelay: o.options.retryDelay,
+      networkMode: o.options.networkMode,
+      canRun: () => !0
+    })), E(this, de).start();
+  }
+}, Ot = new WeakMap(), _t = new WeakMap(), xe = new WeakMap(), de = new WeakMap(), Xt = new WeakMap(), mt = new WeakMap(), _e = new WeakSet(), ze = function(t) {
+  const r = (n) => {
+    switch (t.type) {
+      case "failed":
+        return {
+          ...n,
+          fetchFailureCount: t.failureCount,
+          fetchFailureReason: t.error
+        };
+      case "pause":
+        return {
+          ...n,
+          fetchStatus: "paused"
+        };
+      case "continue":
+        return {
+          ...n,
+          fetchStatus: "fetching"
+        };
+      case "fetch":
+        return {
+          ...n,
+          ...Gn(n.data, this.options),
+          fetchMeta: t.meta ?? null
+        };
+      case "success":
+        return {
+          ...n,
+          data: t.data,
+          dataUpdateCount: n.dataUpdateCount + 1,
+          dataUpdatedAt: t.dataUpdatedAt ?? Date.now(),
+          error: null,
+          isInvalidated: !1,
+          status: "success",
+          ...!t.manual && {
+            fetchStatus: "idle",
+            fetchFailureCount: 0,
+            fetchFailureReason: null
+          }
+        };
+      case "error":
+        const a = t.error;
+        return Lr(a) && a.revert && E(this, _t) ? { ...E(this, _t), fetchStatus: "idle" } : {
+          ...n,
+          error: a,
+          errorUpdateCount: n.errorUpdateCount + 1,
+          errorUpdatedAt: Date.now(),
+          fetchFailureCount: n.fetchFailureCount + 1,
+          fetchFailureReason: a,
+          fetchStatus: "idle",
+          status: "error"
+        };
+      case "invalidate":
+        return {
+          ...n,
+          isInvalidated: !0
+        };
+      case "setState":
+        return {
+          ...n,
+          ...t.state
+        };
+    }
+  };
+  this.state = r(this.state), on.batch(() => {
+    this.observers.forEach((n) => {
+      n.onQueryUpdate();
+    }), E(this, xe).notify({ query: this, type: "updated", action: t });
+  });
+}, Wn);
+function Gn(e, t) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: Qn(t.networkMode) ? "fetching" : "paused",
+    ...e === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+function La(e) {
+  const t = typeof e.initialData == "function" ? e.initialData() : e.initialData, r = t !== void 0, n = r ? typeof e.initialDataUpdatedAt == "function" ? e.initialDataUpdatedAt() : e.initialDataUpdatedAt : 0;
+  return {
+    data: t,
+    dataUpdateCount: 0,
+    dataUpdatedAt: r ? n ?? Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: !1,
+    status: r ? "success" : "pending",
+    fetchStatus: "idle"
+  };
+}
+var ye, z, Zt, pe, yt, Ft, Ue, er, Tt, Mt, gt, bt, rt, Nt, K, Kt, Kr, qr, Yr, Qr, Jr, Gr, Xr, Xn, zn, ja = (zn = class extends nn {
+  constructor(t, r) {
+    super();
+    H(this, K);
+    H(this, ye);
+    H(this, z);
+    H(this, Zt);
+    H(this, pe);
+    H(this, yt);
+    H(this, Ft);
+    H(this, Ue);
+    H(this, er);
+    H(this, Tt);
+    // This property keeps track of the last query with defined data.
+    // It will be used to pass the previous data and query to the placeholder function between renders.
+    H(this, Mt);
+    H(this, gt);
+    H(this, bt);
+    H(this, rt);
+    H(this, Nt, /* @__PURE__ */ new Set());
+    this.options = r, I(this, ye, t), I(this, Ue, null), this.bindMethods(), this.setOptions(r);
+  }
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (E(this, z).addObserver(this), En(E(this, z), this.options) ? Y(this, K, Kt).call(this) : this.updateResult(), Y(this, K, Qr).call(this));
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return Zr(
+      E(this, z),
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return Zr(
+      E(this, z),
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), Y(this, K, Jr).call(this), Y(this, K, Gr).call(this), E(this, z).removeObserver(this);
+  }
+  setOptions(t, r) {
+    const n = this.options, a = E(this, z);
+    if (this.options = E(this, ye).defaultQueryOptions(t), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof Te(this.options.enabled, E(this, z)) != "boolean")
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    Y(this, K, Xr).call(this), E(this, z).setOptions(this.options), n._defaulted && !Wr(this.options, n) && E(this, ye).getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: E(this, z),
+      observer: this
+    });
+    const u = this.hasListeners();
+    u && Rn(
+      E(this, z),
+      a,
+      this.options,
+      n
+    ) && Y(this, K, Kt).call(this), this.updateResult(r), u && (E(this, z) !== a || Te(this.options.enabled, E(this, z)) !== Te(n.enabled, E(this, z)) || yr(this.options.staleTime, E(this, z)) !== yr(n.staleTime, E(this, z))) && Y(this, K, Kr).call(this);
+    const o = Y(this, K, qr).call(this);
+    u && (E(this, z) !== a || Te(this.options.enabled, E(this, z)) !== Te(n.enabled, E(this, z)) || o !== E(this, rt)) && Y(this, K, Yr).call(this, o);
+  }
+  getOptimisticResult(t) {
+    const r = E(this, ye).getQueryCache().build(E(this, ye), t), n = this.createResult(r, t);
+    return Aa(this, n) && (I(this, pe, n), I(this, Ft, this.options), I(this, yt, E(this, z).state)), n;
+  }
+  getCurrentResult() {
+    return E(this, pe);
+  }
+  trackResult(t, r) {
+    const n = {};
+    return Object.keys(t).forEach((a) => {
+      Object.defineProperty(n, a, {
+        configurable: !1,
+        enumerable: !0,
+        get: () => (this.trackProp(a), r == null || r(a), t[a])
+      });
+    }), n;
+  }
+  trackProp(t) {
+    E(this, Nt).add(t);
+  }
+  getCurrentQuery() {
+    return E(this, z);
+  }
+  refetch({ ...t } = {}) {
+    return this.fetch({
+      ...t
+    });
+  }
+  fetchOptimistic(t) {
+    const r = E(this, ye).defaultQueryOptions(t), n = E(this, ye).getQueryCache().build(E(this, ye), r);
+    return n.isFetchingOptimistic = !0, n.fetch().then(() => this.createResult(n, r));
+  }
+  fetch(t) {
+    return Y(this, K, Kt).call(this, {
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), E(this, pe)));
+  }
+  createResult(t, r) {
+    var oe;
+    const n = E(this, z), a = this.options, u = E(this, pe), o = E(this, yt), f = E(this, Ft), y = t !== n ? t.state : E(this, Zt), { state: m } = t;
+    let l = { ...m }, v = !1, O;
+    if (r._optimisticResults) {
+      const q = this.hasListeners(), W = !q && En(t, r), ce = q && Rn(t, n, r, a);
+      (W || ce) && (l = {
+        ...l,
+        ...Gn(m.data, t.options)
+      }), r._optimisticResults === "isRestoring" && (l.fetchStatus = "idle");
+    }
+    let { error: F, errorUpdatedAt: C, status: L } = l;
+    if (r.select && l.data !== void 0)
+      if (u && l.data === (o == null ? void 0 : o.data) && r.select === E(this, er))
+        O = E(this, Tt);
+      else
+        try {
+          I(this, er, r.select), O = r.select(l.data), O = $r(u == null ? void 0 : u.data, O, r), I(this, Tt, O), I(this, Ue, null);
+        } catch (q) {
+          I(this, Ue, q);
+        }
+    else
+      O = l.data;
+    if (r.placeholderData !== void 0 && O === void 0 && L === "pending") {
+      let q;
+      if (u != null && u.isPlaceholderData && r.placeholderData === (f == null ? void 0 : f.placeholderData))
+        q = u.data;
+      else if (q = typeof r.placeholderData == "function" ? r.placeholderData(
+        (oe = E(this, Mt)) == null ? void 0 : oe.state.data,
+        E(this, Mt)
+      ) : r.placeholderData, r.select && q !== void 0)
+        try {
+          q = r.select(q), I(this, Ue, null);
+        } catch (W) {
+          I(this, Ue, W);
+        }
+      q !== void 0 && (L = "success", O = $r(
+        u == null ? void 0 : u.data,
+        q,
+        r
+      ), v = !0);
+    }
+    E(this, Ue) && (F = E(this, Ue), O = E(this, Tt), C = Date.now(), L = "error");
+    const _ = l.fetchStatus === "fetching", P = L === "pending", $ = L === "error", G = P && _, re = O !== void 0;
+    return {
+      status: L,
+      fetchStatus: l.fetchStatus,
+      isPending: P,
+      isSuccess: L === "success",
+      isError: $,
+      isInitialLoading: G,
+      isLoading: G,
+      data: O,
+      dataUpdatedAt: l.dataUpdatedAt,
+      error: F,
+      errorUpdatedAt: C,
+      failureCount: l.fetchFailureCount,
+      failureReason: l.fetchFailureReason,
+      errorUpdateCount: l.errorUpdateCount,
+      isFetched: l.dataUpdateCount > 0 || l.errorUpdateCount > 0,
+      isFetchedAfterMount: l.dataUpdateCount > y.dataUpdateCount || l.errorUpdateCount > y.errorUpdateCount,
+      isFetching: _,
+      isRefetching: _ && !P,
+      isLoadingError: $ && !re,
+      isPaused: l.fetchStatus === "paused",
+      isPlaceholderData: v,
+      isRefetchError: $ && re,
+      isStale: sn(t, r),
+      refetch: this.refetch
+    };
+  }
+  updateResult(t) {
+    const r = E(this, pe), n = this.createResult(E(this, z), this.options);
+    if (I(this, yt, E(this, z).state), I(this, Ft, this.options), E(this, yt).data !== void 0 && I(this, Mt, E(this, z)), Wr(n, r))
+      return;
+    I(this, pe, n);
+    const a = {}, u = () => {
+      if (!r)
+        return !0;
+      const { notifyOnChangeProps: o } = this.options, f = typeof o == "function" ? o() : o;
+      if (f === "all" || !f && !E(this, Nt).size)
+        return !0;
+      const c = new Set(
+        f ?? E(this, Nt)
+      );
+      return this.options.throwOnError && c.add("error"), Object.keys(E(this, pe)).some((y) => {
+        const m = y;
+        return E(this, pe)[m] !== r[m] && c.has(m);
+      });
+    };
+    (t == null ? void 0 : t.listeners) !== !1 && u() && (a.listeners = !0), Y(this, K, Xn).call(this, { ...a, ...t });
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && Y(this, K, Qr).call(this);
+  }
+}, ye = new WeakMap(), z = new WeakMap(), Zt = new WeakMap(), pe = new WeakMap(), yt = new WeakMap(), Ft = new WeakMap(), Ue = new WeakMap(), er = new WeakMap(), Tt = new WeakMap(), Mt = new WeakMap(), gt = new WeakMap(), bt = new WeakMap(), rt = new WeakMap(), Nt = new WeakMap(), K = new WeakSet(), Kt = function(t) {
+  Y(this, K, Xr).call(this);
+  let r = E(this, z).fetch(
+    this.options,
+    t
+  );
+  return t != null && t.throwOnError || (r = r.catch(kr)), r;
+}, Kr = function() {
+  Y(this, K, Jr).call(this);
+  const t = yr(
+    this.options.staleTime,
+    E(this, z)
+  );
+  if (Lt || E(this, pe).isStale || !Br(t))
+    return;
+  const n = Hn(E(this, pe).dataUpdatedAt, t) + 1;
+  I(this, gt, setTimeout(() => {
+    E(this, pe).isStale || this.updateResult();
+  }, n));
+}, qr = function() {
+  return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(E(this, z)) : this.options.refetchInterval) ?? !1;
+}, Yr = function(t) {
+  Y(this, K, Gr).call(this), I(this, rt, t), !(Lt || Te(this.options.enabled, E(this, z)) === !1 || !Br(E(this, rt)) || E(this, rt) === 0) && I(this, bt, setInterval(() => {
+    (this.options.refetchIntervalInBackground || qn.isFocused()) && Y(this, K, Kt).call(this);
+  }, E(this, rt)));
+}, Qr = function() {
+  Y(this, K, Kr).call(this), Y(this, K, Yr).call(this, Y(this, K, qr).call(this));
+}, Jr = function() {
+  E(this, gt) && (clearTimeout(E(this, gt)), I(this, gt, void 0));
+}, Gr = function() {
+  E(this, bt) && (clearInterval(E(this, bt)), I(this, bt, void 0));
+}, Xr = function() {
+  const t = E(this, ye).getQueryCache().build(E(this, ye), this.options);
+  if (t === E(this, z))
+    return;
+  const r = E(this, z);
+  I(this, z, t), I(this, Zt, t.state), this.hasListeners() && (r == null || r.removeObserver(this), t.addObserver(this));
+}, Xn = function(t) {
+  on.batch(() => {
+    t.listeners && this.listeners.forEach((r) => {
+      r(E(this, pe));
+    }), E(this, ye).getQueryCache().notify({
+      query: E(this, z),
+      type: "observerResultsUpdated"
+    });
+  });
+}, zn);
+function Ua(e, t) {
+  return Te(t.enabled, e) !== !1 && e.state.data === void 0 && !(e.state.status === "error" && t.retryOnMount === !1);
+}
+function En(e, t) {
+  return Ua(e, t) || e.state.data !== void 0 && Zr(e, t, t.refetchOnMount);
+}
+function Zr(e, t, r) {
+  if (Te(t.enabled, e) !== !1) {
+    const n = typeof r == "function" ? r(e) : r;
+    return n === "always" || n !== !1 && sn(e, t);
+  }
+  return !1;
+}
+function Rn(e, t, r, n) {
+  return (e !== t || Te(n.enabled, e) === !1) && (!r.suspense || e.state.status !== "error") && sn(e, r);
+}
+function sn(e, t) {
+  return Te(t.enabled, e) !== !1 && e.isStaleByTime(yr(t.staleTime, e));
+}
+function Aa(e, t) {
+  return !Wr(e.getCurrentResult(), t);
+}
+var Zn = D.createContext(
+  void 0
+), Ia = (e) => {
+  const t = D.useContext(Zn);
+  if (!t)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return t;
+}, Ro = ({
+  client: e,
+  children: t
+}) => (D.useEffect(() => (e.mount(), () => {
+  e.unmount();
+}), [e]), /* @__PURE__ */ Ca.jsx(Zn.Provider, { value: e, children: t })), ea = D.createContext(!1), ka = () => D.useContext(ea);
+ea.Provider;
+function Ba() {
+  let e = !1;
+  return {
+    clearReset: () => {
+      e = !1;
+    },
+    reset: () => {
+      e = !0;
+    },
+    isReset: () => e
+  };
+}
+var Va = D.createContext(Ba()), Wa = () => D.useContext(Va);
+function za(e, t) {
+  return typeof e == "function" ? e(...t) : !!e;
+}
+function wo() {
+}
+var $a = (e, t) => {
+  (e.suspense || e.throwOnError) && (t.isReset() || (e.retryOnMount = !1));
+}, Ha = (e) => {
+  D.useEffect(() => {
+    e.clearReset();
+  }, [e]);
+}, Ka = ({
+  result: e,
+  errorResetBoundary: t,
+  throwOnError: r,
+  query: n
+}) => e.isError && !t.isReset() && !e.isFetching && n && za(r, [e.error, n]), qa = (e, t) => t.state.data === void 0, Ya = (e) => {
+  e.suspense && typeof e.staleTime != "number" && (e.staleTime = 1e3);
+}, Qa = (e, t) => (e == null ? void 0 : e.suspense) && t.isPending, Ja = (e, t, r) => t.fetchOptimistic(e).catch(() => {
+  r.clearReset();
+});
+function Ga(e, t, r) {
+  var y, m, l, v;
+  if (process.env.NODE_ENV !== "production" && (typeof e != "object" || Array.isArray(e)))
+    throw new Error(
+      'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+    );
+  const n = Ia(), a = ka(), u = Wa(), o = n.defaultQueryOptions(e);
+  (m = (y = n.getDefaultOptions().queries) == null ? void 0 : y._experimental_beforeQuery) == null || m.call(
+    y,
+    o
+  ), o._optimisticResults = a ? "isRestoring" : "optimistic", Ya(o), $a(o, u), Ha(u);
+  const [f] = D.useState(
+    () => new t(
+      n,
+      o
+    )
+  ), c = f.getOptimisticResult(o);
+  if (D.useSyncExternalStore(
+    D.useCallback(
+      (O) => {
+        const F = a ? () => {
+        } : f.subscribe(on.batchCalls(O));
+        return f.updateResult(), F;
+      },
+      [f, a]
+    ),
+    () => f.getCurrentResult(),
+    () => f.getCurrentResult()
+  ), D.useEffect(() => {
+    f.setOptions(o, { listeners: !1 });
+  }, [o, f]), Qa(o, c))
+    throw Ja(o, f, u);
+  if (Ka({
+    result: c,
+    errorResetBoundary: u,
+    throwOnError: o.throwOnError,
+    query: n.getQueryCache().get(o.queryHash)
+  }))
+    throw c.error;
+  return (v = (l = n.getDefaultOptions().queries) == null ? void 0 : l._experimental_afterQuery) == null || v.call(
+    l,
+    o,
+    c
+  ), o.notifyOnChangeProps ? c : f.trackResult(c);
+}
+function ta(e, t) {
+  return process.env.NODE_ENV !== "production" && e.queryFn === Hr && console.error("skipToken is not allowed for useSuspenseQuery"), Ga(
+    {
+      ...e,
+      enabled: !0,
+      suspense: !0,
+      throwOnError: qa,
+      placeholderData: void 0
+    },
+    ja
+  );
+}
+/**
+ * @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 ee() {
+  return ee = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var r = arguments[t];
+      for (var n in r)
+        Object.prototype.hasOwnProperty.call(r, n) && (e[n] = r[n]);
+    }
+    return e;
+  }, ee.apply(this, arguments);
+}
+var ie;
+(function(e) {
+  e.Pop = "POP", e.Push = "PUSH", e.Replace = "REPLACE";
+})(ie || (ie = {}));
+const wn = "popstate";
+function So(e) {
+  e === void 0 && (e = {});
+  function t(n, a) {
+    let {
+      pathname: u,
+      search: o,
+      hash: f
+    } = n.location;
+    return Qt(
+      "",
+      {
+        pathname: u,
+        search: o,
+        hash: f
+      },
+      // state defaults to `null` because `window.history.state` does
+      a.state && a.state.usr || null,
+      a.state && a.state.key || "default"
+    );
+  }
+  function r(n, a) {
+    return typeof a == "string" ? a : tr(a);
+  }
+  return Za(t, r, null, e);
+}
+function U(e, t) {
+  if (e === !1 || e === null || typeof e > "u")
+    throw new Error(t);
+}
+function fe(e, t) {
+  if (!e) {
+    typeof console < "u" && console.warn(t);
+    try {
+      throw new Error(t);
+    } catch {
+    }
+  }
+}
+function Xa() {
+  return Math.random().toString(36).substr(2, 8);
+}
+function Sn(e, t) {
+  return {
+    usr: e.state,
+    key: e.key,
+    idx: t
+  };
+}
+function Qt(e, t, r, n) {
+  return r === void 0 && (r = null), ee({
+    pathname: typeof e == "string" ? e : e.pathname,
+    search: "",
+    hash: ""
+  }, typeof t == "string" ? nt(t) : t, {
+    state: r,
+    // 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 || n || Xa()
+  });
+}
+function tr(e) {
+  let {
+    pathname: t = "/",
+    search: r = "",
+    hash: n = ""
+  } = e;
+  return r && r !== "?" && (t += r.charAt(0) === "?" ? r : "?" + r), n && n !== "#" && (t += n.charAt(0) === "#" ? n : "#" + n), t;
+}
+function nt(e) {
+  let t = {};
+  if (e) {
+    let r = e.indexOf("#");
+    r >= 0 && (t.hash = e.substr(r), e = e.substr(0, r));
+    let n = e.indexOf("?");
+    n >= 0 && (t.search = e.substr(n), e = e.substr(0, n)), e && (t.pathname = e);
+  }
+  return t;
+}
+function Za(e, t, r, n) {
+  n === void 0 && (n = {});
+  let {
+    window: a = document.defaultView,
+    v5Compat: u = !1
+  } = n, o = a.history, f = ie.Pop, c = null, y = m();
+  y == null && (y = 0, o.replaceState(ee({}, o.state, {
+    idx: y
+  }), ""));
+  function m() {
+    return (o.state || {
+      idx: null
+    }).idx;
+  }
+  function l() {
+    f = ie.Pop;
+    let L = m(), _ = L == null ? null : L - y;
+    y = L, c && c({
+      action: f,
+      location: C.location,
+      delta: _
+    });
+  }
+  function v(L, _) {
+    f = ie.Push;
+    let P = Qt(C.location, L, _);
+    y = m() + 1;
+    let $ = Sn(P, y), G = C.createHref(P);
+    try {
+      o.pushState($, "", G);
+    } catch (re) {
+      if (re instanceof DOMException && re.name === "DataCloneError")
+        throw re;
+      a.location.assign(G);
+    }
+    u && c && c({
+      action: f,
+      location: C.location,
+      delta: 1
+    });
+  }
+  function O(L, _) {
+    f = ie.Replace;
+    let P = Qt(C.location, L, _);
+    y = m();
+    let $ = Sn(P, y), G = C.createHref(P);
+    o.replaceState($, "", G), u && c && c({
+      action: f,
+      location: C.location,
+      delta: 0
+    });
+  }
+  function F(L) {
+    let _ = a.location.origin !== "null" ? a.location.origin : a.location.href, P = typeof L == "string" ? L : tr(L);
+    return P = P.replace(/ $/, "%20"), U(_, "No window.location.(origin|href) available to create URL for href: " + P), new URL(P, _);
+  }
+  let C = {
+    get action() {
+      return f;
+    },
+    get location() {
+      return e(a, o);
+    },
+    listen(L) {
+      if (c)
+        throw new Error("A history only accepts one active listener");
+      return a.addEventListener(wn, l), c = L, () => {
+        a.removeEventListener(wn, l), c = null;
+      };
+    },
+    createHref(L) {
+      return t(a, L);
+    },
+    createURL: F,
+    encodeLocation(L) {
+      let _ = F(L);
+      return {
+        pathname: _.pathname,
+        search: _.search,
+        hash: _.hash
+      };
+    },
+    push: v,
+    replace: O,
+    go(L) {
+      return o.go(L);
+    }
+  };
+  return C;
+}
+var J;
+(function(e) {
+  e.data = "data", e.deferred = "deferred", e.redirect = "redirect", e.error = "error";
+})(J || (J = {}));
+const ei = /* @__PURE__ */ new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
+function ti(e) {
+  return e.index === !0;
+}
+function Jt(e, t, r, n) {
+  return r === void 0 && (r = []), n === void 0 && (n = {}), e.map((a, u) => {
+    let o = [...r, String(u)], f = typeof a.id == "string" ? a.id : o.join("-");
+    if (U(a.index !== !0 || !a.children, "Cannot specify children on an index route"), U(!n[f], 'Found a route id collision on id "' + f + `".  Route id's must be globally unique within Data Router usages`), ti(a)) {
+      let c = ee({}, a, t(a), {
+        id: f
+      });
+      return n[f] = c, c;
+    } else {
+      let c = ee({}, a, t(a), {
+        id: f,
+        children: void 0
+      });
+      return n[f] = c, a.children && (c.children = Jt(a.children, t, o, n)), c;
+    }
+  });
+}
+function dt(e, t, r) {
+  return r === void 0 && (r = "/"), gr(e, t, r, !1);
+}
+function gr(e, t, r, n) {
+  let a = typeof t == "string" ? nt(t) : t, u = rr(a.pathname || "/", r);
+  if (u == null)
+    return null;
+  let o = ra(e);
+  ni(o);
+  let f = null;
+  for (let c = 0; f == null && c < o.length; ++c) {
+    let y = pi(u);
+    f = fi(o[c], y, n);
+  }
+  return f;
+}
+function ri(e, t) {
+  let {
+    route: r,
+    pathname: n,
+    params: a
+  } = e;
+  return {
+    id: r.id,
+    pathname: n,
+    params: a,
+    data: t[r.id],
+    handle: r.handle
+  };
+}
+function ra(e, t, r, n) {
+  t === void 0 && (t = []), r === void 0 && (r = []), n === void 0 && (n = "");
+  let a = (u, o, f) => {
+    let c = {
+      relativePath: f === void 0 ? u.path || "" : f,
+      caseSensitive: u.caseSensitive === !0,
+      childrenIndex: o,
+      route: u
+    };
+    c.relativePath.startsWith("/") && (U(c.relativePath.startsWith(n), 'Absolute route path "' + c.relativePath + '" nested under path ' + ('"' + n + '" is not valid. An absolute child route path ') + "must start with the combined path of all its parent routes."), c.relativePath = c.relativePath.slice(n.length));
+    let y = $e([n, c.relativePath]), m = r.concat(c);
+    u.children && u.children.length > 0 && (U(
+      // Our types know better, but runtime JS may not!
+      // @ts-expect-error
+      u.index !== !0,
+      "Index routes must not have child routes. Please remove " + ('all child routes from route path "' + y + '".')
+    ), ra(u.children, t, m, y)), !(u.path == null && !u.index) && t.push({
+      path: y,
+      score: ci(y, u.index),
+      routesMeta: m
+    });
+  };
+  return e.forEach((u, o) => {
+    var f;
+    if (u.path === "" || !((f = u.path) != null && f.includes("?")))
+      a(u, o);
+    else
+      for (let c of na(u.path))
+        a(u, o, c);
+  }), t;
+}
+function na(e) {
+  let t = e.split("/");
+  if (t.length === 0) return [];
+  let [r, ...n] = t, a = r.endsWith("?"), u = r.replace(/\?$/, "");
+  if (n.length === 0)
+    return a ? [u, ""] : [u];
+  let o = na(n.join("/")), f = [];
+  return f.push(...o.map((c) => c === "" ? u : [u, c].join("/"))), a && f.push(...o), f.map((c) => e.startsWith("/") && c === "" ? "/" : c);
+}
+function ni(e) {
+  e.sort((t, r) => t.score !== r.score ? r.score - t.score : di(t.routesMeta.map((n) => n.childrenIndex), r.routesMeta.map((n) => n.childrenIndex)));
+}
+const ai = /^:[\w-]+$/, ii = 3, oi = 2, si = 1, li = 10, ui = -2, Cn = (e) => e === "*";
+function ci(e, t) {
+  let r = e.split("/"), n = r.length;
+  return r.some(Cn) && (n += ui), t && (n += oi), r.filter((a) => !Cn(a)).reduce((a, u) => a + (ai.test(u) ? ii : u === "" ? si : li), n);
+}
+function di(e, t) {
+  return e.length === t.length && e.slice(0, -1).every((n, a) => n === t[a]) ? (
+    // 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 fi(e, t, r) {
+  r === void 0 && (r = !1);
+  let {
+    routesMeta: n
+  } = e, a = {}, u = "/", o = [];
+  for (let f = 0; f < n.length; ++f) {
+    let c = n[f], y = f === n.length - 1, m = u === "/" ? t : t.slice(u.length) || "/", l = en({
+      path: c.relativePath,
+      caseSensitive: c.caseSensitive,
+      end: y
+    }, m), v = c.route;
+    if (!l && y && r && !n[n.length - 1].route.index && (l = en({
+      path: c.relativePath,
+      caseSensitive: c.caseSensitive,
+      end: !1
+    }, m)), !l)
+      return null;
+    Object.assign(a, l.params), o.push({
+      // TODO: Can this as be avoided?
+      params: a,
+      pathname: $e([u, l.pathname]),
+      pathnameBase: yi($e([u, l.pathnameBase])),
+      route: v
+    }), l.pathnameBase !== "/" && (u = $e([u, l.pathnameBase]));
+  }
+  return o;
+}
+function en(e, t) {
+  typeof e == "string" && (e = {
+    path: e,
+    caseSensitive: !1,
+    end: !0
+  });
+  let [r, n] = hi(e.path, e.caseSensitive, e.end), a = t.match(r);
+  if (!a) return null;
+  let u = a[0], o = u.replace(/(.)\/+$/, "$1"), f = a.slice(1);
+  return {
+    params: n.reduce((y, m, l) => {
+      let {
+        paramName: v,
+        isOptional: O
+      } = m;
+      if (v === "*") {
+        let C = f[l] || "";
+        o = u.slice(0, u.length - C.length).replace(/(.)\/+$/, "$1");
+      }
+      const F = f[l];
+      return O && !F ? y[v] = void 0 : y[v] = (F || "").replace(/%2F/g, "/"), y;
+    }, {}),
+    pathname: u,
+    pathnameBase: o,
+    pattern: e
+  };
+}
+function hi(e, t, r) {
+  t === void 0 && (t = !1), r === void 0 && (r = !0), fe(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 n = [], a = "^" + e.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(/\/:([\w-]+)(\?)?/g, (o, f, c) => (n.push({
+    paramName: f,
+    isOptional: c != null
+  }), c ? "/?([^\\/]+)?" : "/([^\\/]+)"));
+  return e.endsWith("*") ? (n.push({
+    paramName: "*"
+  }), a += e === "*" || e === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$") : r ? a += "\\/*$" : e !== "" && e !== "/" && (a += "(?:(?=\\/|$))"), [new RegExp(a, t ? void 0 : "i"), n];
+}
+function pi(e) {
+  try {
+    return e.split("/").map((t) => decodeURIComponent(t).replace(/\//g, "%2F")).join("/");
+  } catch (t) {
+    return fe(!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 rr(e, t) {
+  if (t === "/") return e;
+  if (!e.toLowerCase().startsWith(t.toLowerCase()))
+    return null;
+  let r = t.endsWith("/") ? t.length - 1 : t.length, n = e.charAt(r);
+  return n && n !== "/" ? null : e.slice(r) || "/";
+}
+function vi(e, t) {
+  t === void 0 && (t = "/");
+  let {
+    pathname: r,
+    search: n = "",
+    hash: a = ""
+  } = typeof e == "string" ? nt(e) : e;
+  return {
+    pathname: r ? r.startsWith("/") ? r : mi(r, t) : t,
+    search: gi(n),
+    hash: bi(a)
+  };
+}
+function mi(e, t) {
+  let r = t.replace(/\/+$/, "").split("/");
+  return e.split("/").forEach((a) => {
+    a === ".." ? r.length > 1 && r.pop() : a !== "." && r.push(a);
+  }), r.length > 1 ? r.join("/") : "/";
+}
+function jr(e, t, r, n) {
+  return "Cannot include a '" + e + "' character in a manually specified " + ("`to." + t + "` field [" + JSON.stringify(n) + "].  Please separate it out to the ") + ("`to." + r + "` field. Alternatively you may provide the full path as ") + 'a string in <Link to="..."> and the router will parse it for you.';
+}
+function aa(e) {
+  return e.filter((t, r) => r === 0 || t.route.path && t.route.path.length > 0);
+}
+function Er(e, t) {
+  let r = aa(e);
+  return t ? r.map((n, a) => a === r.length - 1 ? n.pathname : n.pathnameBase) : r.map((n) => n.pathnameBase);
+}
+function Rr(e, t, r, n) {
+  n === void 0 && (n = !1);
+  let a;
+  typeof e == "string" ? a = nt(e) : (a = ee({}, e), U(!a.pathname || !a.pathname.includes("?"), jr("?", "pathname", "search", a)), U(!a.pathname || !a.pathname.includes("#"), jr("#", "pathname", "hash", a)), U(!a.search || !a.search.includes("#"), jr("#", "search", "hash", a)));
+  let u = e === "" || a.pathname === "", o = u ? "/" : a.pathname, f;
+  if (o == null)
+    f = r;
+  else {
+    let l = t.length - 1;
+    if (!n && o.startsWith("..")) {
+      let v = o.split("/");
+      for (; v[0] === ".."; )
+        v.shift(), l -= 1;
+      a.pathname = v.join("/");
+    }
+    f = l >= 0 ? t[l] : "/";
+  }
+  let c = vi(a, f), y = o && o !== "/" && o.endsWith("/"), m = (u || o === ".") && r.endsWith("/");
+  return !c.pathname.endsWith("/") && (y || m) && (c.pathname += "/"), c;
+}
+const $e = (e) => e.join("/").replace(/\/\/+/g, "/"), yi = (e) => e.replace(/\/+$/, "").replace(/^\/*/, "/"), gi = (e) => !e || e === "?" ? "" : e.startsWith("?") ? e : "?" + e, bi = (e) => !e || e === "#" ? "" : e.startsWith("#") ? e : "#" + e;
+class ia {
+  constructor(t, r, n, a) {
+    a === void 0 && (a = !1), this.status = t, this.statusText = r || "", this.internal = a, n instanceof Error ? (this.data = n.toString(), this.error = n) : this.data = n;
+  }
+}
+function wr(e) {
+  return e != null && typeof e.status == "number" && typeof e.statusText == "string" && typeof e.internal == "boolean" && "data" in e;
+}
+const oa = ["post", "put", "patch", "delete"], Ei = new Set(oa), Ri = ["get", ...oa], wi = new Set(Ri), Si = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]), Ci = /* @__PURE__ */ new Set([307, 308]), Ur = {
+  state: "idle",
+  location: void 0,
+  formMethod: void 0,
+  formAction: void 0,
+  formEncType: void 0,
+  formData: void 0,
+  json: void 0,
+  text: void 0
+}, Di = {
+  state: "idle",
+  data: void 0,
+  formMethod: void 0,
+  formAction: void 0,
+  formEncType: void 0,
+  formData: void 0,
+  json: void 0,
+  text: void 0
+}, $t = {
+  state: "unblocked",
+  proceed: void 0,
+  reset: void 0,
+  location: void 0
+}, ln = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i, xi = (e) => ({
+  hasErrorBoundary: !!e.hasErrorBoundary
+}), sa = "remix-router-transitions";
+function Co(e) {
+  const t = e.window ? e.window : typeof window < "u" ? window : void 0, r = typeof t < "u" && typeof t.document < "u" && typeof t.document.createElement < "u", n = !r;
+  U(e.routes.length > 0, "You must provide a non-empty routes array to createRouter");
+  let a;
+  if (e.mapRouteProperties)
+    a = e.mapRouteProperties;
+  else if (e.detectErrorBoundary) {
+    let s = e.detectErrorBoundary;
+    a = (d) => ({
+      hasErrorBoundary: s(d)
+    });
+  } else
+    a = xi;
+  let u = {}, o = Jt(e.routes, a, void 0, u), f, c = e.basename || "/", y = e.unstable_dataStrategy || Ti, m = e.unstable_patchRoutesOnMiss, l = ee({
+    v7_fetcherPersist: !1,
+    v7_normalizeFormMethod: !1,
+    v7_partialHydration: !1,
+    v7_prependBasename: !1,
+    v7_relativeSplatPath: !1,
+    unstable_skipActionErrorRevalidation: !1
+  }, e.future), v = null, O = /* @__PURE__ */ new Set(), F = null, C = null, L = null, _ = e.hydrationData != null, P = dt(o, e.history.location, c), $ = null;
+  if (P == null && !m) {
+    let s = ve(404, {
+      pathname: e.history.location.pathname
+    }), {
+      matches: d,
+      route: p
+    } = Ln(o);
+    P = d, $ = {
+      [p.id]: s
+    };
+  }
+  P && m && wt(P, o, e.history.location.pathname).active && (P = null);
+  let G;
+  if (!P)
+    G = !1, P = [];
+  else if (P.some((s) => s.route.lazy))
+    G = !1;
+  else if (!P.some((s) => s.route.loader))
+    G = !0;
+  else if (l.v7_partialHydration) {
+    let s = e.hydrationData ? e.hydrationData.loaderData : null, d = e.hydrationData ? e.hydrationData.errors : null, p = (g) => g.route.loader ? typeof g.route.loader == "function" && g.route.loader.hydrate === !0 ? !1 : s && s[g.route.id] !== void 0 || d && d[g.route.id] !== void 0 : !0;
+    if (d) {
+      let g = P.findIndex((x) => d[x.route.id] !== void 0);
+      G = P.slice(0, g + 1).every(p);
+    } else
+      G = P.every(p);
+  } else
+    G = e.hydrationData != null;
+  let re, b = {
+    historyAction: e.history.action,
+    location: e.history.location,
+    matches: P,
+    initialized: G,
+    navigation: Ur,
+    // 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 || $,
+    fetchers: /* @__PURE__ */ new Map(),
+    blockers: /* @__PURE__ */ new Map()
+  }, oe = ie.Pop, q = !1, W, ce = !1, se = /* @__PURE__ */ new Map(), ge = null, ne = !1, X = !1, we = [], it = [], Z = /* @__PURE__ */ new Map(), ot = 0, He = -1, Ie = /* @__PURE__ */ new Map(), Se = /* @__PURE__ */ new Set(), ke = /* @__PURE__ */ new Map(), Ke = /* @__PURE__ */ new Map(), Pe = /* @__PURE__ */ new Set(), Be = /* @__PURE__ */ new Map(), Oe = /* @__PURE__ */ new Map(), Ut = /* @__PURE__ */ new Map(), qe = !1;
+  function At() {
+    if (v = e.history.listen((s) => {
+      let {
+        action: d,
+        location: p,
+        delta: g
+      } = s;
+      if (qe) {
+        qe = !1;
+        return;
+      }
+      fe(Oe.size === 0 || g != 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 x = Vt({
+        currentLocation: b.location,
+        nextLocation: p,
+        historyAction: d
+      });
+      if (x && g != null) {
+        qe = !0, e.history.go(g * -1), Ge(x, {
+          state: "blocked",
+          location: p,
+          proceed() {
+            Ge(x, {
+              state: "proceeding",
+              proceed: void 0,
+              reset: void 0,
+              location: p
+            }), e.history.go(g);
+          },
+          reset() {
+            let N = new Map(b.blockers);
+            N.set(x, $t), le({
+              blockers: N
+            });
+          }
+        });
+        return;
+      }
+      return be(d, p);
+    }), r) {
+      $i(t, se);
+      let s = () => Hi(t, se);
+      t.addEventListener("pagehide", s), ge = () => t.removeEventListener("pagehide", s);
+    }
+    return b.initialized || be(ie.Pop, b.location, {
+      initialHydration: !0
+    }), re;
+  }
+  function Et() {
+    v && v(), ge && ge(), O.clear(), W && W.abort(), b.fetchers.forEach((s, d) => Je(d)), b.blockers.forEach((s, d) => cr(d));
+  }
+  function Dr(s) {
+    return O.add(s), () => O.delete(s);
+  }
+  function le(s, d) {
+    d === void 0 && (d = {}), b = ee({}, b, s);
+    let p = [], g = [];
+    l.v7_fetcherPersist && b.fetchers.forEach((x, N) => {
+      x.state === "idle" && (Pe.has(N) ? g.push(N) : p.push(N));
+    }), [...O].forEach((x) => x(b, {
+      deletedFetchers: g,
+      unstable_viewTransitionOpts: d.viewTransitionOpts,
+      unstable_flushSync: d.flushSync === !0
+    })), l.v7_fetcherPersist && (p.forEach((x) => b.fetchers.delete(x)), g.forEach((x) => Je(x)));
+  }
+  function Ye(s, d, p) {
+    var g, x;
+    let {
+      flushSync: N
+    } = p === void 0 ? {} : p, i = b.actionData != null && b.navigation.formMethod != null && Fe(b.navigation.formMethod) && b.navigation.state === "loading" && ((g = s.state) == null ? void 0 : g._isRedirect) !== !0, h;
+    d.actionData ? Object.keys(d.actionData).length > 0 ? h = d.actionData : h = null : i ? h = b.actionData : h = null;
+    let R = d.loaderData ? Mn(b.loaderData, d.loaderData, d.matches || [], d.errors) : b.loaderData, w = b.blockers;
+    w.size > 0 && (w = new Map(w), w.forEach((T, M) => w.set(M, $t)));
+    let S = q === !0 || b.navigation.formMethod != null && Fe(b.navigation.formMethod) && ((x = s.state) == null ? void 0 : x._isRedirect) !== !0;
+    f && (o = f, f = void 0), ne || oe === ie.Pop || (oe === ie.Push ? e.history.push(s, s.state) : oe === ie.Replace && e.history.replace(s, s.state));
+    let j;
+    if (oe === ie.Pop) {
+      let T = se.get(b.location.pathname);
+      T && T.has(s.pathname) ? j = {
+        currentLocation: b.location,
+        nextLocation: s
+      } : se.has(s.pathname) && (j = {
+        currentLocation: s,
+        nextLocation: b.location
+      });
+    } else if (ce) {
+      let T = se.get(b.location.pathname);
+      T ? T.add(s.pathname) : (T = /* @__PURE__ */ new Set([s.pathname]), se.set(b.location.pathname, T)), j = {
+        currentLocation: b.location,
+        nextLocation: s
+      };
+    }
+    le(ee({}, d, {
+      actionData: h,
+      loaderData: R,
+      historyAction: oe,
+      location: s,
+      initialized: !0,
+      navigation: Ur,
+      revalidation: "idle",
+      restoreScrollPosition: pr(s, d.matches || b.matches),
+      preventScrollReset: S,
+      blockers: w
+    }), {
+      viewTransitionOpts: j,
+      flushSync: N === !0
+    }), oe = ie.Pop, q = !1, ce = !1, ne = !1, X = !1, we = [], it = [];
+  }
+  async function ar(s, d) {
+    if (typeof s == "number") {
+      e.history.go(s);
+      return;
+    }
+    let p = tn(b.location, b.matches, c, l.v7_prependBasename, s, l.v7_relativeSplatPath, d == null ? void 0 : d.fromRouteId, d == null ? void 0 : d.relative), {
+      path: g,
+      submission: x,
+      error: N
+    } = Dn(l.v7_normalizeFormMethod, !1, p, d), i = b.location, h = Qt(b.location, g, d && d.state);
+    h = ee({}, h, e.history.encodeLocation(h));
+    let R = d && d.replace != null ? d.replace : void 0, w = ie.Push;
+    R === !0 ? w = ie.Replace : R === !1 || x != null && Fe(x.formMethod) && x.formAction === b.location.pathname + b.location.search && (w = ie.Replace);
+    let S = d && "preventScrollReset" in d ? d.preventScrollReset === !0 : void 0, j = (d && d.unstable_flushSync) === !0, T = Vt({
+      currentLocation: i,
+      nextLocation: h,
+      historyAction: w
+    });
+    if (T) {
+      Ge(T, {
+        state: "blocked",
+        location: h,
+        proceed() {
+          Ge(T, {
+            state: "proceeding",
+            proceed: void 0,
+            reset: void 0,
+            location: h
+          }), ar(s, d);
+        },
+        reset() {
+          let M = new Map(b.blockers);
+          M.set(T, $t), le({
+            blockers: M
+          });
+        }
+      });
+      return;
+    }
+    return await be(w, h, {
+      submission: x,
+      // Send through the formData serialization error if we have one so we can
+      // render at the right error boundary after we match routes
+      pendingError: N,
+      preventScrollReset: S,
+      replace: d && d.replace,
+      enableViewTransition: d && d.unstable_viewTransition,
+      flushSync: j
+    });
+  }
+  function Rt() {
+    if (Ve(), le({
+      revalidation: "loading"
+    }), b.navigation.state !== "submitting") {
+      if (b.navigation.state === "idle") {
+        be(b.historyAction, b.location, {
+          startUninterruptedRevalidation: !0
+        });
+        return;
+      }
+      be(oe || b.historyAction, b.navigation.location, {
+        overrideNavigation: b.navigation
+      });
+    }
+  }
+  async function be(s, d, p) {
+    W && W.abort(), W = null, oe = s, ne = (p && p.startUninterruptedRevalidation) === !0, hr(b.location, b.matches), q = (p && p.preventScrollReset) === !0, ce = (p && p.enableViewTransition) === !0;
+    let g = f || o, x = p && p.overrideNavigation, N = dt(g, d, c), i = (p && p.flushSync) === !0, h = wt(N, g, d.pathname);
+    if (h.active && h.matches && (N = h.matches), !N) {
+      let {
+        error: A,
+        notFoundMatches: B,
+        route: k
+      } = Le(d.pathname);
+      Ye(d, {
+        matches: B,
+        loaderData: {},
+        errors: {
+          [k.id]: A
+        }
+      }, {
+        flushSync: i
+      });
+      return;
+    }
+    if (b.initialized && !X && Ai(b.location, d) && !(p && p.submission && Fe(p.submission.formMethod))) {
+      Ye(d, {
+        matches: N
+      }, {
+        flushSync: i
+      });
+      return;
+    }
+    W = new AbortController();
+    let R = Ct(e.history, d, W.signal, p && p.submission), w;
+    if (p && p.pendingError)
+      w = [Yt(N).route.id, {
+        type: J.error,
+        error: p.pendingError
+      }];
+    else if (p && p.submission && Fe(p.submission.formMethod)) {
+      let A = await ir(R, d, p.submission, N, h.active, {
+        replace: p.replace,
+        flushSync: i
+      });
+      if (A.shortCircuited)
+        return;
+      if (A.pendingActionResult) {
+        let [B, k] = A.pendingActionResult;
+        if (Re(k) && wr(k.error) && k.error.status === 404) {
+          W = null, Ye(d, {
+            matches: A.matches,
+            loaderData: {},
+            errors: {
+              [B]: k.error
+            }
+          });
+          return;
+        }
+      }
+      N = A.matches || N, w = A.pendingActionResult, x = Ar(d, p.submission), i = !1, h.active = !1, R = Ct(e.history, R.url, R.signal);
+    }
+    let {
+      shortCircuited: S,
+      matches: j,
+      loaderData: T,
+      errors: M
+    } = await or(R, d, N, h.active, x, p && p.submission, p && p.fetcherSubmission, p && p.replace, p && p.initialHydration === !0, i, w);
+    S || (W = null, Ye(d, ee({
+      matches: j || N
+    }, Nn(w), {
+      loaderData: T,
+      errors: M
+    })));
+  }
+  async function ir(s, d, p, g, x, N) {
+    N === void 0 && (N = {}), Ve();
+    let i = Wi(d, p);
+    if (le({
+      navigation: i
+    }, {
+      flushSync: N.flushSync === !0
+    }), x) {
+      let w = await ct(g, d.pathname, s.signal);
+      if (w.type === "aborted")
+        return {
+          shortCircuited: !0
+        };
+      if (w.type === "error") {
+        let {
+          error: S,
+          notFoundMatches: j,
+          route: T
+        } = Xe(d.pathname, w);
+        return {
+          matches: j,
+          pendingActionResult: [T.id, {
+            type: J.error,
+            error: S
+          }]
+        };
+      } else if (w.matches)
+        g = w.matches;
+      else {
+        let {
+          notFoundMatches: S,
+          error: j,
+          route: T
+        } = Le(d.pathname);
+        return {
+          matches: S,
+          pendingActionResult: [T.id, {
+            type: J.error,
+            error: j
+          }]
+        };
+      }
+    }
+    let h, R = qt(g, d);
+    if (!R.route.action && !R.route.lazy)
+      h = {
+        type: J.error,
+        error: ve(405, {
+          method: s.method,
+          pathname: d.pathname,
+          routeId: R.route.id
+        })
+      };
+    else if (h = (await Qe("action", s, [R], g))[0], s.signal.aborted)
+      return {
+        shortCircuited: !0
+      };
+    if (ht(h)) {
+      let w;
+      return N && N.replace != null ? w = N.replace : w = _n(h.response.headers.get("Location"), new URL(s.url), c) === b.location.pathname + b.location.search, await lt(s, h, {
+        submission: p,
+        replace: w
+      }), {
+        shortCircuited: !0
+      };
+    }
+    if (ft(h))
+      throw ve(400, {
+        type: "defer-action"
+      });
+    if (Re(h)) {
+      let w = Yt(g, R.route.id);
+      return (N && N.replace) !== !0 && (oe = ie.Push), {
+        matches: g,
+        pendingActionResult: [w.route.id, h]
+      };
+    }
+    return {
+      matches: g,
+      pendingActionResult: [R.route.id, h]
+    };
+  }
+  async function or(s, d, p, g, x, N, i, h, R, w, S) {
+    let j = x || Ar(d, N), T = N || i || An(j), M = !ne && (!l.v7_partialHydration || !R);
+    if (g) {
+      if (M) {
+        let te = st(S);
+        le(ee({
+          navigation: j
+        }, te !== void 0 ? {
+          actionData: te
+        } : {}), {
+          flushSync: w
+        });
+      }
+      let V = await ct(p, d.pathname, s.signal);
+      if (V.type === "aborted")
+        return {
+          shortCircuited: !0
+        };
+      if (V.type === "error") {
+        let {
+          error: te,
+          notFoundMatches: Ee,
+          route: Q
+        } = Xe(d.pathname, V);
+        return {
+          matches: Ee,
+          loaderData: {},
+          errors: {
+            [Q.id]: te
+          }
+        };
+      } else if (V.matches)
+        p = V.matches;
+      else {
+        let {
+          error: te,
+          notFoundMatches: Ee,
+          route: Q
+        } = Le(d.pathname);
+        return {
+          matches: Ee,
+          loaderData: {},
+          errors: {
+            [Q.id]: te
+          }
+        };
+      }
+    }
+    let A = f || o, [B, k] = xn(e.history, b, p, T, d, l.v7_partialHydration && R === !0, l.unstable_skipActionErrorRevalidation, X, we, it, Pe, ke, Se, A, c, S);
+    if (ut((V) => !(p && p.some((te) => te.route.id === V)) || B && B.some((te) => te.route.id === V)), He = ++ot, B.length === 0 && k.length === 0) {
+      let V = lr();
+      return Ye(d, ee({
+        matches: p,
+        loaderData: {},
+        // Commit pending error if we're short circuiting
+        errors: S && Re(S[1]) ? {
+          [S[0]]: S[1].error
+        } : null
+      }, Nn(S), V ? {
+        fetchers: new Map(b.fetchers)
+      } : {}), {
+        flushSync: w
+      }), {
+        shortCircuited: !0
+      };
+    }
+    if (M) {
+      let V = {};
+      if (!g) {
+        V.navigation = j;
+        let te = st(S);
+        te !== void 0 && (V.actionData = te);
+      }
+      k.length > 0 && (V.fetchers = xr(k)), le(V, {
+        flushSync: w
+      });
+    }
+    k.forEach((V) => {
+      Z.has(V.key) && Ne(V.key), V.controller && Z.set(V.key, V.controller);
+    });
+    let ue = () => k.forEach((V) => Ne(V.key));
+    W && W.signal.addEventListener("abort", ue);
+    let {
+      loaderResults: he,
+      fetcherResults: me
+    } = await kt(b.matches, p, B, k, s);
+    if (s.signal.aborted)
+      return {
+        shortCircuited: !0
+      };
+    W && W.signal.removeEventListener("abort", ue), k.forEach((V) => Z.delete(V.key));
+    let ae = jn([...he, ...me]);
+    if (ae) {
+      if (ae.idx >= B.length) {
+        let V = k[ae.idx - B.length].key;
+        Se.add(V);
+      }
+      return await lt(s, ae.result, {
+        replace: h
+      }), {
+        shortCircuited: !0
+      };
+    }
+    let {
+      loaderData: je,
+      errors: De
+    } = Tn(b, p, B, he, S, k, me, Be);
+    Be.forEach((V, te) => {
+      V.subscribe((Ee) => {
+        (Ee || V.done) && Be.delete(te);
+      });
+    }), l.v7_partialHydration && R && b.errors && Object.entries(b.errors).filter((V) => {
+      let [te] = V;
+      return !B.some((Ee) => Ee.route.id === te);
+    }).forEach((V) => {
+      let [te, Ee] = V;
+      De = Object.assign(De || {}, {
+        [te]: Ee
+      });
+    });
+    let St = lr(), vr = ur(He), mr = St || vr || k.length > 0;
+    return ee({
+      matches: p,
+      loaderData: je,
+      errors: De
+    }, mr ? {
+      fetchers: new Map(b.fetchers)
+    } : {});
+  }
+  function st(s) {
+    if (s && !Re(s[1]))
+      return {
+        [s[0]]: s[1].data
+      };
+    if (b.actionData)
+      return Object.keys(b.actionData).length === 0 ? null : b.actionData;
+  }
+  function xr(s) {
+    return s.forEach((d) => {
+      let p = b.fetchers.get(d.key), g = Ht(void 0, p ? p.data : void 0);
+      b.fetchers.set(d.key, g);
+    }), new Map(b.fetchers);
+  }
+  function Pr(s, d, p, g) {
+    if (n)
+      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.");
+    Z.has(s) && Ne(s);
+    let x = (g && g.unstable_flushSync) === !0, N = f || o, i = tn(b.location, b.matches, c, l.v7_prependBasename, p, l.v7_relativeSplatPath, d, g == null ? void 0 : g.relative), h = dt(N, i, c), R = wt(h, N, i);
+    if (R.active && R.matches && (h = R.matches), !h) {
+      Ce(s, d, ve(404, {
+        pathname: i
+      }), {
+        flushSync: x
+      });
+      return;
+    }
+    let {
+      path: w,
+      submission: S,
+      error: j
+    } = Dn(l.v7_normalizeFormMethod, !0, i, g);
+    if (j) {
+      Ce(s, d, j, {
+        flushSync: x
+      });
+      return;
+    }
+    let T = qt(h, w);
+    if (q = (g && g.preventScrollReset) === !0, S && Fe(S.formMethod)) {
+      It(s, d, w, T, h, R.active, x, S);
+      return;
+    }
+    ke.set(s, {
+      routeId: d,
+      path: w
+    }), Or(s, d, w, T, h, R.active, x, S);
+  }
+  async function It(s, d, p, g, x, N, i, h) {
+    Ve(), ke.delete(s);
+    function R(Q) {
+      if (!Q.route.action && !Q.route.lazy) {
+        let We = ve(405, {
+          method: h.formMethod,
+          pathname: p,
+          routeId: d
+        });
+        return Ce(s, d, We, {
+          flushSync: i
+        }), !0;
+      }
+      return !1;
+    }
+    if (!N && R(g))
+      return;
+    let w = b.fetchers.get(s);
+    Me(s, zi(h, w), {
+      flushSync: i
+    });
+    let S = new AbortController(), j = Ct(e.history, p, S.signal, h);
+    if (N) {
+      let Q = await ct(x, p, j.signal);
+      if (Q.type === "aborted")
+        return;
+      if (Q.type === "error") {
+        let {
+          error: We
+        } = Xe(p, Q);
+        Ce(s, d, We, {
+          flushSync: i
+        });
+        return;
+      } else if (Q.matches) {
+        if (x = Q.matches, g = qt(x, p), R(g))
+          return;
+      } else {
+        Ce(s, d, ve(404, {
+          pathname: p
+        }), {
+          flushSync: i
+        });
+        return;
+      }
+    }
+    Z.set(s, S);
+    let T = ot, A = (await Qe("action", j, [g], x))[0];
+    if (j.signal.aborted) {
+      Z.get(s) === S && Z.delete(s);
+      return;
+    }
+    if (l.v7_fetcherPersist && Pe.has(s)) {
+      if (ht(A) || Re(A)) {
+        Me(s, Ze(void 0));
+        return;
+      }
+    } else {
+      if (ht(A))
+        if (Z.delete(s), He > T) {
+          Me(s, Ze(void 0));
+          return;
+        } else
+          return Se.add(s), Me(s, Ht(h)), lt(j, A, {
+            fetcherSubmission: h
+          });
+      if (Re(A)) {
+        Ce(s, d, A.error);
+        return;
+      }
+    }
+    if (ft(A))
+      throw ve(400, {
+        type: "defer-action"
+      });
+    let B = b.navigation.location || b.location, k = Ct(e.history, B, S.signal), ue = f || o, he = b.navigation.state !== "idle" ? dt(ue, b.navigation.location, c) : b.matches;
+    U(he, "Didn't find any matches after fetcher action");
+    let me = ++ot;
+    Ie.set(s, me);
+    let ae = Ht(h, A.data);
+    b.fetchers.set(s, ae);
+    let [je, De] = xn(e.history, b, he, h, B, !1, l.unstable_skipActionErrorRevalidation, X, we, it, Pe, ke, Se, ue, c, [g.route.id, A]);
+    De.filter((Q) => Q.key !== s).forEach((Q) => {
+      let We = Q.key, pn = b.fetchers.get(We), ba = Ht(void 0, pn ? pn.data : void 0);
+      b.fetchers.set(We, ba), Z.has(We) && Ne(We), Q.controller && Z.set(We, Q.controller);
+    }), le({
+      fetchers: new Map(b.fetchers)
+    });
+    let St = () => De.forEach((Q) => Ne(Q.key));
+    S.signal.addEventListener("abort", St);
+    let {
+      loaderResults: vr,
+      fetcherResults: mr
+    } = await kt(b.matches, he, je, De, k);
+    if (S.signal.aborted)
+      return;
+    S.signal.removeEventListener("abort", St), Ie.delete(s), Z.delete(s), De.forEach((Q) => Z.delete(Q.key));
+    let V = jn([...vr, ...mr]);
+    if (V) {
+      if (V.idx >= je.length) {
+        let Q = De[V.idx - je.length].key;
+        Se.add(Q);
+      }
+      return lt(k, V.result);
+    }
+    let {
+      loaderData: te,
+      errors: Ee
+    } = Tn(b, b.matches, je, vr, void 0, De, mr, Be);
+    if (b.fetchers.has(s)) {
+      let Q = Ze(A.data);
+      b.fetchers.set(s, Q);
+    }
+    ur(me), b.navigation.state === "loading" && me > He ? (U(oe, "Expected pending action"), W && W.abort(), Ye(b.navigation.location, {
+      matches: he,
+      loaderData: te,
+      errors: Ee,
+      fetchers: new Map(b.fetchers)
+    })) : (le({
+      errors: Ee,
+      loaderData: Mn(b.loaderData, te, he, Ee),
+      fetchers: new Map(b.fetchers)
+    }), X = !1);
+  }
+  async function Or(s, d, p, g, x, N, i, h) {
+    let R = b.fetchers.get(s);
+    Me(s, Ht(h, R ? R.data : void 0), {
+      flushSync: i
+    });
+    let w = new AbortController(), S = Ct(e.history, p, w.signal);
+    if (N) {
+      let A = await ct(x, p, S.signal);
+      if (A.type === "aborted")
+        return;
+      if (A.type === "error") {
+        let {
+          error: B
+        } = Xe(p, A);
+        Ce(s, d, B, {
+          flushSync: i
+        });
+        return;
+      } else if (A.matches)
+        x = A.matches, g = qt(x, p);
+      else {
+        Ce(s, d, ve(404, {
+          pathname: p
+        }), {
+          flushSync: i
+        });
+        return;
+      }
+    }
+    Z.set(s, w);
+    let j = ot, M = (await Qe("loader", S, [g], x))[0];
+    if (ft(M) && (M = await fa(M, S.signal, !0) || M), Z.get(s) === w && Z.delete(s), !S.signal.aborted) {
+      if (Pe.has(s)) {
+        Me(s, Ze(void 0));
+        return;
+      }
+      if (ht(M))
+        if (He > j) {
+          Me(s, Ze(void 0));
+          return;
+        } else {
+          Se.add(s), await lt(S, M);
+          return;
+        }
+      if (Re(M)) {
+        Ce(s, d, M.error);
+        return;
+      }
+      U(!ft(M), "Unhandled fetcher deferred data"), Me(s, Ze(M.data));
+    }
+  }
+  async function lt(s, d, p) {
+    let {
+      submission: g,
+      fetcherSubmission: x,
+      replace: N
+    } = p === void 0 ? {} : p;
+    d.response.headers.has("X-Remix-Revalidate") && (X = !0);
+    let i = d.response.headers.get("Location");
+    U(i, "Expected a Location header on the redirect Response"), i = _n(i, new URL(s.url), c);
+    let h = Qt(b.location, i, {
+      _isRedirect: !0
+    });
+    if (r) {
+      let M = !1;
+      if (d.response.headers.has("X-Remix-Reload-Document"))
+        M = !0;
+      else if (ln.test(i)) {
+        const A = e.history.createURL(i);
+        M = // Hard reload if it's an absolute URL to a new origin
+        A.origin !== t.location.origin || // Hard reload if it's an absolute URL that does not match our basename
+        rr(A.pathname, c) == null;
+      }
+      if (M) {
+        N ? t.location.replace(i) : t.location.assign(i);
+        return;
+      }
+    }
+    W = null;
+    let R = N === !0 ? ie.Replace : ie.Push, {
+      formMethod: w,
+      formAction: S,
+      formEncType: j
+    } = b.navigation;
+    !g && !x && w && S && j && (g = An(b.navigation));
+    let T = g || x;
+    if (Ci.has(d.response.status) && T && Fe(T.formMethod))
+      await be(R, h, {
+        submission: ee({}, T, {
+          formAction: i
+        }),
+        // Preserve this flag across redirects
+        preventScrollReset: q
+      });
+    else {
+      let M = Ar(h, g);
+      await be(R, h, {
+        overrideNavigation: M,
+        // Send fetcher submissions through for shouldRevalidate
+        fetcherSubmission: x,
+        // Preserve this flag across redirects
+        preventScrollReset: q
+      });
+    }
+  }
+  async function Qe(s, d, p, g) {
+    try {
+      let x = await Mi(y, s, d, p, g, u, a);
+      return await Promise.all(x.map((N, i) => {
+        if (ki(N)) {
+          let h = N.result;
+          return {
+            type: J.redirect,
+            response: ji(h, d, p[i].route.id, g, c, l.v7_relativeSplatPath)
+          };
+        }
+        return Li(N);
+      }));
+    } catch (x) {
+      return p.map(() => ({
+        type: J.error,
+        error: x
+      }));
+    }
+  }
+  async function kt(s, d, p, g, x) {
+    let [N, ...i] = await Promise.all([p.length ? Qe("loader", x, p, d) : [], ...g.map((h) => {
+      if (h.matches && h.match && h.controller) {
+        let R = Ct(e.history, h.path, h.controller.signal);
+        return Qe("loader", R, [h.match], h.matches).then((w) => w[0]);
+      } else
+        return Promise.resolve({
+          type: J.error,
+          error: ve(404, {
+            pathname: h.path
+          })
+        });
+    })]);
+    return await Promise.all([Un(s, p, N, N.map(() => x.signal), !1, b.loaderData), Un(s, g.map((h) => h.match), i, g.map((h) => h.controller ? h.controller.signal : null), !0)]), {
+      loaderResults: N,
+      fetcherResults: i
+    };
+  }
+  function Ve() {
+    X = !0, we.push(...ut()), ke.forEach((s, d) => {
+      Z.has(d) && (it.push(d), Ne(d));
+    });
+  }
+  function Me(s, d, p) {
+    p === void 0 && (p = {}), b.fetchers.set(s, d), le({
+      fetchers: new Map(b.fetchers)
+    }, {
+      flushSync: (p && p.flushSync) === !0
+    });
+  }
+  function Ce(s, d, p, g) {
+    g === void 0 && (g = {});
+    let x = Yt(b.matches, d);
+    Je(s), le({
+      errors: {
+        [x.route.id]: p
+      },
+      fetchers: new Map(b.fetchers)
+    }, {
+      flushSync: (g && g.flushSync) === !0
+    });
+  }
+  function Bt(s) {
+    return l.v7_fetcherPersist && (Ke.set(s, (Ke.get(s) || 0) + 1), Pe.has(s) && Pe.delete(s)), b.fetchers.get(s) || Di;
+  }
+  function Je(s) {
+    let d = b.fetchers.get(s);
+    Z.has(s) && !(d && d.state === "loading" && Ie.has(s)) && Ne(s), ke.delete(s), Ie.delete(s), Se.delete(s), Pe.delete(s), b.fetchers.delete(s);
+  }
+  function _r(s) {
+    if (l.v7_fetcherPersist) {
+      let d = (Ke.get(s) || 0) - 1;
+      d <= 0 ? (Ke.delete(s), Pe.add(s)) : Ke.set(s, d);
+    } else
+      Je(s);
+    le({
+      fetchers: new Map(b.fetchers)
+    });
+  }
+  function Ne(s) {
+    let d = Z.get(s);
+    U(d, "Expected fetch controller: " + s), d.abort(), Z.delete(s);
+  }
+  function sr(s) {
+    for (let d of s) {
+      let p = Bt(d), g = Ze(p.data);
+      b.fetchers.set(d, g);
+    }
+  }
+  function lr() {
+    let s = [], d = !1;
+    for (let p of Se) {
+      let g = b.fetchers.get(p);
+      U(g, "Expected fetcher: " + p), g.state === "loading" && (Se.delete(p), s.push(p), d = !0);
+    }
+    return sr(s), d;
+  }
+  function ur(s) {
+    let d = [];
+    for (let [p, g] of Ie)
+      if (g < s) {
+        let x = b.fetchers.get(p);
+        U(x, "Expected fetcher: " + p), x.state === "loading" && (Ne(p), Ie.delete(p), d.push(p));
+      }
+    return sr(d), d.length > 0;
+  }
+  function Fr(s, d) {
+    let p = b.blockers.get(s) || $t;
+    return Oe.get(s) !== d && Oe.set(s, d), p;
+  }
+  function cr(s) {
+    b.blockers.delete(s), Oe.delete(s);
+  }
+  function Ge(s, d) {
+    let p = b.blockers.get(s) || $t;
+    U(p.state === "unblocked" && d.state === "blocked" || p.state === "blocked" && d.state === "blocked" || p.state === "blocked" && d.state === "proceeding" || p.state === "blocked" && d.state === "unblocked" || p.state === "proceeding" && d.state === "unblocked", "Invalid blocker state transition: " + p.state + " -> " + d.state);
+    let g = new Map(b.blockers);
+    g.set(s, d), le({
+      blockers: g
+    });
+  }
+  function Vt(s) {
+    let {
+      currentLocation: d,
+      nextLocation: p,
+      historyAction: g
+    } = s;
+    if (Oe.size === 0)
+      return;
+    Oe.size > 1 && fe(!1, "A router only supports one blocker at a time");
+    let x = Array.from(Oe.entries()), [N, i] = x[x.length - 1], h = b.blockers.get(N);
+    if (!(h && h.state === "proceeding") && i({
+      currentLocation: d,
+      nextLocation: p,
+      historyAction: g
+    }))
+      return N;
+  }
+  function Le(s) {
+    let d = ve(404, {
+      pathname: s
+    }), p = f || o, {
+      matches: g,
+      route: x
+    } = Ln(p);
+    return ut(), {
+      notFoundMatches: g,
+      route: x,
+      error: d
+    };
+  }
+  function Xe(s, d) {
+    let p = d.partialMatches, g = p[p.length - 1].route, x = ve(400, {
+      type: "route-discovery",
+      routeId: g.id,
+      pathname: s,
+      message: d.error != null && "message" in d.error ? d.error : String(d.error)
+    });
+    return {
+      notFoundMatches: p,
+      route: g,
+      error: x
+    };
+  }
+  function ut(s) {
+    let d = [];
+    return Be.forEach((p, g) => {
+      (!s || s(g)) && (p.cancel(), d.push(g), Be.delete(g));
+    }), d;
+  }
+  function dr(s, d, p) {
+    if (F = s, L = d, C = p || null, !_ && b.navigation === Ur) {
+      _ = !0;
+      let g = pr(b.location, b.matches);
+      g != null && le({
+        restoreScrollPosition: g
+      });
+    }
+    return () => {
+      F = null, L = null, C = null;
+    };
+  }
+  function fr(s, d) {
+    return C && C(s, d.map((g) => ri(g, b.loaderData))) || s.key;
+  }
+  function hr(s, d) {
+    if (F && L) {
+      let p = fr(s, d);
+      F[p] = L();
+    }
+  }
+  function pr(s, d) {
+    if (F) {
+      let p = fr(s, d), g = F[p];
+      if (typeof g == "number")
+        return g;
+    }
+    return null;
+  }
+  function wt(s, d, p) {
+    if (m)
+      if (s) {
+        let g = s[s.length - 1].route;
+        if (g.path && (g.path === "*" || g.path.endsWith("/*")))
+          return {
+            active: !0,
+            matches: gr(d, p, c, !0)
+          };
+      } else
+        return {
+          active: !0,
+          matches: gr(d, p, c, !0) || []
+        };
+    return {
+      active: !1,
+      matches: null
+    };
+  }
+  async function ct(s, d, p) {
+    let g = s, x = g.length > 0 ? g[g.length - 1].route : null;
+    for (; ; ) {
+      let N = f == null, i = f || o;
+      try {
+        await Fi(m, d, g, i, u, a, Ut, p);
+      } catch (S) {
+        return {
+          type: "error",
+          error: S,
+          partialMatches: g
+        };
+      } finally {
+        N && (o = [...o]);
+      }
+      if (p.aborted)
+        return {
+          type: "aborted"
+        };
+      let h = dt(i, d, c), R = !1;
+      if (h) {
+        let S = h[h.length - 1].route;
+        if (S.index)
+          return {
+            type: "success",
+            matches: h
+          };
+        if (S.path && S.path.length > 0)
+          if (S.path === "*")
+            R = !0;
+          else
+            return {
+              type: "success",
+              matches: h
+            };
+      }
+      let w = gr(i, d, c, !0);
+      if (!w || g.map((S) => S.route.id).join("-") === w.map((S) => S.route.id).join("-"))
+        return {
+          type: "success",
+          matches: R ? h : null
+        };
+      if (g = w, x = g[g.length - 1].route, x.path === "*")
+        return {
+          type: "success",
+          matches: g
+        };
+    }
+  }
+  function Tr(s) {
+    u = {}, f = Jt(s, a, void 0, u);
+  }
+  function Mr(s, d) {
+    let p = f == null;
+    ua(s, d, f || o, u, a), p && (o = [...o], le({}));
+  }
+  return re = {
+    get basename() {
+      return c;
+    },
+    get future() {
+      return l;
+    },
+    get state() {
+      return b;
+    },
+    get routes() {
+      return o;
+    },
+    get window() {
+      return t;
+    },
+    initialize: At,
+    subscribe: Dr,
+    enableScrollRestoration: dr,
+    navigate: ar,
+    fetch: Pr,
+    revalidate: Rt,
+    // Passthrough to history-aware createHref used by useHref so we get proper
+    // hash-aware URLs in DOM paths
+    createHref: (s) => e.history.createHref(s),
+    encodeLocation: (s) => e.history.encodeLocation(s),
+    getFetcher: Bt,
+    deleteFetcher: _r,
+    dispose: Et,
+    getBlocker: Fr,
+    deleteBlocker: cr,
+    patchRoutes: Mr,
+    _internalFetchControllers: Z,
+    _internalActiveDeferreds: Be,
+    // TODO: Remove setRoutes, it's temporary to avoid dealing with
+    // updating the tree while validating the update algorithm.
+    _internalSetRoutes: Tr
+  }, re;
+}
+function Pi(e) {
+  return e != null && ("formData" in e && e.formData != null || "body" in e && e.body !== void 0);
+}
+function tn(e, t, r, n, a, u, o, f) {
+  let c, y;
+  if (o) {
+    c = [];
+    for (let l of t)
+      if (c.push(l), l.route.id === o) {
+        y = l;
+        break;
+      }
+  } else
+    c = t, y = t[t.length - 1];
+  let m = Rr(a || ".", Er(c, u), rr(e.pathname, r) || e.pathname, f === "path");
+  return a == null && (m.search = e.search, m.hash = e.hash), (a == null || a === "" || a === ".") && y && y.route.index && !un(m.search) && (m.search = m.search ? m.search.replace(/^\?/, "?index&") : "?index"), n && r !== "/" && (m.pathname = m.pathname === "/" ? r : $e([r, m.pathname])), tr(m);
+}
+function Dn(e, t, r, n) {
+  if (!n || !Pi(n))
+    return {
+      path: r
+    };
+  if (n.formMethod && !Vi(n.formMethod))
+    return {
+      path: r,
+      error: ve(405, {
+        method: n.formMethod
+      })
+    };
+  let a = () => ({
+    path: r,
+    error: ve(400, {
+      type: "invalid-body"
+    })
+  }), u = n.formMethod || "get", o = e ? u.toUpperCase() : u.toLowerCase(), f = ca(r);
+  if (n.body !== void 0) {
+    if (n.formEncType === "text/plain") {
+      if (!Fe(o))
+        return a();
+      let v = typeof n.body == "string" ? n.body : n.body instanceof FormData || n.body instanceof URLSearchParams ? (
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
+        Array.from(n.body.entries()).reduce((O, F) => {
+          let [C, L] = F;
+          return "" + O + C + "=" + L + `
+`;
+        }, "")
+      ) : String(n.body);
+      return {
+        path: r,
+        submission: {
+          formMethod: o,
+          formAction: f,
+          formEncType: n.formEncType,
+          formData: void 0,
+          json: void 0,
+          text: v
+        }
+      };
+    } else if (n.formEncType === "application/json") {
+      if (!Fe(o))
+        return a();
+      try {
+        let v = typeof n.body == "string" ? JSON.parse(n.body) : n.body;
+        return {
+          path: r,
+          submission: {
+            formMethod: o,
+            formAction: f,
+            formEncType: n.formEncType,
+            formData: void 0,
+            json: v,
+            text: void 0
+          }
+        };
+      } catch {
+        return a();
+      }
+    }
+  }
+  U(typeof FormData == "function", "FormData is not available in this environment");
+  let c, y;
+  if (n.formData)
+    c = rn(n.formData), y = n.formData;
+  else if (n.body instanceof FormData)
+    c = rn(n.body), y = n.body;
+  else if (n.body instanceof URLSearchParams)
+    c = n.body, y = Fn(c);
+  else if (n.body == null)
+    c = new URLSearchParams(), y = new FormData();
+  else
+    try {
+      c = new URLSearchParams(n.body), y = Fn(c);
+    } catch {
+      return a();
+    }
+  let m = {
+    formMethod: o,
+    formAction: f,
+    formEncType: n && n.formEncType || "application/x-www-form-urlencoded",
+    formData: y,
+    json: void 0,
+    text: void 0
+  };
+  if (Fe(m.formMethod))
+    return {
+      path: r,
+      submission: m
+    };
+  let l = nt(r);
+  return t && l.search && un(l.search) && c.append("index", ""), l.search = "?" + c, {
+    path: tr(l),
+    submission: m
+  };
+}
+function Oi(e, t) {
+  let r = e;
+  if (t) {
+    let n = e.findIndex((a) => a.route.id === t);
+    n >= 0 && (r = e.slice(0, n));
+  }
+  return r;
+}
+function xn(e, t, r, n, a, u, o, f, c, y, m, l, v, O, F, C) {
+  let L = C ? Re(C[1]) ? C[1].error : C[1].data : void 0, _ = e.createURL(t.location), P = e.createURL(a), $ = C && Re(C[1]) ? C[0] : void 0, G = $ ? Oi(r, $) : r, re = C ? C[1].statusCode : void 0, b = o && re && re >= 400, oe = G.filter((W, ce) => {
+    let {
+      route: se
+    } = W;
+    if (se.lazy)
+      return !0;
+    if (se.loader == null)
+      return !1;
+    if (u)
+      return typeof se.loader != "function" || se.loader.hydrate ? !0 : t.loaderData[se.id] === void 0 && // Don't re-run if the loader ran and threw an error
+      (!t.errors || t.errors[se.id] === void 0);
+    if (_i(t.loaderData, t.matches[ce], W) || c.some((X) => X === W.route.id))
+      return !0;
+    let ge = t.matches[ce], ne = W;
+    return Pn(W, ee({
+      currentUrl: _,
+      currentParams: ge.params,
+      nextUrl: P,
+      nextParams: ne.params
+    }, n, {
+      actionResult: L,
+      unstable_actionStatus: re,
+      defaultShouldRevalidate: b ? !1 : (
+        // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+        f || _.pathname + _.search === P.pathname + P.search || // Search params affect all loaders
+        _.search !== P.search || la(ge, ne)
+      )
+    }));
+  }), q = [];
+  return l.forEach((W, ce) => {
+    if (u || !r.some((we) => we.route.id === W.routeId) || m.has(ce))
+      return;
+    let se = dt(O, W.path, F);
+    if (!se) {
+      q.push({
+        key: ce,
+        routeId: W.routeId,
+        path: W.path,
+        matches: null,
+        match: null,
+        controller: null
+      });
+      return;
+    }
+    let ge = t.fetchers.get(ce), ne = qt(se, W.path), X = !1;
+    v.has(ce) ? X = !1 : y.includes(ce) ? X = !0 : ge && ge.state !== "idle" && ge.data === void 0 ? X = f : X = Pn(ne, ee({
+      currentUrl: _,
+      currentParams: t.matches[t.matches.length - 1].params,
+      nextUrl: P,
+      nextParams: r[r.length - 1].params
+    }, n, {
+      actionResult: L,
+      unstable_actionStatus: re,
+      defaultShouldRevalidate: b ? !1 : f
+    })), X && q.push({
+      key: ce,
+      routeId: W.routeId,
+      path: W.path,
+      matches: se,
+      match: ne,
+      controller: new AbortController()
+    });
+  }), [oe, q];
+}
+function _i(e, t, r) {
+  let n = (
+    // [a] -> [a, b]
+    !t || // [a, b] -> [a, c]
+    r.route.id !== t.route.id
+  ), a = e[r.route.id] === void 0;
+  return n || a;
+}
+function la(e, t) {
+  let r = 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
+    r != null && r.endsWith("*") && e.params["*"] !== t.params["*"]
+  );
+}
+function Pn(e, t) {
+  if (e.route.shouldRevalidate) {
+    let r = e.route.shouldRevalidate(t);
+    if (typeof r == "boolean")
+      return r;
+  }
+  return t.defaultShouldRevalidate;
+}
+async function Fi(e, t, r, n, a, u, o, f) {
+  let c = [t, ...r.map((y) => y.route.id)].join("-");
+  try {
+    let y = o.get(c);
+    y || (y = e({
+      path: t,
+      matches: r,
+      patch: (m, l) => {
+        f.aborted || ua(m, l, n, a, u);
+      }
+    }), o.set(c, y)), y && Ii(y) && await y;
+  } finally {
+    o.delete(c);
+  }
+}
+function ua(e, t, r, n, a) {
+  if (e) {
+    var u;
+    let o = n[e];
+    U(o, "No route found to patch children into: routeId = " + e);
+    let f = Jt(t, a, [e, "patch", String(((u = o.children) == null ? void 0 : u.length) || "0")], n);
+    o.children ? o.children.push(...f) : o.children = f;
+  } else {
+    let o = Jt(t, a, ["patch", String(r.length || "0")], n);
+    r.push(...o);
+  }
+}
+async function On(e, t, r) {
+  if (!e.lazy)
+    return;
+  let n = await e.lazy();
+  if (!e.lazy)
+    return;
+  let a = r[e.id];
+  U(a, "No route found in manifest");
+  let u = {};
+  for (let o in n) {
+    let c = a[o] !== void 0 && // This property isn't static since it should always be updated based
+    // on the route updates
+    o !== "hasErrorBoundary";
+    fe(!c, 'Route "' + a.id + '" has a static property "' + o + '" defined but its lazy function is also returning a value for this property. ' + ('The lazy route property "' + o + '" will be ignored.')), !c && !ei.has(o) && (u[o] = n[o]);
+  }
+  Object.assign(a, u), Object.assign(a, ee({}, t(a), {
+    lazy: void 0
+  }));
+}
+function Ti(e) {
+  return Promise.all(e.matches.map((t) => t.resolve()));
+}
+async function Mi(e, t, r, n, a, u, o, f) {
+  let c = n.reduce((l, v) => l.add(v.route.id), /* @__PURE__ */ new Set()), y = /* @__PURE__ */ new Set(), m = await e({
+    matches: a.map((l) => {
+      let v = c.has(l.route.id);
+      return ee({}, l, {
+        shouldLoad: v,
+        resolve: (F) => (y.add(l.route.id), v ? Ni(t, r, l, u, o, F, f) : Promise.resolve({
+          type: J.data,
+          result: void 0
+        }))
+      });
+    }),
+    request: r,
+    params: a[0].params,
+    context: f
+  });
+  return a.forEach((l) => U(y.has(l.route.id), '`match.resolve()` was not called for route id "' + l.route.id + '". You must call `match.resolve()` on every match passed to `dataStrategy` to ensure all routes are properly loaded.')), m.filter((l, v) => c.has(a[v].route.id));
+}
+async function Ni(e, t, r, n, a, u, o) {
+  let f, c, y = (m) => {
+    let l, v = new Promise((C, L) => l = L);
+    c = () => l(), t.signal.addEventListener("abort", c);
+    let O = (C) => typeof m != "function" ? Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ('"' + e + '" [routeId: ' + r.route.id + "]"))) : m({
+      request: t,
+      params: r.params,
+      context: o
+    }, ...C !== void 0 ? [C] : []), F;
+    return u ? F = u((C) => O(C)) : F = (async () => {
+      try {
+        return {
+          type: "data",
+          result: await O()
+        };
+      } catch (C) {
+        return {
+          type: "error",
+          result: C
+        };
+      }
+    })(), Promise.race([F, v]);
+  };
+  try {
+    let m = r.route[e];
+    if (r.route.lazy)
+      if (m) {
+        let l, [v] = 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
+          y(m).catch((O) => {
+            l = O;
+          }),
+          On(r.route, a, n)
+        ]);
+        if (l !== void 0)
+          throw l;
+        f = v;
+      } else if (await On(r.route, a, n), m = r.route[e], m)
+        f = await y(m);
+      else if (e === "action") {
+        let l = new URL(t.url), v = l.pathname + l.search;
+        throw ve(405, {
+          method: t.method,
+          pathname: v,
+          routeId: r.route.id
+        });
+      } else
+        return {
+          type: J.data,
+          result: void 0
+        };
+    else if (m)
+      f = await y(m);
+    else {
+      let l = new URL(t.url), v = l.pathname + l.search;
+      throw ve(404, {
+        pathname: v
+      });
+    }
+    U(f.result !== void 0, "You defined " + (e === "action" ? "an action" : "a loader") + " for route " + ('"' + r.route.id + "\" but didn't return anything from your `" + e + "` ") + "function. Please return a value or `null`.");
+  } catch (m) {
+    return {
+      type: J.error,
+      result: m
+    };
+  } finally {
+    c && t.signal.removeEventListener("abort", c);
+  }
+  return f;
+}
+async function Li(e) {
+  let {
+    result: t,
+    type: r,
+    status: n
+  } = e;
+  if (da(t)) {
+    let o;
+    try {
+      let f = t.headers.get("Content-Type");
+      f && /\bapplication\/json\b/.test(f) ? t.body == null ? o = null : o = await t.json() : o = await t.text();
+    } catch (f) {
+      return {
+        type: J.error,
+        error: f
+      };
+    }
+    return r === J.error ? {
+      type: J.error,
+      error: new ia(t.status, t.statusText, o),
+      statusCode: t.status,
+      headers: t.headers
+    } : {
+      type: J.data,
+      data: o,
+      statusCode: t.status,
+      headers: t.headers
+    };
+  }
+  if (r === J.error)
+    return {
+      type: J.error,
+      error: t,
+      statusCode: wr(t) ? t.status : n
+    };
+  if (Bi(t)) {
+    var a, u;
+    return {
+      type: J.deferred,
+      deferredData: t,
+      statusCode: (a = t.init) == null ? void 0 : a.status,
+      headers: ((u = t.init) == null ? void 0 : u.headers) && new Headers(t.init.headers)
+    };
+  }
+  return {
+    type: J.data,
+    data: t,
+    statusCode: n
+  };
+}
+function ji(e, t, r, n, a, u) {
+  let o = e.headers.get("Location");
+  if (U(o, "Redirects returned/thrown from loaders/actions must have a Location header"), !ln.test(o)) {
+    let f = n.slice(0, n.findIndex((c) => c.route.id === r) + 1);
+    o = tn(new URL(t.url), f, a, !0, o, u), e.headers.set("Location", o);
+  }
+  return e;
+}
+function _n(e, t, r) {
+  if (ln.test(e)) {
+    let n = e, a = n.startsWith("//") ? new URL(t.protocol + n) : new URL(n), u = rr(a.pathname, r) != null;
+    if (a.origin === t.origin && u)
+      return a.pathname + a.search + a.hash;
+  }
+  return e;
+}
+function Ct(e, t, r, n) {
+  let a = e.createURL(ca(t)).toString(), u = {
+    signal: r
+  };
+  if (n && Fe(n.formMethod)) {
+    let {
+      formMethod: o,
+      formEncType: f
+    } = n;
+    u.method = o.toUpperCase(), f === "application/json" ? (u.headers = new Headers({
+      "Content-Type": f
+    }), u.body = JSON.stringify(n.json)) : f === "text/plain" ? u.body = n.text : f === "application/x-www-form-urlencoded" && n.formData ? u.body = rn(n.formData) : u.body = n.formData;
+  }
+  return new Request(a, u);
+}
+function rn(e) {
+  let t = new URLSearchParams();
+  for (let [r, n] of e.entries())
+    t.append(r, typeof n == "string" ? n : n.name);
+  return t;
+}
+function Fn(e) {
+  let t = new FormData();
+  for (let [r, n] of e.entries())
+    t.append(r, n);
+  return t;
+}
+function Ui(e, t, r, n, a, u) {
+  let o = {}, f = null, c, y = !1, m = {}, l = n && Re(n[1]) ? n[1].error : void 0;
+  return r.forEach((v, O) => {
+    let F = t[O].route.id;
+    if (U(!ht(v), "Cannot handle redirect results in processLoaderData"), Re(v)) {
+      let C = v.error;
+      l !== void 0 && (C = l, l = void 0), f = f || {};
+      {
+        let L = Yt(e, F);
+        f[L.route.id] == null && (f[L.route.id] = C);
+      }
+      o[F] = void 0, y || (y = !0, c = wr(v.error) ? v.error.status : 500), v.headers && (m[F] = v.headers);
+    } else
+      ft(v) ? (a.set(F, v.deferredData), o[F] = v.deferredData.data, v.statusCode != null && v.statusCode !== 200 && !y && (c = v.statusCode), v.headers && (m[F] = v.headers)) : (o[F] = v.data, v.statusCode && v.statusCode !== 200 && !y && (c = v.statusCode), v.headers && (m[F] = v.headers));
+  }), l !== void 0 && n && (f = {
+    [n[0]]: l
+  }, o[n[0]] = void 0), {
+    loaderData: o,
+    errors: f,
+    statusCode: c || 200,
+    loaderHeaders: m
+  };
+}
+function Tn(e, t, r, n, a, u, o, f) {
+  let {
+    loaderData: c,
+    errors: y
+  } = Ui(t, r, n, a, f);
+  for (let m = 0; m < u.length; m++) {
+    let {
+      key: l,
+      match: v,
+      controller: O
+    } = u[m];
+    U(o !== void 0 && o[m] !== void 0, "Did not find corresponding fetcher result");
+    let F = o[m];
+    if (!(O && O.signal.aborted))
+      if (Re(F)) {
+        let C = Yt(e.matches, v == null ? void 0 : v.route.id);
+        y && y[C.route.id] || (y = ee({}, y, {
+          [C.route.id]: F.error
+        })), e.fetchers.delete(l);
+      } else if (ht(F))
+        U(!1, "Unhandled fetcher revalidation redirect");
+      else if (ft(F))
+        U(!1, "Unhandled fetcher deferred data");
+      else {
+        let C = Ze(F.data);
+        e.fetchers.set(l, C);
+      }
+  }
+  return {
+    loaderData: c,
+    errors: y
+  };
+}
+function Mn(e, t, r, n) {
+  let a = ee({}, t);
+  for (let u of r) {
+    let o = u.route.id;
+    if (t.hasOwnProperty(o) ? t[o] !== void 0 && (a[o] = t[o]) : e[o] !== void 0 && u.route.loader && (a[o] = e[o]), n && n.hasOwnProperty(o))
+      break;
+  }
+  return a;
+}
+function Nn(e) {
+  return e ? Re(e[1]) ? {
+    // Clear out prior actionData on errors
+    actionData: {}
+  } : {
+    actionData: {
+      [e[0]]: e[1].data
+    }
+  } : {};
+}
+function Yt(e, t) {
+  return (t ? e.slice(0, e.findIndex((n) => n.route.id === t) + 1) : [...e]).reverse().find((n) => n.route.hasErrorBoundary === !0) || e[0];
+}
+function Ln(e) {
+  let t = e.length === 1 ? e[0] : e.find((r) => r.index || !r.path || r.path === "/") || {
+    id: "__shim-error-route__"
+  };
+  return {
+    matches: [{
+      params: {},
+      pathname: "",
+      pathnameBase: "",
+      route: t
+    }],
+    route: t
+  };
+}
+function ve(e, t) {
+  let {
+    pathname: r,
+    routeId: n,
+    method: a,
+    type: u,
+    message: o
+  } = t === void 0 ? {} : t, f = "Unknown Server Error", c = "Unknown @remix-run/router error";
+  return e === 400 ? (f = "Bad Request", u === "route-discovery" ? c = 'Unable to match URL "' + r + '" - the `children()` function for ' + ("route `" + n + "` threw the following error:\n" + o) : a && r && n ? c = "You made a " + a + ' request to "' + r + '" but ' + ('did not provide a `loader` for route "' + n + '", ') + "so there is no way to handle the request." : u === "defer-action" ? c = "defer() is not supported in actions" : u === "invalid-body" && (c = "Unable to encode submission body")) : e === 403 ? (f = "Forbidden", c = 'Route "' + n + '" does not match URL "' + r + '"') : e === 404 ? (f = "Not Found", c = 'No route matches URL "' + r + '"') : e === 405 && (f = "Method Not Allowed", a && r && n ? c = "You made a " + a.toUpperCase() + ' request to "' + r + '" but ' + ('did not provide an `action` for route "' + n + '", ') + "so there is no way to handle the request." : a && (c = 'Invalid request method "' + a.toUpperCase() + '"')), new ia(e || 500, f, new Error(c), !0);
+}
+function jn(e) {
+  for (let t = e.length - 1; t >= 0; t--) {
+    let r = e[t];
+    if (ht(r))
+      return {
+        result: r,
+        idx: t
+      };
+  }
+}
+function ca(e) {
+  let t = typeof e == "string" ? nt(e) : e;
+  return tr(ee({}, t, {
+    hash: ""
+  }));
+}
+function Ai(e, t) {
+  return e.pathname !== t.pathname || e.search !== t.search ? !1 : e.hash === "" ? t.hash !== "" : e.hash === t.hash ? !0 : t.hash !== "";
+}
+function Ii(e) {
+  return typeof e == "object" && e != null && "then" in e;
+}
+function ki(e) {
+  return da(e.result) && Si.has(e.result.status);
+}
+function ft(e) {
+  return e.type === J.deferred;
+}
+function Re(e) {
+  return e.type === J.error;
+}
+function ht(e) {
+  return (e && e.type) === J.redirect;
+}
+function Bi(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 da(e) {
+  return e != null && typeof e.status == "number" && typeof e.statusText == "string" && typeof e.headers == "object" && typeof e.body < "u";
+}
+function Vi(e) {
+  return wi.has(e.toLowerCase());
+}
+function Fe(e) {
+  return Ei.has(e.toLowerCase());
+}
+async function Un(e, t, r, n, a, u) {
+  for (let o = 0; o < r.length; o++) {
+    let f = r[o], c = t[o];
+    if (!c)
+      continue;
+    let y = e.find((l) => l.route.id === c.route.id), m = y != null && !la(y, c) && (u && u[c.route.id]) !== void 0;
+    if (ft(f) && (a || m)) {
+      let l = n[o];
+      U(l, "Expected an AbortSignal for revalidating fetcher deferred result"), await fa(f, l, a).then((v) => {
+        v && (r[o] = v || r[o]);
+      });
+    }
+  }
+}
+async function fa(e, t, r) {
+  if (r === void 0 && (r = !1), !await e.deferredData.resolveData(t)) {
+    if (r)
+      try {
+        return {
+          type: J.data,
+          data: e.deferredData.unwrappedData
+        };
+      } catch (a) {
+        return {
+          type: J.error,
+          error: a
+        };
+      }
+    return {
+      type: J.data,
+      data: e.deferredData.data
+    };
+  }
+}
+function un(e) {
+  return new URLSearchParams(e).getAll("index").some((t) => t === "");
+}
+function qt(e, t) {
+  let r = typeof t == "string" ? nt(t).search : t.search;
+  if (e[e.length - 1].route.index && un(r || ""))
+    return e[e.length - 1];
+  let n = aa(e);
+  return n[n.length - 1];
+}
+function An(e) {
+  let {
+    formMethod: t,
+    formAction: r,
+    formEncType: n,
+    text: a,
+    formData: u,
+    json: o
+  } = e;
+  if (!(!t || !r || !n)) {
+    if (a != null)
+      return {
+        formMethod: t,
+        formAction: r,
+        formEncType: n,
+        formData: void 0,
+        json: void 0,
+        text: a
+      };
+    if (u != null)
+      return {
+        formMethod: t,
+        formAction: r,
+        formEncType: n,
+        formData: u,
+        json: void 0,
+        text: void 0
+      };
+    if (o !== void 0)
+      return {
+        formMethod: t,
+        formAction: r,
+        formEncType: n,
+        formData: void 0,
+        json: o,
+        text: void 0
+      };
+  }
+}
+function Ar(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 Wi(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 Ht(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 zi(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 Ze(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 $i(e, t) {
+  try {
+    let r = e.sessionStorage.getItem(sa);
+    if (r) {
+      let n = JSON.parse(r);
+      for (let [a, u] of Object.entries(n || {}))
+        u && Array.isArray(u) && t.set(a, new Set(u || []));
+    }
+  } catch {
+  }
+}
+function Hi(e, t) {
+  if (t.size > 0) {
+    let r = {};
+    for (let [n, a] of t)
+      r[n] = [...a];
+    try {
+      e.sessionStorage.setItem(sa, JSON.stringify(r));
+    } catch (n) {
+      fe(!1, "Failed to save applied view transitions in sessionStorage (" + n + ").");
+    }
+  }
+}
+/**
+ * React Router v6.24.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 br() {
+  return br = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var r = arguments[t];
+      for (var n in r)
+        Object.prototype.hasOwnProperty.call(r, n) && (e[n] = r[n]);
+    }
+    return e;
+  }, br.apply(this, arguments);
+}
+const Sr = /* @__PURE__ */ D.createContext(null);
+process.env.NODE_ENV !== "production" && (Sr.displayName = "DataRouter");
+const ha = /* @__PURE__ */ D.createContext(null);
+process.env.NODE_ENV !== "production" && (ha.displayName = "DataRouterState");
+const Ki = /* @__PURE__ */ D.createContext(null);
+process.env.NODE_ENV !== "production" && (Ki.displayName = "Await");
+const at = /* @__PURE__ */ D.createContext(null);
+process.env.NODE_ENV !== "production" && (at.displayName = "Navigation");
+const Cr = /* @__PURE__ */ D.createContext(null);
+process.env.NODE_ENV !== "production" && (Cr.displayName = "Location");
+const Ae = /* @__PURE__ */ D.createContext({
+  outlet: null,
+  matches: [],
+  isDataRoute: !1
+});
+process.env.NODE_ENV !== "production" && (Ae.displayName = "Route");
+const cn = /* @__PURE__ */ D.createContext(null);
+process.env.NODE_ENV !== "production" && (cn.displayName = "RouteError");
+function Do(e, t) {
+  let {
+    relative: r
+  } = t === void 0 ? {} : t;
+  jt() || (process.env.NODE_ENV !== "production" ? U(
+    !1,
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useHref() may be used only in the context of a <Router> component."
+  ) : U(!1));
+  let {
+    basename: n,
+    navigator: a
+  } = D.useContext(at), {
+    hash: u,
+    pathname: o,
+    search: f
+  } = Gi(e, {
+    relative: r
+  }), c = o;
+  return n !== "/" && (c = o === "/" ? n : $e([n, o])), a.createHref({
+    pathname: c,
+    search: f,
+    hash: u
+  });
+}
+function jt() {
+  return D.useContext(Cr) != null;
+}
+function nr() {
+  return jt() || (process.env.NODE_ENV !== "production" ? U(
+    !1,
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useLocation() may be used only in the context of a <Router> component."
+  ) : U(!1)), D.useContext(Cr).location;
+}
+const pa = "You should call navigate() in a React.useEffect(), not when your component is first rendered.";
+function va(e) {
+  D.useContext(at).static || D.useLayoutEffect(e);
+}
+function qi() {
+  let {
+    isDataRoute: e
+  } = D.useContext(Ae);
+  return e ? so() : Yi();
+}
+function Yi() {
+  jt() || (process.env.NODE_ENV !== "production" ? U(
+    !1,
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useNavigate() may be used only in the context of a <Router> component."
+  ) : U(!1));
+  let e = D.useContext(Sr), {
+    basename: t,
+    future: r,
+    navigator: n
+  } = D.useContext(at), {
+    matches: a
+  } = D.useContext(Ae), {
+    pathname: u
+  } = nr(), o = JSON.stringify(Er(a, r.v7_relativeSplatPath)), f = D.useRef(!1);
+  return va(() => {
+    f.current = !0;
+  }), D.useCallback(function(y, m) {
+    if (m === void 0 && (m = {}), process.env.NODE_ENV !== "production" && fe(f.current, pa), !f.current) return;
+    if (typeof y == "number") {
+      n.go(y);
+      return;
+    }
+    let l = Rr(y, JSON.parse(o), u, m.relative === "path");
+    e == null && t !== "/" && (l.pathname = l.pathname === "/" ? t : $e([t, l.pathname])), (m.replace ? n.replace : n.push)(l, m.state, m);
+  }, [t, n, o, u, e]);
+}
+const Qi = /* @__PURE__ */ D.createContext(null);
+function Ji(e) {
+  let t = D.useContext(Ae).outlet;
+  return t && /* @__PURE__ */ D.createElement(Qi.Provider, {
+    value: e
+  }, t);
+}
+function Gi(e, t) {
+  let {
+    relative: r
+  } = t === void 0 ? {} : t, {
+    future: n
+  } = D.useContext(at), {
+    matches: a
+  } = D.useContext(Ae), {
+    pathname: u
+  } = nr(), o = JSON.stringify(Er(a, n.v7_relativeSplatPath));
+  return D.useMemo(() => Rr(e, JSON.parse(o), u, r === "path"), [e, o, u, r]);
+}
+function xo(e, t, r, n) {
+  jt() || (process.env.NODE_ENV !== "production" ? U(
+    !1,
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useRoutes() may be used only in the context of a <Router> component."
+  ) : U(!1));
+  let {
+    navigator: a
+  } = D.useContext(at), {
+    matches: u
+  } = D.useContext(Ae), o = u[u.length - 1], f = o ? o.params : {}, c = o ? o.pathname : "/", y = o ? o.pathnameBase : "/", m = o && o.route;
+  if (process.env.NODE_ENV !== "production") {
+    let _ = m && m.path || "";
+    ya(c, !m || _.endsWith("*"), "You rendered descendant <Routes> (or called `useRoutes()`) at " + ('"' + c + '" (under <Route path="' + _ + '">) but the ') + `parent route path has no trailing "*". This means if you navigate deeper, the parent won't match anymore and therefore the child routes will never render.
+
+` + ('Please change the parent <Route path="' + _ + '"> to <Route ') + ('path="' + (_ === "/" ? "*" : _ + "/*") + '">.'));
+  }
+  let l = nr(), v;
+  v = l;
+  let O = v.pathname || "/", F = O;
+  if (y !== "/") {
+    let _ = y.replace(/^\//, "").split("/");
+    F = "/" + O.replace(/^\//, "").split("/").slice(_.length).join("/");
+  }
+  let C = dt(e, {
+    pathname: F
+  });
+  return process.env.NODE_ENV !== "production" && (process.env.NODE_ENV !== "production" && fe(m || C != null, 'No routes matched location "' + v.pathname + v.search + v.hash + '" '), process.env.NODE_ENV !== "production" && fe(C == null || C[C.length - 1].route.element !== void 0 || C[C.length - 1].route.Component !== void 0 || C[C.length - 1].route.lazy !== void 0, 'Matched leaf route at location "' + v.pathname + v.search + v.hash + '" does not have an element or Component. This means it will render an <Outlet /> with a null value by default resulting in an "empty" page.')), ro(C && C.map((_) => Object.assign({}, _, {
+    params: Object.assign({}, f, _.params),
+    pathname: $e([
+      y,
+      // Re-encode pathnames that were decoded inside matchRoutes
+      a.encodeLocation ? a.encodeLocation(_.pathname).pathname : _.pathname
+    ]),
+    pathnameBase: _.pathnameBase === "/" ? y : $e([
+      y,
+      // Re-encode pathnames that were decoded inside matchRoutes
+      a.encodeLocation ? a.encodeLocation(_.pathnameBase).pathname : _.pathnameBase
+    ])
+  })), u, r, n);
+}
+function Xi() {
+  let e = oo(), t = wr(e) ? e.status + " " + e.statusText : e instanceof Error ? e.message : JSON.stringify(e), r = e instanceof Error ? e.stack : null, n = "rgba(200,200,200, 0.5)", a = {
+    padding: "0.5rem",
+    backgroundColor: n
+  }, u = {
+    padding: "2px 4px",
+    backgroundColor: n
+  }, o = null;
+  return process.env.NODE_ENV !== "production" && (console.error("Error handled by React Router default ErrorBoundary:", e), o = /* @__PURE__ */ D.createElement(D.Fragment, null, /* @__PURE__ */ D.createElement("p", null, "💿 Hey developer 👋"), /* @__PURE__ */ D.createElement("p", null, "You can provide a way better UX than this when your app throws errors by providing your own ", /* @__PURE__ */ D.createElement("code", {
+    style: u
+  }, "ErrorBoundary"), " or", " ", /* @__PURE__ */ D.createElement("code", {
+    style: u
+  }, "errorElement"), " prop on your route."))), /* @__PURE__ */ D.createElement(D.Fragment, null, /* @__PURE__ */ D.createElement("h2", null, "Unexpected Application Error!"), /* @__PURE__ */ D.createElement("h3", {
+    style: {
+      fontStyle: "italic"
+    }
+  }, t), r ? /* @__PURE__ */ D.createElement("pre", {
+    style: a
+  }, r) : null, o);
+}
+const Zi = /* @__PURE__ */ D.createElement(Xi, null);
+class eo extends D.Component {
+  constructor(t) {
+    super(t), this.state = {
+      location: t.location,
+      revalidation: t.revalidation,
+      error: t.error
+    };
+  }
+  static getDerivedStateFromError(t) {
+    return {
+      error: t
+    };
+  }
+  static getDerivedStateFromProps(t, r) {
+    return r.location !== t.location || r.revalidation !== "idle" && t.revalidation === "idle" ? {
+      error: t.error,
+      location: t.location,
+      revalidation: t.revalidation
+    } : {
+      error: t.error !== void 0 ? t.error : r.error,
+      location: r.location,
+      revalidation: t.revalidation || r.revalidation
+    };
+  }
+  componentDidCatch(t, r) {
+    console.error("React Router caught the following error during render", t, r);
+  }
+  render() {
+    return this.state.error !== void 0 ? /* @__PURE__ */ D.createElement(Ae.Provider, {
+      value: this.props.routeContext
+    }, /* @__PURE__ */ D.createElement(cn.Provider, {
+      value: this.state.error,
+      children: this.props.component
+    })) : this.props.children;
+  }
+}
+function to(e) {
+  let {
+    routeContext: t,
+    match: r,
+    children: n
+  } = e, a = D.useContext(Sr);
+  return a && a.static && a.staticContext && (r.route.errorElement || r.route.ErrorBoundary) && (a.staticContext._deepestRenderedBoundaryId = r.route.id), /* @__PURE__ */ D.createElement(Ae.Provider, {
+    value: t
+  }, n);
+}
+function ro(e, t, r, n) {
+  var a;
+  if (t === void 0 && (t = []), r === void 0 && (r = null), n === void 0 && (n = null), e == null) {
+    var u;
+    if ((u = r) != null && u.errors)
+      e = r.matches;
+    else
+      return null;
+  }
+  let o = e, f = (a = r) == null ? void 0 : a.errors;
+  if (f != null) {
+    let m = o.findIndex((l) => l.route.id && (f == null ? void 0 : f[l.route.id]) !== void 0);
+    m >= 0 || (process.env.NODE_ENV !== "production" ? U(!1, "Could not find a matching route for errors on route IDs: " + Object.keys(f).join(",")) : U(!1)), o = o.slice(0, Math.min(o.length, m + 1));
+  }
+  let c = !1, y = -1;
+  if (r && n && n.v7_partialHydration)
+    for (let m = 0; m < o.length; m++) {
+      let l = o[m];
+      if ((l.route.HydrateFallback || l.route.hydrateFallbackElement) && (y = m), l.route.id) {
+        let {
+          loaderData: v,
+          errors: O
+        } = r, F = l.route.loader && v[l.route.id] === void 0 && (!O || O[l.route.id] === void 0);
+        if (l.route.lazy || F) {
+          c = !0, y >= 0 ? o = o.slice(0, y + 1) : o = [o[0]];
+          break;
+        }
+      }
+    }
+  return o.reduceRight((m, l, v) => {
+    let O, F = !1, C = null, L = null;
+    r && (O = f && l.route.id ? f[l.route.id] : void 0, C = l.route.errorElement || Zi, c && (y < 0 && v === 0 ? (ya("route-fallback", !1, "No `HydrateFallback` element provided to render during initial hydration"), F = !0, L = null) : y === v && (F = !0, L = l.route.hydrateFallbackElement || null)));
+    let _ = t.concat(o.slice(0, v + 1)), P = () => {
+      let $;
+      return O ? $ = C : F ? $ = L : l.route.Component ? $ = /* @__PURE__ */ D.createElement(l.route.Component, null) : l.route.element ? $ = l.route.element : $ = m, /* @__PURE__ */ D.createElement(to, {
+        match: l,
+        routeContext: {
+          outlet: m,
+          matches: _,
+          isDataRoute: r != null
+        },
+        children: $
+      });
+    };
+    return r && (l.route.ErrorBoundary || l.route.errorElement || v === 0) ? /* @__PURE__ */ D.createElement(eo, {
+      location: r.location,
+      revalidation: r.revalidation,
+      component: C,
+      error: O,
+      children: P(),
+      routeContext: {
+        outlet: null,
+        matches: _,
+        isDataRoute: !0
+      }
+    }) : P();
+  }, null);
+}
+var ma = /* @__PURE__ */ function(e) {
+  return e.UseBlocker = "useBlocker", e.UseRevalidator = "useRevalidator", e.UseNavigateStable = "useNavigate", e;
+}(ma || {}), Gt = /* @__PURE__ */ function(e) {
+  return e.UseBlocker = "useBlocker", e.UseLoaderData = "useLoaderData", e.UseActionData = "useActionData", e.UseRouteError = "useRouteError", e.UseNavigation = "useNavigation", e.UseRouteLoaderData = "useRouteLoaderData", e.UseMatches = "useMatches", e.UseRevalidator = "useRevalidator", e.UseNavigateStable = "useNavigate", e.UseRouteId = "useRouteId", e;
+}(Gt || {});
+function dn(e) {
+  return e + " must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.";
+}
+function no(e) {
+  let t = D.useContext(Sr);
+  return t || (process.env.NODE_ENV !== "production" ? U(!1, dn(e)) : U(!1)), t;
+}
+function ao(e) {
+  let t = D.useContext(ha);
+  return t || (process.env.NODE_ENV !== "production" ? U(!1, dn(e)) : U(!1)), t;
+}
+function io(e) {
+  let t = D.useContext(Ae);
+  return t || (process.env.NODE_ENV !== "production" ? U(!1, dn(e)) : U(!1)), t;
+}
+function fn(e) {
+  let t = io(e), r = t.matches[t.matches.length - 1];
+  return r.route.id || (process.env.NODE_ENV !== "production" ? U(!1, e + ' can only be used on routes that contain a unique "id"') : U(!1)), r.route.id;
+}
+function Po() {
+  return fn(Gt.UseRouteId);
+}
+function oo() {
+  var e;
+  let t = D.useContext(cn), r = ao(Gt.UseRouteError), n = fn(Gt.UseRouteError);
+  return t !== void 0 ? t : (e = r.errors) == null ? void 0 : e[n];
+}
+function so() {
+  let {
+    router: e
+  } = no(ma.UseNavigateStable), t = fn(Gt.UseNavigateStable), r = D.useRef(!1);
+  return va(() => {
+    r.current = !0;
+  }), D.useCallback(function(a, u) {
+    u === void 0 && (u = {}), process.env.NODE_ENV !== "production" && fe(r.current, pa), r.current && (typeof a == "number" ? e.navigate(a) : e.navigate(a, br({
+      fromRouteId: t
+    }, u)));
+  }, [e, t]);
+}
+const In = {};
+function ya(e, t, r) {
+  !t && !In[e] && (In[e] = !0, process.env.NODE_ENV !== "production" && fe(!1, r));
+}
+function Oo(e) {
+  let {
+    to: t,
+    replace: r,
+    state: n,
+    relative: a
+  } = e;
+  jt() || (process.env.NODE_ENV !== "production" ? U(
+    !1,
+    // TODO: This error is probably because they somehow have 2 versions of
+    // the router loaded. We can help them understand how to avoid that.
+    "<Navigate> may be used only in the context of a <Router> component."
+  ) : U(!1));
+  let {
+    future: u,
+    static: o
+  } = D.useContext(at);
+  process.env.NODE_ENV !== "production" && fe(!o, "<Navigate> must not be used on the initial render in a <StaticRouter>. This is a no-op, but you should modify your code so the <Navigate> is only ever rendered in response to some user interaction or state change.");
+  let {
+    matches: f
+  } = D.useContext(Ae), {
+    pathname: c
+  } = nr(), y = qi(), m = Rr(t, Er(f, u.v7_relativeSplatPath), c, a === "path"), l = JSON.stringify(m);
+  return D.useEffect(() => y(JSON.parse(l), {
+    replace: r,
+    state: n,
+    relative: a
+  }), [y, l, a, r, n]), null;
+}
+function _o(e) {
+  return Ji(e.context);
+}
+function Fo(e) {
+  let {
+    basename: t = "/",
+    children: r = null,
+    location: n,
+    navigationType: a = ie.Pop,
+    navigator: u,
+    static: o = !1,
+    future: f
+  } = e;
+  jt() && (process.env.NODE_ENV !== "production" ? U(!1, "You cannot render a <Router> inside another <Router>. You should never have more than one in your app.") : U(!1));
+  let c = t.replace(/^\/*/, "/"), y = D.useMemo(() => ({
+    basename: c,
+    navigator: u,
+    static: o,
+    future: br({
+      v7_relativeSplatPath: !1
+    }, f)
+  }), [c, f, u, o]);
+  typeof n == "string" && (n = nt(n));
+  let {
+    pathname: m = "/",
+    search: l = "",
+    hash: v = "",
+    state: O = null,
+    key: F = "default"
+  } = n, C = D.useMemo(() => {
+    let L = rr(m, c);
+    return L == null ? null : {
+      location: {
+        pathname: L,
+        search: l,
+        hash: v,
+        state: O,
+        key: F
+      },
+      navigationType: a
+    };
+  }, [c, m, l, v, O, F, a]);
+  return process.env.NODE_ENV !== "production" && fe(C != null, '<Router basename="' + c + '"> is not able to match the URL ' + ('"' + m + l + v + '" because it does not start with the ') + "basename, so the <Router> won't render anything."), C == null ? null : /* @__PURE__ */ D.createElement(at.Provider, {
+    value: y
+  }, /* @__PURE__ */ D.createElement(Cr.Provider, {
+    children: r,
+    value: C
+  }));
+}
+new Promise(() => {
+});
+function To(e) {
+  let t = {
+    // Note: this check also occurs in createRoutesFromChildren so update
+    // there if you change this -- please and thank you!
+    hasErrorBoundary: e.ErrorBoundary != null || e.errorElement != null
+  };
+  return e.Component && (process.env.NODE_ENV !== "production" && e.element && process.env.NODE_ENV !== "production" && fe(!1, "You should not include both `Component` and `element` on your route - `Component` will be used."), Object.assign(t, {
+    element: /* @__PURE__ */ D.createElement(e.Component),
+    Component: void 0
+  })), e.HydrateFallback && (process.env.NODE_ENV !== "production" && e.hydrateFallbackElement && process.env.NODE_ENV !== "production" && fe(!1, "You should not include both `HydrateFallback` and `hydrateFallbackElement` on your route - `HydrateFallback` will be used."), Object.assign(t, {
+    hydrateFallbackElement: /* @__PURE__ */ D.createElement(e.HydrateFallback),
+    HydrateFallback: void 0
+  })), e.ErrorBoundary && (process.env.NODE_ENV !== "production" && e.errorElement && process.env.NODE_ENV !== "production" && fe(!1, "You should not include both `ErrorBoundary` and `errorElement` on your route - `ErrorBoundary` will be used."), Object.assign(t, {
+    errorElement: /* @__PURE__ */ D.createElement(e.ErrorBoundary),
+    ErrorBoundary: void 0
+  })), t;
+}
+const ga = Ea(
+  void 0
+), Mo = ga.Provider, hn = () => {
+  const e = Ra(ga);
+  if (!e)
+    throw new Error("useDevPortal must be used within a DevPortalProvider.");
+  return e;
+}, No = () => {
+  const { getApiIdentities: e } = hn();
+  return ta({
+    queryFn: e,
+    queryKey: ["api-identities"]
+  });
+}, lo = () => {
+  const { navigation: e } = hn(), t = nr();
+  return e.find(
+    (r) => en({ path: r.path, end: !1 }, t.pathname)
+  );
+}, Lo = () => {
+  const { getNavigation: e } = hn(), t = lo(), r = (t == null ? void 0 : t.path) ?? "";
+  return ta({
+    queryFn: async () => ({
+      items: [...(t == null ? void 0 : t.categories) ?? [], ...await e(r)],
+      currentTopNavItem: t
+    }),
+    queryKey: ["navigation", r]
+  });
+};
+export {
+  So as $,
+  Ia as A,
+  wo as B,
+  za as C,
+  Mo as D,
+  qi as E,
+  ta as F,
+  po as G,
+  No as H,
+  en as I,
+  Ta as J,
+  at as K,
+  rr as L,
+  fe as M,
+  Oo as N,
+  _o as O,
+  Do as P,
+  Eo as Q,
+  Na as R,
+  nn as S,
+  Gi as T,
+  tr as U,
+  ha as V,
+  Po as W,
+  Ae as X,
+  U as Y,
+  $e as Z,
+  Co as _,
+  yo as a,
+  To as a0,
+  ia as a1,
+  Sr as a2,
+  Fo as a3,
+  xo as a4,
+  kr as b,
+  bo as c,
+  go as d,
+  Pa as e,
+  qn as f,
+  vo as g,
+  Da as h,
+  Vr as i,
+  ho as j,
+  Ca as k,
+  nr as l,
+  mo as m,
+  on as n,
+  Yn as o,
+  an as p,
+  lo as q,
+  yr as r,
+  Hr as s,
+  Lo as t,
+  hn as u,
+  Ro as v,
+  Ga as w,
+  ja as x,
+  fo as y,
+  Wr as z
+};