zudoku 0.3.0-dev.4 → 0.3.0-dev.41

package/lib/router-BkOLuJlq.js

@@ -0,0 +1,2973 @@
+/**
+ * @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 I() {
+  return I = Object.assign ? Object.assign.bind() : function(e) {
+    for (var t = 1; t < arguments.length; t++) {
+      var r = arguments[t];
+      for (var a in r)
+        Object.prototype.hasOwnProperty.call(r, a) && (e[a] = r[a]);
+    }
+    return e;
+  }, I.apply(this, arguments);
+}
+var V;
+(function(e) {
+  e.Pop = "POP", e.Push = "PUSH", e.Replace = "REPLACE";
+})(V || (V = {}));
+const _t = "popstate";
+function Br(e) {
+  e === void 0 && (e = {});
+  let {
+    initialEntries: t = ["/"],
+    initialIndex: r,
+    v5Compat: a = !1
+  } = e, n;
+  n = t.map((m, y) => b(m, typeof m == "string" ? null : m.state, y === 0 ? "default" : void 0));
+  let s = u(r ?? n.length - 1), l = V.Pop, f = null;
+  function u(m) {
+    return Math.min(Math.max(m, 0), n.length - 1);
+  }
+  function v() {
+    return n[s];
+  }
+  function b(m, y, g) {
+    y === void 0 && (y = null);
+    let P = ge(n ? v().pathname : "/", m, y, g);
+    return de(P.pathname.charAt(0) === "/", "relative pathnames are not supported in memory history: " + JSON.stringify(m)), P;
+  }
+  function p(m) {
+    return typeof m == "string" ? m : ue(m);
+  }
+  return {
+    get index() {
+      return s;
+    },
+    get action() {
+      return l;
+    },
+    get location() {
+      return v();
+    },
+    createHref: p,
+    createURL(m) {
+      return new URL(p(m), "http://localhost");
+    },
+    encodeLocation(m) {
+      let y = typeof m == "string" ? ie(m) : m;
+      return {
+        pathname: y.pathname || "",
+        search: y.search || "",
+        hash: y.hash || ""
+      };
+    },
+    push(m, y) {
+      l = V.Push;
+      let g = b(m, y);
+      s += 1, n.splice(s, n.length, g), a && f && f({
+        action: l,
+        location: g,
+        delta: 1
+      });
+    },
+    replace(m, y) {
+      l = V.Replace;
+      let g = b(m, y);
+      n[s] = g, a && f && f({
+        action: l,
+        location: g,
+        delta: 0
+      });
+    },
+    go(m) {
+      l = V.Pop;
+      let y = u(s + m), g = n[y];
+      s = y, f && f({
+        action: l,
+        location: g,
+        delta: m
+      });
+    },
+    listen(m) {
+      return f = m, () => {
+        f = null;
+      };
+    }
+  };
+}
+function Wr(e) {
+  e === void 0 && (e = {});
+  function t(a, n) {
+    let {
+      pathname: s,
+      search: l,
+      hash: f
+    } = a.location;
+    return ge(
+      "",
+      {
+        pathname: s,
+        search: l,
+        hash: f
+      },
+      // state defaults to `null` because `window.history.state` does
+      n.state && n.state.usr || null,
+      n.state && n.state.key || "default"
+    );
+  }
+  function r(a, n) {
+    return typeof n == "string" ? n : ue(n);
+  }
+  return Gt(t, r, null, e);
+}
+function Kr(e) {
+  e === void 0 && (e = {});
+  function t(n, s) {
+    let {
+      pathname: l = "/",
+      search: f = "",
+      hash: u = ""
+    } = ie(n.location.hash.substr(1));
+    return !l.startsWith("/") && !l.startsWith(".") && (l = "/" + l), ge(
+      "",
+      {
+        pathname: l,
+        search: f,
+        hash: u
+      },
+      // state defaults to `null` because `window.history.state` does
+      s.state && s.state.usr || null,
+      s.state && s.state.key || "default"
+    );
+  }
+  function r(n, s) {
+    let l = n.document.querySelector("base"), f = "";
+    if (l && l.getAttribute("href")) {
+      let u = n.location.href, v = u.indexOf("#");
+      f = v === -1 ? u : u.slice(0, v);
+    }
+    return f + "#" + (typeof s == "string" ? s : ue(s));
+  }
+  function a(n, s) {
+    de(n.pathname.charAt(0) === "/", "relative pathnames are not supported in hash history.push(" + JSON.stringify(s) + ")");
+  }
+  return Gt(t, r, a, e);
+}
+function O(e, t) {
+  if (e === !1 || e === null || typeof e > "u")
+    throw new Error(t);
+}
+function de(e, t) {
+  if (!e) {
+    typeof console < "u" && console.warn(t);
+    try {
+      throw new Error(t);
+    } catch {
+    }
+  }
+}
+function $r() {
+  return Math.random().toString(36).substr(2, 8);
+}
+function Ut(e, t) {
+  return {
+    usr: e.state,
+    key: e.key,
+    idx: t
+  };
+}
+function ge(e, t, r, a) {
+  return r === void 0 && (r = null), I({
+    pathname: typeof e == "string" ? e : e.pathname,
+    search: "",
+    hash: ""
+  }, typeof t == "string" ? ie(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 || a || $r()
+  });
+}
+function ue(e) {
+  let {
+    pathname: t = "/",
+    search: r = "",
+    hash: a = ""
+  } = e;
+  return r && r !== "?" && (t += r.charAt(0) === "?" ? r : "?" + r), a && a !== "#" && (t += a.charAt(0) === "#" ? a : "#" + a), t;
+}
+function ie(e) {
+  let t = {};
+  if (e) {
+    let r = e.indexOf("#");
+    r >= 0 && (t.hash = e.substr(r), e = e.substr(0, r));
+    let a = e.indexOf("?");
+    a >= 0 && (t.search = e.substr(a), e = e.substr(0, a)), e && (t.pathname = e);
+  }
+  return t;
+}
+function Gt(e, t, r, a) {
+  a === void 0 && (a = {});
+  let {
+    window: n = document.defaultView,
+    v5Compat: s = !1
+  } = a, l = n.history, f = V.Pop, u = null, v = b();
+  v == null && (v = 0, l.replaceState(I({}, l.state, {
+    idx: v
+  }), ""));
+  function b() {
+    return (l.state || {
+      idx: null
+    }).idx;
+  }
+  function p() {
+    f = V.Pop;
+    let P = b(), A = P == null ? null : P - v;
+    v = P, u && u({
+      action: f,
+      location: g.location,
+      delta: A
+    });
+  }
+  function S(P, A) {
+    f = V.Push;
+    let x = ge(g.location, P, A);
+    r && r(x, P), v = b() + 1;
+    let _ = Ut(x, v), R = g.createHref(x);
+    try {
+      l.pushState(_, "", R);
+    } catch (N) {
+      if (N instanceof DOMException && N.name === "DataCloneError")
+        throw N;
+      n.location.assign(R);
+    }
+    s && u && u({
+      action: f,
+      location: g.location,
+      delta: 1
+    });
+  }
+  function m(P, A) {
+    f = V.Replace;
+    let x = ge(g.location, P, A);
+    r && r(x, P), v = b();
+    let _ = Ut(x, v), R = g.createHref(x);
+    l.replaceState(_, "", R), s && u && u({
+      action: f,
+      location: g.location,
+      delta: 0
+    });
+  }
+  function y(P) {
+    let A = n.location.origin !== "null" ? n.location.origin : n.location.href, x = typeof P == "string" ? P : ue(P);
+    return x = x.replace(/ $/, "%20"), O(A, "No window.location.(origin|href) available to create URL for href: " + x), new URL(x, A);
+  }
+  let g = {
+    get action() {
+      return f;
+    },
+    get location() {
+      return e(n, l);
+    },
+    listen(P) {
+      if (u)
+        throw new Error("A history only accepts one active listener");
+      return n.addEventListener(_t, p), u = P, () => {
+        n.removeEventListener(_t, p), u = null;
+      };
+    },
+    createHref(P) {
+      return t(n, P);
+    },
+    createURL: y,
+    encodeLocation(P) {
+      let A = y(P);
+      return {
+        pathname: A.pathname,
+        search: A.search,
+        hash: A.hash
+      };
+    },
+    push: S,
+    replace: m,
+    go(P) {
+      return l.go(P);
+    }
+  };
+  return g;
+}
+var z;
+(function(e) {
+  e.data = "data", e.deferred = "deferred", e.redirect = "redirect", e.error = "error";
+})(z || (z = {}));
+const kr = /* @__PURE__ */ new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
+function Vr(e) {
+  return e.index === !0;
+}
+function Me(e, t, r, a) {
+  return r === void 0 && (r = []), a === void 0 && (a = {}), e.map((n, s) => {
+    let l = [...r, String(s)], f = typeof n.id == "string" ? n.id : l.join("-");
+    if (O(n.index !== !0 || !n.children, "Cannot specify children on an index route"), O(!a[f], 'Found a route id collision on id "' + f + `".  Route id's must be globally unique within Data Router usages`), Vr(n)) {
+      let u = I({}, n, t(n), {
+        id: f
+      });
+      return a[f] = u, u;
+    } else {
+      let u = I({}, n, t(n), {
+        id: f,
+        children: void 0
+      });
+      return a[f] = u, n.children && (u.children = Me(n.children, t, l, a)), u;
+    }
+  });
+}
+function me(e, t, r) {
+  return r === void 0 && (r = "/"), at(e, t, r, !1);
+}
+function at(e, t, r, a) {
+  let n = typeof t == "string" ? ie(t) : t, s = Ye(n.pathname || "/", r);
+  if (s == null)
+    return null;
+  let l = Qt(e);
+  Yr(l);
+  let f = null;
+  for (let u = 0; f == null && u < l.length; ++u) {
+    let v = oa(s);
+    f = ra(l[u], v, a);
+  }
+  return f;
+}
+function Xt(e, t) {
+  let {
+    route: r,
+    pathname: a,
+    params: n
+  } = e;
+  return {
+    id: r.id,
+    pathname: a,
+    params: n,
+    data: t[r.id],
+    handle: r.handle
+  };
+}
+function Qt(e, t, r, a) {
+  t === void 0 && (t = []), r === void 0 && (r = []), a === void 0 && (a = "");
+  let n = (s, l, f) => {
+    let u = {
+      relativePath: f === void 0 ? s.path || "" : f,
+      caseSensitive: s.caseSensitive === !0,
+      childrenIndex: l,
+      route: s
+    };
+    u.relativePath.startsWith("/") && (O(u.relativePath.startsWith(a), 'Absolute route path "' + u.relativePath + '" nested under path ' + ('"' + a + '" is not valid. An absolute child route path ') + "must start with the combined path of all its parent routes."), u.relativePath = u.relativePath.slice(a.length));
+    let v = Ne([a, u.relativePath]), b = r.concat(u);
+    s.children && s.children.length > 0 && (O(
+      // Our types know better, but runtime JS may not!
+      // @ts-expect-error
+      s.index !== !0,
+      "Index routes must not have child routes. Please remove " + ('all child routes from route path "' + v + '".')
+    ), Qt(s.children, t, b, v)), !(s.path == null && !s.index) && t.push({
+      path: v,
+      score: ea(v, s.index),
+      routesMeta: b
+    });
+  };
+  return e.forEach((s, l) => {
+    var f;
+    if (s.path === "" || !((f = s.path) != null && f.includes("?")))
+      n(s, l);
+    else
+      for (let u of Zt(s.path))
+        n(s, l, u);
+  }), t;
+}
+function Zt(e) {
+  let t = e.split("/");
+  if (t.length === 0) return [];
+  let [r, ...a] = t, n = r.endsWith("?"), s = r.replace(/\?$/, "");
+  if (a.length === 0)
+    return n ? [s, ""] : [s];
+  let l = Zt(a.join("/")), f = [];
+  return f.push(...l.map((u) => u === "" ? s : [s, u].join("/"))), n && f.push(...l), f.map((u) => e.startsWith("/") && u === "" ? "/" : u);
+}
+function Yr(e) {
+  e.sort((t, r) => t.score !== r.score ? r.score - t.score : ta(t.routesMeta.map((a) => a.childrenIndex), r.routesMeta.map((a) => a.childrenIndex)));
+}
+const Jr = /^:[\w-]+$/, Gr = 3, Xr = 2, Qr = 1, Zr = 10, qr = -2, At = (e) => e === "*";
+function ea(e, t) {
+  let r = e.split("/"), a = r.length;
+  return r.some(At) && (a += qr), t && (a += Xr), r.filter((n) => !At(n)).reduce((n, s) => n + (Jr.test(s) ? Gr : s === "" ? Qr : Zr), a);
+}
+function ta(e, t) {
+  return e.length === t.length && e.slice(0, -1).every((a, n) => a === t[n]) ? (
+    // 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 ra(e, t, r) {
+  r === void 0 && (r = !1);
+  let {
+    routesMeta: a
+  } = e, n = {}, s = "/", l = [];
+  for (let f = 0; f < a.length; ++f) {
+    let u = a[f], v = f === a.length - 1, b = s === "/" ? t : t.slice(s.length) || "/", p = ht({
+      path: u.relativePath,
+      caseSensitive: u.caseSensitive,
+      end: v
+    }, b), S = u.route;
+    if (!p && v && r && !a[a.length - 1].route.index && (p = ht({
+      path: u.relativePath,
+      caseSensitive: u.caseSensitive,
+      end: !1
+    }, b)), !p)
+      return null;
+    Object.assign(n, p.params), l.push({
+      // TODO: Can this as be avoided?
+      params: n,
+      pathname: Ne([s, p.pathname]),
+      pathnameBase: ar(Ne([s, p.pathnameBase])),
+      route: S
+    }), p.pathnameBase !== "/" && (s = Ne([s, p.pathnameBase]));
+  }
+  return l;
+}
+function aa(e, t) {
+  t === void 0 && (t = {});
+  let r = e;
+  r.endsWith("*") && r !== "*" && !r.endsWith("/*") && (de(!1, 'Route path "' + r + '" will be treated as if it were ' + ('"' + r.replace(/\*$/, "/*") + '" because the `*` character must ') + "always follow a `/` in the pattern. To get rid of this warning, " + ('please change the route path to "' + r.replace(/\*$/, "/*") + '".')), r = r.replace(/\*$/, "/*"));
+  const a = r.startsWith("/") ? "/" : "", n = (l) => l == null ? "" : typeof l == "string" ? l : String(l), s = r.split(/\/+/).map((l, f, u) => {
+    if (f === u.length - 1 && l === "*")
+      return n(t["*"]);
+    const b = l.match(/^:([\w-]+)(\??)$/);
+    if (b) {
+      const [, p, S] = b;
+      let m = t[p];
+      return O(S === "?" || m != null, 'Missing ":' + p + '" param'), n(m);
+    }
+    return l.replace(/\?$/g, "");
+  }).filter((l) => !!l);
+  return a + s.join("/");
+}
+function ht(e, t) {
+  typeof e == "string" && (e = {
+    path: e,
+    caseSensitive: !1,
+    end: !0
+  });
+  let [r, a] = na(e.path, e.caseSensitive, e.end), n = t.match(r);
+  if (!n) return null;
+  let s = n[0], l = s.replace(/(.)\/+$/, "$1"), f = n.slice(1);
+  return {
+    params: a.reduce((v, b, p) => {
+      let {
+        paramName: S,
+        isOptional: m
+      } = b;
+      if (S === "*") {
+        let g = f[p] || "";
+        l = s.slice(0, s.length - g.length).replace(/(.)\/+$/, "$1");
+      }
+      const y = f[p];
+      return m && !y ? v[S] = void 0 : v[S] = (y || "").replace(/%2F/g, "/"), v;
+    }, {}),
+    pathname: s,
+    pathnameBase: l,
+    pattern: e
+  };
+}
+function na(e, t, r) {
+  t === void 0 && (t = !1), r === void 0 && (r = !0), de(e === "*" || !e.endsWith("*") || e.endsWith("/*"), 'Route path "' + e + '" will be treated as if it were ' + ('"' + e.replace(/\*$/, "/*") + '" because the `*` character must ') + "always follow a `/` in the pattern. To get rid of this warning, " + ('please change the route path to "' + e.replace(/\*$/, "/*") + '".'));
+  let a = [], n = "^" + e.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(/\/:([\w-]+)(\?)?/g, (l, f, u) => (a.push({
+    paramName: f,
+    isOptional: u != null
+  }), u ? "/?([^\\/]+)?" : "/([^\\/]+)"));
+  return e.endsWith("*") ? (a.push({
+    paramName: "*"
+  }), n += e === "*" || e === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$") : r ? n += "\\/*$" : e !== "" && e !== "/" && (n += "(?:(?=\\/|$))"), [new RegExp(n, t ? void 0 : "i"), a];
+}
+function oa(e) {
+  try {
+    return e.split("/").map((t) => decodeURIComponent(t).replace(/\//g, "%2F")).join("/");
+  } catch (t) {
+    return de(!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 Ye(e, t) {
+  if (t === "/") return e;
+  if (!e.toLowerCase().startsWith(t.toLowerCase()))
+    return null;
+  let r = t.endsWith("/") ? t.length - 1 : t.length, a = e.charAt(r);
+  return a && a !== "/" ? null : e.slice(r) || "/";
+}
+function qt(e, t) {
+  t === void 0 && (t = "/");
+  let {
+    pathname: r,
+    search: a = "",
+    hash: n = ""
+  } = typeof e == "string" ? ie(e) : e;
+  return {
+    pathname: r ? r.startsWith("/") ? r : ia(r, t) : t,
+    search: sa(a),
+    hash: da(n)
+  };
+}
+function ia(e, t) {
+  let r = t.replace(/\/+$/, "").split("/");
+  return e.split("/").forEach((n) => {
+    n === ".." ? r.length > 1 && r.pop() : n !== "." && r.push(n);
+  }), r.length > 1 ? r.join("/") : "/";
+}
+function ft(e, t, r, a) {
+  return "Cannot include a '" + e + "' character in a manually specified " + ("`to." + t + "` field [" + JSON.stringify(a) + "].  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 er(e) {
+  return e.filter((t, r) => r === 0 || t.route.path && t.route.path.length > 0);
+}
+function tr(e, t) {
+  let r = er(e);
+  return t ? r.map((a, n) => n === r.length - 1 ? a.pathname : a.pathnameBase) : r.map((a) => a.pathnameBase);
+}
+function rr(e, t, r, a) {
+  a === void 0 && (a = !1);
+  let n;
+  typeof e == "string" ? n = ie(e) : (n = I({}, e), O(!n.pathname || !n.pathname.includes("?"), ft("?", "pathname", "search", n)), O(!n.pathname || !n.pathname.includes("#"), ft("#", "pathname", "hash", n)), O(!n.search || !n.search.includes("#"), ft("#", "search", "hash", n)));
+  let s = e === "" || n.pathname === "", l = s ? "/" : n.pathname, f;
+  if (l == null)
+    f = r;
+  else {
+    let p = t.length - 1;
+    if (!a && l.startsWith("..")) {
+      let S = l.split("/");
+      for (; S[0] === ".."; )
+        S.shift(), p -= 1;
+      n.pathname = S.join("/");
+    }
+    f = p >= 0 ? t[p] : "/";
+  }
+  let u = qt(n, f), v = l && l !== "/" && l.endsWith("/"), b = (s || l === ".") && r.endsWith("/");
+  return !u.pathname.endsWith("/") && (v || b) && (u.pathname += "/"), u;
+}
+function la(e) {
+  return e === "" || e.pathname === "" ? "/" : typeof e == "string" ? ie(e).pathname : e.pathname;
+}
+const Ne = (e) => e.join("/").replace(/\/\/+/g, "/"), ar = (e) => e.replace(/\/+$/, "").replace(/^\/*/, "/"), sa = (e) => !e || e === "?" ? "" : e.startsWith("?") ? e : "?" + e, da = (e) => !e || e === "#" ? "" : e.startsWith("#") ? e : "#" + e, ua = function(t, r) {
+  r === void 0 && (r = {});
+  let a = typeof r == "number" ? {
+    status: r
+  } : r, n = new Headers(a.headers);
+  return n.has("Content-Type") || n.set("Content-Type", "application/json; charset=utf-8"), new Response(JSON.stringify(t), I({}, a, {
+    headers: n
+  }));
+};
+class pt extends Error {
+}
+class nr {
+  constructor(t, r) {
+    this.pendingKeysSet = /* @__PURE__ */ new Set(), this.subscribers = /* @__PURE__ */ new Set(), this.deferredKeys = [], O(t && typeof t == "object" && !Array.isArray(t), "defer() only accepts plain objects");
+    let a;
+    this.abortPromise = new Promise((s, l) => a = l), this.controller = new AbortController();
+    let n = () => a(new pt("Deferred data aborted"));
+    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener("abort", n), this.controller.signal.addEventListener("abort", n), this.data = Object.entries(t).reduce((s, l) => {
+      let [f, u] = l;
+      return Object.assign(s, {
+        [f]: this.trackPromise(f, u)
+      });
+    }, {}), this.done && this.unlistenAbortSignal(), this.init = r;
+  }
+  trackPromise(t, r) {
+    if (!(r instanceof Promise))
+      return r;
+    this.deferredKeys.push(t), this.pendingKeysSet.add(t);
+    let a = Promise.race([r, this.abortPromise]).then((n) => this.onSettle(a, t, void 0, n), (n) => this.onSettle(a, t, n));
+    return a.catch(() => {
+    }), Object.defineProperty(a, "_tracked", {
+      get: () => !0
+    }), a;
+  }
+  onSettle(t, r, a, n) {
+    if (this.controller.signal.aborted && a instanceof pt)
+      return this.unlistenAbortSignal(), Object.defineProperty(t, "_error", {
+        get: () => a
+      }), Promise.reject(a);
+    if (this.pendingKeysSet.delete(r), this.done && this.unlistenAbortSignal(), a === void 0 && n === void 0) {
+      let s = new Error('Deferred data for key "' + r + '" resolved/rejected with `undefined`, you must resolve/reject with a value or `null`.');
+      return Object.defineProperty(t, "_error", {
+        get: () => s
+      }), this.emit(!1, r), Promise.reject(s);
+    }
+    return n === void 0 ? (Object.defineProperty(t, "_error", {
+      get: () => a
+    }), this.emit(!1, r), Promise.reject(a)) : (Object.defineProperty(t, "_data", {
+      get: () => n
+    }), this.emit(!1, r), n);
+  }
+  emit(t, r) {
+    this.subscribers.forEach((a) => a(t, r));
+  }
+  subscribe(t) {
+    return this.subscribers.add(t), () => this.subscribers.delete(t);
+  }
+  cancel() {
+    this.controller.abort(), this.pendingKeysSet.forEach((t, r) => this.pendingKeysSet.delete(r)), this.emit(!0);
+  }
+  async resolveData(t) {
+    let r = !1;
+    if (!this.done) {
+      let a = () => this.cancel();
+      t.addEventListener("abort", a), r = await new Promise((n) => {
+        this.subscribe((s) => {
+          t.removeEventListener("abort", a), (s || this.done) && n(s);
+        });
+      });
+    }
+    return r;
+  }
+  get done() {
+    return this.pendingKeysSet.size === 0;
+  }
+  get unwrappedData() {
+    return O(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds"), Object.entries(this.data).reduce((t, r) => {
+      let [a, n] = r;
+      return Object.assign(t, {
+        [a]: ca(n)
+      });
+    }, {});
+  }
+  get pendingKeys() {
+    return Array.from(this.pendingKeysSet);
+  }
+}
+function fa(e) {
+  return e instanceof Promise && e._tracked === !0;
+}
+function ca(e) {
+  if (!fa(e))
+    return e;
+  if (e._error)
+    throw e._error;
+  return e._data;
+}
+const ha = function(t, r) {
+  r === void 0 && (r = {});
+  let a = typeof r == "number" ? {
+    status: r
+  } : r;
+  return new nr(t, a);
+}, or = function(t, r) {
+  r === void 0 && (r = 302);
+  let a = r;
+  typeof a == "number" ? a = {
+    status: a
+  } : typeof a.status > "u" && (a.status = 302);
+  let n = new Headers(a.headers);
+  return n.set("Location", t), new Response(null, I({}, a, {
+    headers: n
+  }));
+}, pa = (e, t) => {
+  let r = or(e, t);
+  return r.headers.set("X-Remix-Reload-Document", "true"), r;
+};
+class vt {
+  constructor(t, r, a, n) {
+    n === void 0 && (n = !1), this.status = t, this.statusText = r || "", this.internal = n, a instanceof Error ? (this.data = a.toString(), this.error = a) : this.data = a;
+  }
+}
+function ze(e) {
+  return e != null && typeof e.status == "number" && typeof e.statusText == "string" && typeof e.internal == "boolean" && "data" in e;
+}
+const ir = ["post", "put", "patch", "delete"], ma = new Set(ir), ga = ["get", ...ir], ya = new Set(ga), va = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]), wa = /* @__PURE__ */ new Set([307, 308]), nt = {
+  state: "idle",
+  location: void 0,
+  formMethod: void 0,
+  formAction: void 0,
+  formEncType: void 0,
+  formData: void 0,
+  json: void 0,
+  text: void 0
+}, lr = {
+  state: "idle",
+  data: void 0,
+  formMethod: void 0,
+  formAction: void 0,
+  formEncType: void 0,
+  formData: void 0,
+  json: void 0,
+  text: void 0
+}, Ie = {
+  state: "unblocked",
+  proceed: void 0,
+  reset: void 0,
+  location: void 0
+}, wt = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i, sr = (e) => ({
+  hasErrorBoundary: !!e.hasErrorBoundary
+}), dr = "remix-router-transitions";
+function ba(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", a = !r;
+  O(e.routes.length > 0, "You must provide a non-empty routes array to createRouter");
+  let n;
+  if (e.mapRouteProperties)
+    n = e.mapRouteProperties;
+  else if (e.detectErrorBoundary) {
+    let o = e.detectErrorBoundary;
+    n = (i) => ({
+      hasErrorBoundary: o(i)
+    });
+  } else
+    n = sr;
+  let s = {}, l = Me(e.routes, n, void 0, s), f, u = e.basename || "/", v = e.unstable_dataStrategy || pr, b = e.unstable_patchRoutesOnMiss, p = I({
+    v7_fetcherPersist: !1,
+    v7_normalizeFormMethod: !1,
+    v7_partialHydration: !1,
+    v7_prependBasename: !1,
+    v7_relativeSplatPath: !1,
+    unstable_skipActionErrorRevalidation: !1
+  }, e.future), S = null, m = /* @__PURE__ */ new Set(), y = null, g = null, P = null, A = e.hydrationData != null, x = me(l, e.history.location, u), _ = null;
+  if (x == null && !b) {
+    let o = Y(404, {
+      pathname: e.history.location.pathname
+    }), {
+      matches: i,
+      route: d
+    } = ot(l);
+    x = i, _ = {
+      [d.id]: o
+    };
+  }
+  x && b && ut(x, l, e.history.location.pathname).active && (x = null);
+  let R;
+  if (!x)
+    R = !1, x = [];
+  else if (x.some((o) => o.route.lazy))
+    R = !1;
+  else if (!x.some((o) => o.route.loader))
+    R = !0;
+  else if (p.v7_partialHydration) {
+    let o = e.hydrationData ? e.hydrationData.loaderData : null, i = e.hydrationData ? e.hydrationData.errors : null, d = (h) => h.route.loader ? typeof h.route.loader == "function" && h.route.loader.hydrate === !0 ? !1 : o && o[h.route.id] !== void 0 || i && i[h.route.id] !== void 0 : !0;
+    if (i) {
+      let h = x.findIndex((D) => i[D.route.id] !== void 0);
+      R = x.slice(0, h + 1).every(d);
+    } else
+      R = x.every(d);
+  } else
+    R = e.hydrationData != null;
+  let N, c = {
+    historyAction: e.history.action,
+    location: e.history.location,
+    matches: x,
+    initialized: R,
+    navigation: nt,
+    // 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()
+  }, C = V.Pop, J = !1, F, X = !1, K = /* @__PURE__ */ new Map(), ne = null, le = !1, te = !1, je = [], Je = [], Q = /* @__PURE__ */ new Map(), Ge = 0, Be = -1, Ce = /* @__PURE__ */ new Map(), fe = /* @__PURE__ */ new Set(), Te = /* @__PURE__ */ new Map(), We = /* @__PURE__ */ new Map(), ce = /* @__PURE__ */ new Set(), Ee = /* @__PURE__ */ new Map(), Pe = /* @__PURE__ */ new Map(), Dr = /* @__PURE__ */ new Map(), it = !1;
+  function Er() {
+    if (S = e.history.listen((o) => {
+      let {
+        action: i,
+        location: d,
+        delta: h
+      } = o;
+      if (it) {
+        it = !1;
+        return;
+      }
+      de(Pe.size === 0 || h != 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 D = jt({
+        currentLocation: c.location,
+        nextLocation: d,
+        historyAction: i
+      });
+      if (D && h != null) {
+        it = !0, e.history.go(h * -1), Qe(D, {
+          state: "blocked",
+          location: d,
+          proceed() {
+            Qe(D, {
+              state: "proceeding",
+              proceed: void 0,
+              reset: void 0,
+              location: d
+            }), e.history.go(h);
+          },
+          reset() {
+            let E = new Map(c.blockers);
+            E.set(D, Ie), re({
+              blockers: E
+            });
+          }
+        });
+        return;
+      }
+      return xe(i, d);
+    }), r) {
+      _a(t, K);
+      let o = () => Ua(t, K);
+      t.addEventListener("pagehide", o), ne = () => t.removeEventListener("pagehide", o);
+    }
+    return c.initialized || xe(V.Pop, c.location, {
+      initialHydration: !0
+    }), N;
+  }
+  function Pr() {
+    S && S(), ne && ne(), m.clear(), F && F.abort(), c.fetchers.forEach((o, i) => Xe(i)), c.blockers.forEach((o, i) => Mt(i));
+  }
+  function xr(o) {
+    return m.add(o), () => m.delete(o);
+  }
+  function re(o, i) {
+    i === void 0 && (i = {}), c = I({}, c, o);
+    let d = [], h = [];
+    p.v7_fetcherPersist && c.fetchers.forEach((D, E) => {
+      D.state === "idle" && (ce.has(E) ? h.push(E) : d.push(E));
+    }), [...m].forEach((D) => D(c, {
+      deletedFetchers: h,
+      unstable_viewTransitionOpts: i.viewTransitionOpts,
+      unstable_flushSync: i.flushSync === !0
+    })), p.v7_fetcherPersist && (d.forEach((D) => c.fetchers.delete(D)), h.forEach((D) => Xe(D)));
+  }
+  function Fe(o, i, d) {
+    var h, D;
+    let {
+      flushSync: E
+    } = d === void 0 ? {} : d, j = c.actionData != null && c.navigation.formMethod != null && oe(c.navigation.formMethod) && c.navigation.state === "loading" && ((h = o.state) == null ? void 0 : h._isRedirect) !== !0, w;
+    i.actionData ? Object.keys(i.actionData).length > 0 ? w = i.actionData : w = null : j ? w = c.actionData : w = null;
+    let T = i.loaderData ? $t(c.loaderData, i.loaderData, i.matches || [], i.errors) : c.loaderData, L = c.blockers;
+    L.size > 0 && (L = new Map(L), L.forEach((H, $) => L.set($, Ie)));
+    let M = J === !0 || c.navigation.formMethod != null && oe(c.navigation.formMethod) && ((D = o.state) == null ? void 0 : D._isRedirect) !== !0;
+    f && (l = f, f = void 0), le || C === V.Pop || (C === V.Push ? e.history.push(o, o.state) : C === V.Replace && e.history.replace(o, o.state));
+    let W;
+    if (C === V.Pop) {
+      let H = K.get(c.location.pathname);
+      H && H.has(o.pathname) ? W = {
+        currentLocation: c.location,
+        nextLocation: o
+      } : K.has(o.pathname) && (W = {
+        currentLocation: o,
+        nextLocation: c.location
+      });
+    } else if (X) {
+      let H = K.get(c.location.pathname);
+      H ? H.add(o.pathname) : (H = /* @__PURE__ */ new Set([o.pathname]), K.set(c.location.pathname, H)), W = {
+        currentLocation: c.location,
+        nextLocation: o
+      };
+    }
+    re(I({}, i, {
+      actionData: w,
+      loaderData: T,
+      historyAction: C,
+      location: o,
+      initialized: !0,
+      navigation: nt,
+      revalidation: "idle",
+      restoreScrollPosition: Tt(o, i.matches || c.matches),
+      preventScrollReset: M,
+      blockers: L
+    }), {
+      viewTransitionOpts: W,
+      flushSync: E === !0
+    }), C = V.Pop, J = !1, X = !1, le = !1, te = !1, je = [], Je = [];
+  }
+  async function St(o, i) {
+    if (typeof o == "number") {
+      e.history.go(o);
+      return;
+    }
+    let d = mt(c.location, c.matches, u, p.v7_prependBasename, o, p.v7_relativeSplatPath, i == null ? void 0 : i.fromRouteId, i == null ? void 0 : i.relative), {
+      path: h,
+      submission: D,
+      error: E
+    } = It(p.v7_normalizeFormMethod, !1, d, i), j = c.location, w = ge(c.location, h, i && i.state);
+    w = I({}, w, e.history.encodeLocation(w));
+    let T = i && i.replace != null ? i.replace : void 0, L = V.Push;
+    T === !0 ? L = V.Replace : T === !1 || D != null && oe(D.formMethod) && D.formAction === c.location.pathname + c.location.search && (L = V.Replace);
+    let M = i && "preventScrollReset" in i ? i.preventScrollReset === !0 : void 0, W = (i && i.unstable_flushSync) === !0, H = jt({
+      currentLocation: j,
+      nextLocation: w,
+      historyAction: L
+    });
+    if (H) {
+      Qe(H, {
+        state: "blocked",
+        location: w,
+        proceed() {
+          Qe(H, {
+            state: "proceeding",
+            proceed: void 0,
+            reset: void 0,
+            location: w
+          }), St(o, i);
+        },
+        reset() {
+          let $ = new Map(c.blockers);
+          $.set(H, Ie), re({
+            blockers: $
+          });
+        }
+      });
+      return;
+    }
+    return await xe(L, w, {
+      submission: D,
+      // Send through the formData serialization error if we have one so we can
+      // render at the right error boundary after we match routes
+      pendingError: E,
+      preventScrollReset: M,
+      replace: i && i.replace,
+      enableViewTransition: i && i.unstable_viewTransition,
+      flushSync: W
+    });
+  }
+  function Lr() {
+    if (lt(), re({
+      revalidation: "loading"
+    }), c.navigation.state !== "submitting") {
+      if (c.navigation.state === "idle") {
+        xe(c.historyAction, c.location, {
+          startUninterruptedRevalidation: !0
+        });
+        return;
+      }
+      xe(C || c.historyAction, c.navigation.location, {
+        overrideNavigation: c.navigation
+      });
+    }
+  }
+  async function xe(o, i, d) {
+    F && F.abort(), F = null, C = o, le = (d && d.startUninterruptedRevalidation) === !0, Ir(c.location, c.matches), J = (d && d.preventScrollReset) === !0, X = (d && d.enableViewTransition) === !0;
+    let h = f || l, D = d && d.overrideNavigation, E = me(h, i, u), j = (d && d.flushSync) === !0, w = ut(E, h, i.pathname);
+    if (w.active && w.matches && (E = w.matches), !E) {
+      let {
+        error: B,
+        notFoundMatches: q,
+        route: Z
+      } = st(i.pathname);
+      Fe(i, {
+        matches: q,
+        loaderData: {},
+        errors: {
+          [Z.id]: B
+        }
+      }, {
+        flushSync: j
+      });
+      return;
+    }
+    if (c.initialized && !te && La(c.location, i) && !(d && d.submission && oe(d.submission.formMethod))) {
+      Fe(i, {
+        matches: E
+      }, {
+        flushSync: j
+      });
+      return;
+    }
+    F = new AbortController();
+    let T = Oe(e.history, i, F.signal, d && d.submission), L;
+    if (d && d.pendingError)
+      L = [He(E).route.id, {
+        type: z.error,
+        error: d.pendingError
+      }];
+    else if (d && d.submission && oe(d.submission.formMethod)) {
+      let B = await Mr(T, i, d.submission, E, w.active, {
+        replace: d.replace,
+        flushSync: j
+      });
+      if (B.shortCircuited)
+        return;
+      if (B.pendingActionResult) {
+        let [q, Z] = B.pendingActionResult;
+        if (ee(Z) && ze(Z.error) && Z.error.status === 404) {
+          F = null, Fe(i, {
+            matches: B.matches,
+            loaderData: {},
+            errors: {
+              [q]: Z.error
+            }
+          });
+          return;
+        }
+      }
+      E = B.matches || E, L = B.pendingActionResult, D = ct(i, d.submission), j = !1, w.active = !1, T = Oe(e.history, T.url, T.signal);
+    }
+    let {
+      shortCircuited: M,
+      matches: W,
+      loaderData: H,
+      errors: $
+    } = await jr(T, i, E, w.active, D, d && d.submission, d && d.fetcherSubmission, d && d.replace, d && d.initialHydration === !0, j, L);
+    M || (F = null, Fe(i, I({
+      matches: W || E
+    }, kt(L), {
+      loaderData: H,
+      errors: $
+    })));
+  }
+  async function Mr(o, i, d, h, D, E) {
+    E === void 0 && (E = {}), lt();
+    let j = Ta(i, d);
+    if (re({
+      navigation: j
+    }, {
+      flushSync: E.flushSync === !0
+    }), D) {
+      let L = await qe(h, i.pathname, o.signal);
+      if (L.type === "aborted")
+        return {
+          shortCircuited: !0
+        };
+      if (L.type === "error") {
+        let {
+          error: M,
+          notFoundMatches: W,
+          route: H
+        } = Ze(i.pathname, L);
+        return {
+          matches: W,
+          pendingActionResult: [H.id, {
+            type: z.error,
+            error: M
+          }]
+        };
+      } else if (L.matches)
+        h = L.matches;
+      else {
+        let {
+          notFoundMatches: M,
+          error: W,
+          route: H
+        } = st(i.pathname);
+        return {
+          matches: M,
+          pendingActionResult: [H.id, {
+            type: z.error,
+            error: W
+          }]
+        };
+      }
+    }
+    let w, T = Le(h, i);
+    if (!T.route.action && !T.route.lazy)
+      w = {
+        type: z.error,
+        error: Y(405, {
+          method: o.method,
+          pathname: i.pathname,
+          routeId: T.route.id
+        })
+      };
+    else if (w = (await $e("action", o, [T], h))[0], o.signal.aborted)
+      return {
+        shortCircuited: !0
+      };
+    if (De(w)) {
+      let L;
+      return E && E.replace != null ? L = E.replace : L = Bt(w.response.headers.get("Location"), new URL(o.url), u) === c.location.pathname + c.location.search, await Ke(o, w, {
+        submission: d,
+        replace: L
+      }), {
+        shortCircuited: !0
+      };
+    }
+    if (Re(w))
+      throw Y(400, {
+        type: "defer-action"
+      });
+    if (ee(w)) {
+      let L = He(h, T.route.id);
+      return (E && E.replace) !== !0 && (C = V.Push), {
+        matches: h,
+        pendingActionResult: [L.route.id, w]
+      };
+    }
+    return {
+      matches: h,
+      pendingActionResult: [T.route.id, w]
+    };
+  }
+  async function jr(o, i, d, h, D, E, j, w, T, L, M) {
+    let W = D || ct(i, E), H = E || j || Jt(W), $ = !le && (!p.v7_partialHydration || !T);
+    if (h) {
+      if ($) {
+        let G = Rt(M);
+        re(I({
+          navigation: W
+        }, G !== void 0 ? {
+          actionData: G
+        } : {}), {
+          flushSync: L
+        });
+      }
+      let U = await qe(d, i.pathname, o.signal);
+      if (U.type === "aborted")
+        return {
+          shortCircuited: !0
+        };
+      if (U.type === "error") {
+        let {
+          error: G,
+          notFoundMatches: ae,
+          route: k
+        } = Ze(i.pathname, U);
+        return {
+          matches: ae,
+          loaderData: {},
+          errors: {
+            [k.id]: G
+          }
+        };
+      } else if (U.matches)
+        d = U.matches;
+      else {
+        let {
+          error: G,
+          notFoundMatches: ae,
+          route: k
+        } = st(i.pathname);
+        return {
+          matches: ae,
+          loaderData: {},
+          errors: {
+            [k.id]: G
+          }
+        };
+      }
+    }
+    let B = f || l, [q, Z] = Nt(e.history, c, d, H, i, p.v7_partialHydration && T === !0, p.unstable_skipActionErrorRevalidation, te, je, Je, ce, Te, fe, B, u, M);
+    if (dt((U) => !(d && d.some((G) => G.route.id === U)) || q && q.some((G) => G.route.id === U)), Be = ++Ge, q.length === 0 && Z.length === 0) {
+      let U = xt();
+      return Fe(i, I({
+        matches: d,
+        loaderData: {},
+        // Commit pending error if we're short circuiting
+        errors: M && ee(M[1]) ? {
+          [M[0]]: M[1].error
+        } : null
+      }, kt(M), U ? {
+        fetchers: new Map(c.fetchers)
+      } : {}), {
+        flushSync: L
+      }), {
+        shortCircuited: !0
+      };
+    }
+    if ($) {
+      let U = {};
+      if (!h) {
+        U.navigation = W;
+        let G = Rt(M);
+        G !== void 0 && (U.actionData = G);
+      }
+      Z.length > 0 && (U.fetchers = Cr(Z)), re(U, {
+        flushSync: L
+      });
+    }
+    Z.forEach((U) => {
+      Q.has(U.key) && ve(U.key), U.controller && Q.set(U.key, U.controller);
+    });
+    let ke = () => Z.forEach((U) => ve(U.key));
+    F && F.signal.addEventListener("abort", ke);
+    let {
+      loaderResults: we,
+      fetcherResults: _e
+    } = await Dt(c.matches, d, q, Z, o);
+    if (o.signal.aborted)
+      return {
+        shortCircuited: !0
+      };
+    F && F.signal.removeEventListener("abort", ke), Z.forEach((U) => Q.delete(U.key));
+    let Ue = Vt([...we, ..._e]);
+    if (Ue) {
+      if (Ue.idx >= q.length) {
+        let U = Z[Ue.idx - q.length].key;
+        fe.add(U);
+      }
+      return await Ke(o, Ue.result, {
+        replace: w
+      }), {
+        shortCircuited: !0
+      };
+    }
+    let {
+      loaderData: Ae,
+      errors: se
+    } = Kt(c, d, q, we, M, Z, _e, Ee);
+    Ee.forEach((U, G) => {
+      U.subscribe((ae) => {
+        (ae || U.done) && Ee.delete(G);
+      });
+    }), p.v7_partialHydration && T && c.errors && Object.entries(c.errors).filter((U) => {
+      let [G] = U;
+      return !q.some((ae) => ae.route.id === G);
+    }).forEach((U) => {
+      let [G, ae] = U;
+      se = Object.assign(se || {}, {
+        [G]: ae
+      });
+    });
+    let et = xt(), tt = Lt(Be), rt = et || tt || Z.length > 0;
+    return I({
+      matches: d,
+      loaderData: Ae,
+      errors: se
+    }, rt ? {
+      fetchers: new Map(c.fetchers)
+    } : {});
+  }
+  function Rt(o) {
+    if (o && !ee(o[1]))
+      return {
+        [o[0]]: o[1].data
+      };
+    if (c.actionData)
+      return Object.keys(c.actionData).length === 0 ? null : c.actionData;
+  }
+  function Cr(o) {
+    return o.forEach((i) => {
+      let d = c.fetchers.get(i.key), h = Ve(void 0, d ? d.data : void 0);
+      c.fetchers.set(i.key, h);
+    }), new Map(c.fetchers);
+  }
+  function Tr(o, i, d, h) {
+    if (a)
+      throw new Error("router.fetch() was called during the server render, but it shouldn't be. You are likely calling a useFetcher() method in the body of your component. Try moving it to a useEffect or a callback.");
+    Q.has(o) && ve(o);
+    let D = (h && h.unstable_flushSync) === !0, E = f || l, j = mt(c.location, c.matches, u, p.v7_prependBasename, d, p.v7_relativeSplatPath, i, h == null ? void 0 : h.relative), w = me(E, j, u), T = ut(w, E, j);
+    if (T.active && T.matches && (w = T.matches), !w) {
+      he(o, i, Y(404, {
+        pathname: j
+      }), {
+        flushSync: D
+      });
+      return;
+    }
+    let {
+      path: L,
+      submission: M,
+      error: W
+    } = It(p.v7_normalizeFormMethod, !0, j, h);
+    if (W) {
+      he(o, i, W, {
+        flushSync: D
+      });
+      return;
+    }
+    let H = Le(w, L);
+    if (J = (h && h.preventScrollReset) === !0, M && oe(M.formMethod)) {
+      Fr(o, i, L, H, w, T.active, D, M);
+      return;
+    }
+    Te.set(o, {
+      routeId: i,
+      path: L
+    }), _r(o, i, L, H, w, T.active, D, M);
+  }
+  async function Fr(o, i, d, h, D, E, j, w) {
+    lt(), Te.delete(o);
+    function T(k) {
+      if (!k.route.action && !k.route.lazy) {
+        let pe = Y(405, {
+          method: w.formMethod,
+          pathname: d,
+          routeId: i
+        });
+        return he(o, i, pe, {
+          flushSync: j
+        }), !0;
+      }
+      return !1;
+    }
+    if (!E && T(h))
+      return;
+    let L = c.fetchers.get(o);
+    ye(o, Fa(w, L), {
+      flushSync: j
+    });
+    let M = new AbortController(), W = Oe(e.history, d, M.signal, w);
+    if (E) {
+      let k = await qe(D, d, W.signal);
+      if (k.type === "aborted")
+        return;
+      if (k.type === "error") {
+        let {
+          error: pe
+        } = Ze(d, k);
+        he(o, i, pe, {
+          flushSync: j
+        });
+        return;
+      } else if (k.matches) {
+        if (D = k.matches, h = Le(D, d), T(h))
+          return;
+      } else {
+        he(o, i, Y(404, {
+          pathname: d
+        }), {
+          flushSync: j
+        });
+        return;
+      }
+    }
+    Q.set(o, M);
+    let H = Ge, B = (await $e("action", W, [h], D))[0];
+    if (W.signal.aborted) {
+      Q.get(o) === M && Q.delete(o);
+      return;
+    }
+    if (p.v7_fetcherPersist && ce.has(o)) {
+      if (De(B) || ee(B)) {
+        ye(o, be(void 0));
+        return;
+      }
+    } else {
+      if (De(B))
+        if (Q.delete(o), Be > H) {
+          ye(o, be(void 0));
+          return;
+        } else
+          return fe.add(o), ye(o, Ve(w)), Ke(W, B, {
+            fetcherSubmission: w
+          });
+      if (ee(B)) {
+        he(o, i, B.error);
+        return;
+      }
+    }
+    if (Re(B))
+      throw Y(400, {
+        type: "defer-action"
+      });
+    let q = c.navigation.location || c.location, Z = Oe(e.history, q, M.signal), ke = f || l, we = c.navigation.state !== "idle" ? me(ke, c.navigation.location, u) : c.matches;
+    O(we, "Didn't find any matches after fetcher action");
+    let _e = ++Ge;
+    Ce.set(o, _e);
+    let Ue = Ve(w, B.data);
+    c.fetchers.set(o, Ue);
+    let [Ae, se] = Nt(e.history, c, we, w, q, !1, p.unstable_skipActionErrorRevalidation, te, je, Je, ce, Te, fe, ke, u, [h.route.id, B]);
+    se.filter((k) => k.key !== o).forEach((k) => {
+      let pe = k.key, Ft = c.fetchers.get(pe), zr = Ve(void 0, Ft ? Ft.data : void 0);
+      c.fetchers.set(pe, zr), Q.has(pe) && ve(pe), k.controller && Q.set(pe, k.controller);
+    }), re({
+      fetchers: new Map(c.fetchers)
+    });
+    let et = () => se.forEach((k) => ve(k.key));
+    M.signal.addEventListener("abort", et);
+    let {
+      loaderResults: tt,
+      fetcherResults: rt
+    } = await Dt(c.matches, we, Ae, se, Z);
+    if (M.signal.aborted)
+      return;
+    M.signal.removeEventListener("abort", et), Ce.delete(o), Q.delete(o), se.forEach((k) => Q.delete(k.key));
+    let U = Vt([...tt, ...rt]);
+    if (U) {
+      if (U.idx >= Ae.length) {
+        let k = se[U.idx - Ae.length].key;
+        fe.add(k);
+      }
+      return Ke(Z, U.result);
+    }
+    let {
+      loaderData: G,
+      errors: ae
+    } = Kt(c, c.matches, Ae, tt, void 0, se, rt, Ee);
+    if (c.fetchers.has(o)) {
+      let k = be(B.data);
+      c.fetchers.set(o, k);
+    }
+    Lt(_e), c.navigation.state === "loading" && _e > Be ? (O(C, "Expected pending action"), F && F.abort(), Fe(c.navigation.location, {
+      matches: we,
+      loaderData: G,
+      errors: ae,
+      fetchers: new Map(c.fetchers)
+    })) : (re({
+      errors: ae,
+      loaderData: $t(c.loaderData, G, we, ae),
+      fetchers: new Map(c.fetchers)
+    }), te = !1);
+  }
+  async function _r(o, i, d, h, D, E, j, w) {
+    let T = c.fetchers.get(o);
+    ye(o, Ve(w, T ? T.data : void 0), {
+      flushSync: j
+    });
+    let L = new AbortController(), M = Oe(e.history, d, L.signal);
+    if (E) {
+      let B = await qe(D, d, M.signal);
+      if (B.type === "aborted")
+        return;
+      if (B.type === "error") {
+        let {
+          error: q
+        } = Ze(d, B);
+        he(o, i, q, {
+          flushSync: j
+        });
+        return;
+      } else if (B.matches)
+        D = B.matches, h = Le(D, d);
+      else {
+        he(o, i, Y(404, {
+          pathname: d
+        }), {
+          flushSync: j
+        });
+        return;
+      }
+    }
+    Q.set(o, L);
+    let W = Ge, $ = (await $e("loader", M, [h], D))[0];
+    if (Re($) && ($ = await Rr($, M.signal, !0) || $), Q.get(o) === L && Q.delete(o), !M.signal.aborted) {
+      if (ce.has(o)) {
+        ye(o, be(void 0));
+        return;
+      }
+      if (De($))
+        if (Be > W) {
+          ye(o, be(void 0));
+          return;
+        } else {
+          fe.add(o), await Ke(M, $);
+          return;
+        }
+      if (ee($)) {
+        he(o, i, $.error);
+        return;
+      }
+      O(!Re($), "Unhandled fetcher deferred data"), ye(o, be($.data));
+    }
+  }
+  async function Ke(o, i, d) {
+    let {
+      submission: h,
+      fetcherSubmission: D,
+      replace: E
+    } = d === void 0 ? {} : d;
+    i.response.headers.has("X-Remix-Revalidate") && (te = !0);
+    let j = i.response.headers.get("Location");
+    O(j, "Expected a Location header on the redirect Response"), j = Bt(j, new URL(o.url), u);
+    let w = ge(c.location, j, {
+      _isRedirect: !0
+    });
+    if (r) {
+      let $ = !1;
+      if (i.response.headers.has("X-Remix-Reload-Document"))
+        $ = !0;
+      else if (wt.test(j)) {
+        const B = e.history.createURL(j);
+        $ = // Hard reload if it's an absolute URL to a new origin
+        B.origin !== t.location.origin || // Hard reload if it's an absolute URL that does not match our basename
+        Ye(B.pathname, u) == null;
+      }
+      if ($) {
+        E ? t.location.replace(j) : t.location.assign(j);
+        return;
+      }
+    }
+    F = null;
+    let T = E === !0 ? V.Replace : V.Push, {
+      formMethod: L,
+      formAction: M,
+      formEncType: W
+    } = c.navigation;
+    !h && !D && L && M && W && (h = Jt(c.navigation));
+    let H = h || D;
+    if (wa.has(i.response.status) && H && oe(H.formMethod))
+      await xe(T, w, {
+        submission: I({}, H, {
+          formAction: j
+        }),
+        // Preserve this flag across redirects
+        preventScrollReset: J
+      });
+    else {
+      let $ = ct(w, h);
+      await xe(T, w, {
+        overrideNavigation: $,
+        // Send fetcher submissions through for shouldRevalidate
+        fetcherSubmission: D,
+        // Preserve this flag across redirects
+        preventScrollReset: J
+      });
+    }
+  }
+  async function $e(o, i, d, h) {
+    try {
+      let D = await mr(v, o, i, d, h, s, n);
+      return await Promise.all(D.map((E, j) => {
+        if (br(E)) {
+          let w = E.result;
+          return {
+            type: z.redirect,
+            response: yr(w, i, d[j].route.id, h, u, p.v7_relativeSplatPath)
+          };
+        }
+        return gr(E);
+      }));
+    } catch (D) {
+      return d.map(() => ({
+        type: z.error,
+        error: D
+      }));
+    }
+  }
+  async function Dt(o, i, d, h, D) {
+    let [E, ...j] = await Promise.all([d.length ? $e("loader", D, d, i) : [], ...h.map((w) => {
+      if (w.matches && w.match && w.controller) {
+        let T = Oe(e.history, w.path, w.controller.signal);
+        return $e("loader", T, [w.match], w.matches).then((L) => L[0]);
+      } else
+        return Promise.resolve({
+          type: z.error,
+          error: Y(404, {
+            pathname: w.path
+          })
+        });
+    })]);
+    return await Promise.all([Yt(o, d, E, E.map(() => D.signal), !1, c.loaderData), Yt(o, h.map((w) => w.match), j, h.map((w) => w.controller ? w.controller.signal : null), !0)]), {
+      loaderResults: E,
+      fetcherResults: j
+    };
+  }
+  function lt() {
+    te = !0, je.push(...dt()), Te.forEach((o, i) => {
+      Q.has(i) && (Je.push(i), ve(i));
+    });
+  }
+  function ye(o, i, d) {
+    d === void 0 && (d = {}), c.fetchers.set(o, i), re({
+      fetchers: new Map(c.fetchers)
+    }, {
+      flushSync: (d && d.flushSync) === !0
+    });
+  }
+  function he(o, i, d, h) {
+    h === void 0 && (h = {});
+    let D = He(c.matches, i);
+    Xe(o), re({
+      errors: {
+        [D.route.id]: d
+      },
+      fetchers: new Map(c.fetchers)
+    }, {
+      flushSync: (h && h.flushSync) === !0
+    });
+  }
+  function Et(o) {
+    return p.v7_fetcherPersist && (We.set(o, (We.get(o) || 0) + 1), ce.has(o) && ce.delete(o)), c.fetchers.get(o) || lr;
+  }
+  function Xe(o) {
+    let i = c.fetchers.get(o);
+    Q.has(o) && !(i && i.state === "loading" && Ce.has(o)) && ve(o), Te.delete(o), Ce.delete(o), fe.delete(o), ce.delete(o), c.fetchers.delete(o);
+  }
+  function Ur(o) {
+    if (p.v7_fetcherPersist) {
+      let i = (We.get(o) || 0) - 1;
+      i <= 0 ? (We.delete(o), ce.add(o)) : We.set(o, i);
+    } else
+      Xe(o);
+    re({
+      fetchers: new Map(c.fetchers)
+    });
+  }
+  function ve(o) {
+    let i = Q.get(o);
+    O(i, "Expected fetch controller: " + o), i.abort(), Q.delete(o);
+  }
+  function Pt(o) {
+    for (let i of o) {
+      let d = Et(i), h = be(d.data);
+      c.fetchers.set(i, h);
+    }
+  }
+  function xt() {
+    let o = [], i = !1;
+    for (let d of fe) {
+      let h = c.fetchers.get(d);
+      O(h, "Expected fetcher: " + d), h.state === "loading" && (fe.delete(d), o.push(d), i = !0);
+    }
+    return Pt(o), i;
+  }
+  function Lt(o) {
+    let i = [];
+    for (let [d, h] of Ce)
+      if (h < o) {
+        let D = c.fetchers.get(d);
+        O(D, "Expected fetcher: " + d), D.state === "loading" && (ve(d), Ce.delete(d), i.push(d));
+      }
+    return Pt(i), i.length > 0;
+  }
+  function Ar(o, i) {
+    let d = c.blockers.get(o) || Ie;
+    return Pe.get(o) !== i && Pe.set(o, i), d;
+  }
+  function Mt(o) {
+    c.blockers.delete(o), Pe.delete(o);
+  }
+  function Qe(o, i) {
+    let d = c.blockers.get(o) || Ie;
+    O(d.state === "unblocked" && i.state === "blocked" || d.state === "blocked" && i.state === "blocked" || d.state === "blocked" && i.state === "proceeding" || d.state === "blocked" && i.state === "unblocked" || d.state === "proceeding" && i.state === "unblocked", "Invalid blocker state transition: " + d.state + " -> " + i.state);
+    let h = new Map(c.blockers);
+    h.set(o, i), re({
+      blockers: h
+    });
+  }
+  function jt(o) {
+    let {
+      currentLocation: i,
+      nextLocation: d,
+      historyAction: h
+    } = o;
+    if (Pe.size === 0)
+      return;
+    Pe.size > 1 && de(!1, "A router only supports one blocker at a time");
+    let D = Array.from(Pe.entries()), [E, j] = D[D.length - 1], w = c.blockers.get(E);
+    if (!(w && w.state === "proceeding") && j({
+      currentLocation: i,
+      nextLocation: d,
+      historyAction: h
+    }))
+      return E;
+  }
+  function st(o) {
+    let i = Y(404, {
+      pathname: o
+    }), d = f || l, {
+      matches: h,
+      route: D
+    } = ot(d);
+    return dt(), {
+      notFoundMatches: h,
+      route: D,
+      error: i
+    };
+  }
+  function Ze(o, i) {
+    let d = i.partialMatches, h = d[d.length - 1].route, D = Y(400, {
+      type: "route-discovery",
+      routeId: h.id,
+      pathname: o,
+      message: i.error != null && "message" in i.error ? i.error : String(i.error)
+    });
+    return {
+      notFoundMatches: d,
+      route: h,
+      error: D
+    };
+  }
+  function dt(o) {
+    let i = [];
+    return Ee.forEach((d, h) => {
+      (!o || o(h)) && (d.cancel(), i.push(h), Ee.delete(h));
+    }), i;
+  }
+  function Or(o, i, d) {
+    if (y = o, P = i, g = d || null, !A && c.navigation === nt) {
+      A = !0;
+      let h = Tt(c.location, c.matches);
+      h != null && re({
+        restoreScrollPosition: h
+      });
+    }
+    return () => {
+      y = null, P = null, g = null;
+    };
+  }
+  function Ct(o, i) {
+    return g && g(o, i.map((h) => Xt(h, c.loaderData))) || o.key;
+  }
+  function Ir(o, i) {
+    if (y && P) {
+      let d = Ct(o, i);
+      y[d] = P();
+    }
+  }
+  function Tt(o, i) {
+    if (y) {
+      let d = Ct(o, i), h = y[d];
+      if (typeof h == "number")
+        return h;
+    }
+    return null;
+  }
+  function ut(o, i, d) {
+    if (b)
+      if (o) {
+        let h = o[o.length - 1].route;
+        if (h.path && (h.path === "*" || h.path.endsWith("/*")))
+          return {
+            active: !0,
+            matches: at(i, d, u, !0)
+          };
+      } else
+        return {
+          active: !0,
+          matches: at(i, d, u, !0) || []
+        };
+    return {
+      active: !1,
+      matches: null
+    };
+  }
+  async function qe(o, i, d) {
+    let h = o, D = h.length > 0 ? h[h.length - 1].route : null;
+    for (; ; ) {
+      let E = f == null, j = f || l;
+      try {
+        await Pa(b, i, h, j, s, n, Dr, d);
+      } catch (M) {
+        return {
+          type: "error",
+          error: M,
+          partialMatches: h
+        };
+      } finally {
+        E && (l = [...l]);
+      }
+      if (d.aborted)
+        return {
+          type: "aborted"
+        };
+      let w = me(j, i, u), T = !1;
+      if (w) {
+        let M = w[w.length - 1].route;
+        if (M.index)
+          return {
+            type: "success",
+            matches: w
+          };
+        if (M.path && M.path.length > 0)
+          if (M.path === "*")
+            T = !0;
+          else
+            return {
+              type: "success",
+              matches: w
+            };
+      }
+      let L = at(j, i, u, !0);
+      if (!L || h.map((M) => M.route.id).join("-") === L.map((M) => M.route.id).join("-"))
+        return {
+          type: "success",
+          matches: T ? w : null
+        };
+      if (h = L, D = h[h.length - 1].route, D.path === "*")
+        return {
+          type: "success",
+          matches: h
+        };
+    }
+  }
+  function Nr(o) {
+    s = {}, f = Me(o, n, void 0, s);
+  }
+  function Hr(o, i) {
+    let d = f == null;
+    hr(o, i, f || l, s, n), d && (l = [...l], re({}));
+  }
+  return N = {
+    get basename() {
+      return u;
+    },
+    get future() {
+      return p;
+    },
+    get state() {
+      return c;
+    },
+    get routes() {
+      return l;
+    },
+    get window() {
+      return t;
+    },
+    initialize: Er,
+    subscribe: xr,
+    enableScrollRestoration: Or,
+    navigate: St,
+    fetch: Tr,
+    revalidate: Lr,
+    // Passthrough to history-aware createHref used by useHref so we get proper
+    // hash-aware URLs in DOM paths
+    createHref: (o) => e.history.createHref(o),
+    encodeLocation: (o) => e.history.encodeLocation(o),
+    getFetcher: Et,
+    deleteFetcher: Ur,
+    dispose: Pr,
+    getBlocker: Ar,
+    deleteBlocker: Mt,
+    patchRoutes: Hr,
+    _internalFetchControllers: Q,
+    _internalActiveDeferreds: Ee,
+    // TODO: Remove setRoutes, it's temporary to avoid dealing with
+    // updating the tree while validating the update algorithm.
+    _internalSetRoutes: Nr
+  }, N;
+}
+const ur = Symbol("deferred");
+function Sa(e, t) {
+  O(e.length > 0, "You must provide a non-empty routes array to createStaticHandler");
+  let r = {}, a = (t ? t.basename : null) || "/", n;
+  if (t != null && t.mapRouteProperties)
+    n = t.mapRouteProperties;
+  else if (t != null && t.detectErrorBoundary) {
+    let m = t.detectErrorBoundary;
+    n = (y) => ({
+      hasErrorBoundary: m(y)
+    });
+  } else
+    n = sr;
+  let s = I({
+    v7_relativeSplatPath: !1,
+    v7_throwAbortReason: !1
+  }, t ? t.future : null), l = Me(e, n, void 0, r);
+  async function f(m, y) {
+    let {
+      requestContext: g,
+      skipLoaderErrorBubbling: P,
+      unstable_dataStrategy: A
+    } = y === void 0 ? {} : y, x = new URL(m.url), _ = m.method, R = ge("", ue(x), null, "default"), N = me(l, R, a);
+    if (!yt(_) && _ !== "HEAD") {
+      let C = Y(405, {
+        method: _
+      }), {
+        matches: J,
+        route: F
+      } = ot(l);
+      return {
+        basename: a,
+        location: R,
+        matches: J,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [F.id]: C
+        },
+        statusCode: C.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    } else if (!N) {
+      let C = Y(404, {
+        pathname: R.pathname
+      }), {
+        matches: J,
+        route: F
+      } = ot(l);
+      return {
+        basename: a,
+        location: R,
+        matches: J,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [F.id]: C
+        },
+        statusCode: C.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    }
+    let c = await v(m, R, N, g, A || null, P === !0, null);
+    return Se(c) ? c : I({
+      location: R,
+      basename: a
+    }, c);
+  }
+  async function u(m, y) {
+    let {
+      routeId: g,
+      requestContext: P,
+      unstable_dataStrategy: A
+    } = y === void 0 ? {} : y, x = new URL(m.url), _ = m.method, R = ge("", ue(x), null, "default"), N = me(l, R, a);
+    if (!yt(_) && _ !== "HEAD" && _ !== "OPTIONS")
+      throw Y(405, {
+        method: _
+      });
+    if (!N)
+      throw Y(404, {
+        pathname: R.pathname
+      });
+    let c = g ? N.find((X) => X.route.id === g) : Le(N, R);
+    if (g && !c)
+      throw Y(403, {
+        pathname: R.pathname,
+        routeId: g
+      });
+    if (!c)
+      throw Y(404, {
+        pathname: R.pathname
+      });
+    let C = await v(m, R, N, P, A || null, !1, c);
+    if (Se(C))
+      return C;
+    let J = C.errors ? Object.values(C.errors)[0] : void 0;
+    if (J !== void 0)
+      throw J;
+    if (C.actionData)
+      return Object.values(C.actionData)[0];
+    if (C.loaderData) {
+      var F;
+      let X = Object.values(C.loaderData)[0];
+      return (F = C.activeDeferreds) != null && F[c.route.id] && (X[ur] = C.activeDeferreds[c.route.id]), X;
+    }
+  }
+  async function v(m, y, g, P, A, x, _) {
+    O(m.signal, "query()/queryRoute() requests must contain an AbortController signal");
+    try {
+      if (oe(m.method.toLowerCase()))
+        return await b(m, g, _ || Le(g, y), P, A, x, _ != null);
+      let R = await p(m, g, P, A, x, _);
+      return Se(R) ? R : I({}, R, {
+        actionData: null,
+        actionHeaders: {}
+      });
+    } catch (R) {
+      if (ja(R) && Se(R.result)) {
+        if (R.type === z.error)
+          throw R.result;
+        return R.result;
+      }
+      if (Ca(R))
+        return R;
+      throw R;
+    }
+  }
+  async function b(m, y, g, P, A, x, _) {
+    let R;
+    if (!g.route.action && !g.route.lazy) {
+      let C = Y(405, {
+        method: m.method,
+        pathname: new URL(m.url).pathname,
+        routeId: g.route.id
+      });
+      if (_)
+        throw C;
+      R = {
+        type: z.error,
+        error: C
+      };
+    } else
+      R = (await S("action", m, [g], y, _, P, A))[0], m.signal.aborted && Ot(m, _, s);
+    if (De(R))
+      throw new Response(null, {
+        status: R.response.status,
+        headers: {
+          Location: R.response.headers.get("Location")
+        }
+      });
+    if (Re(R)) {
+      let C = Y(400, {
+        type: "defer-action"
+      });
+      if (_)
+        throw C;
+      R = {
+        type: z.error,
+        error: C
+      };
+    }
+    if (_) {
+      if (ee(R))
+        throw R.error;
+      return {
+        matches: [g],
+        loaderData: {},
+        actionData: {
+          [g.route.id]: R.data
+        },
+        errors: null,
+        // Note: statusCode + headers are unused here since queryRoute will
+        // return the raw Response or value
+        statusCode: 200,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    }
+    let N = new Request(m.url, {
+      headers: m.headers,
+      redirect: m.redirect,
+      signal: m.signal
+    });
+    if (ee(R)) {
+      let C = x ? g : He(y, g.route.id), J = await p(N, y, P, A, x, null, [C.route.id, R]);
+      return I({}, J, {
+        statusCode: ze(R.error) ? R.error.status : R.statusCode != null ? R.statusCode : 500,
+        actionData: null,
+        actionHeaders: I({}, R.headers ? {
+          [g.route.id]: R.headers
+        } : {})
+      });
+    }
+    let c = await p(N, y, P, A, x, null);
+    return I({}, c, {
+      actionData: {
+        [g.route.id]: R.data
+      }
+    }, R.statusCode ? {
+      statusCode: R.statusCode
+    } : {}, {
+      actionHeaders: R.headers ? {
+        [g.route.id]: R.headers
+      } : {}
+    });
+  }
+  async function p(m, y, g, P, A, x, _) {
+    let R = x != null;
+    if (R && !(x != null && x.route.loader) && !(x != null && x.route.lazy))
+      throw Y(400, {
+        method: m.method,
+        pathname: new URL(m.url).pathname,
+        routeId: x == null ? void 0 : x.route.id
+      });
+    let c = (x ? [x] : _ && ee(_[1]) ? fr(y, _[0]) : y).filter((K) => K.route.loader || K.route.lazy);
+    if (c.length === 0)
+      return {
+        matches: y,
+        // Add a null for all matched routes for proper revalidation on the client
+        loaderData: y.reduce((K, ne) => Object.assign(K, {
+          [ne.route.id]: null
+        }), {}),
+        errors: _ && ee(_[1]) ? {
+          [_[0]]: _[1].error
+        } : null,
+        statusCode: 200,
+        loaderHeaders: {},
+        activeDeferreds: null
+      };
+    let C = await S("loader", m, c, y, R, g, P);
+    m.signal.aborted && Ot(m, R, s);
+    let J = /* @__PURE__ */ new Map(), F = vr(y, c, C, _, J, A), X = new Set(c.map((K) => K.route.id));
+    return y.forEach((K) => {
+      X.has(K.route.id) || (F.loaderData[K.route.id] = null);
+    }), I({}, F, {
+      matches: y,
+      activeDeferreds: J.size > 0 ? Object.fromEntries(J.entries()) : null
+    });
+  }
+  async function S(m, y, g, P, A, x, _) {
+    let R = await mr(_ || pr, m, y, g, P, r, n, x);
+    return await Promise.all(R.map((N, c) => {
+      if (br(N)) {
+        let C = N.result;
+        throw yr(C, y, g[c].route.id, P, a, s.v7_relativeSplatPath);
+      }
+      if (Se(N.result) && A)
+        throw N;
+      return gr(N);
+    }));
+  }
+  return {
+    dataRoutes: l,
+    query: f,
+    queryRoute: u
+  };
+}
+function Ra(e, t, r) {
+  return I({}, t, {
+    statusCode: ze(r) ? r.status : 500,
+    errors: {
+      [t._deepestRenderedBoundaryId || e[0].id]: r
+    }
+  });
+}
+function Ot(e, t, r) {
+  if (r.v7_throwAbortReason && e.signal.reason !== void 0)
+    throw e.signal.reason;
+  let a = t ? "queryRoute" : "query";
+  throw new Error(a + "() call aborted: " + e.method + " " + e.url);
+}
+function Da(e) {
+  return e != null && ("formData" in e && e.formData != null || "body" in e && e.body !== void 0);
+}
+function mt(e, t, r, a, n, s, l, f) {
+  let u, v;
+  if (l) {
+    u = [];
+    for (let p of t)
+      if (u.push(p), p.route.id === l) {
+        v = p;
+        break;
+      }
+  } else
+    u = t, v = t[t.length - 1];
+  let b = rr(n || ".", tr(u, s), Ye(e.pathname, r) || e.pathname, f === "path");
+  return n == null && (b.search = e.search, b.hash = e.hash), (n == null || n === "" || n === ".") && v && v.route.index && !bt(b.search) && (b.search = b.search ? b.search.replace(/^\?/, "?index&") : "?index"), a && r !== "/" && (b.pathname = b.pathname === "/" ? r : Ne([r, b.pathname])), ue(b);
+}
+function It(e, t, r, a) {
+  if (!a || !Da(a))
+    return {
+      path: r
+    };
+  if (a.formMethod && !yt(a.formMethod))
+    return {
+      path: r,
+      error: Y(405, {
+        method: a.formMethod
+      })
+    };
+  let n = () => ({
+    path: r,
+    error: Y(400, {
+      type: "invalid-body"
+    })
+  }), s = a.formMethod || "get", l = e ? s.toUpperCase() : s.toLowerCase(), f = wr(r);
+  if (a.body !== void 0) {
+    if (a.formEncType === "text/plain") {
+      if (!oe(l))
+        return n();
+      let S = typeof a.body == "string" ? a.body : a.body instanceof FormData || a.body instanceof URLSearchParams ? (
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
+        Array.from(a.body.entries()).reduce((m, y) => {
+          let [g, P] = y;
+          return "" + m + g + "=" + P + `
+`;
+        }, "")
+      ) : String(a.body);
+      return {
+        path: r,
+        submission: {
+          formMethod: l,
+          formAction: f,
+          formEncType: a.formEncType,
+          formData: void 0,
+          json: void 0,
+          text: S
+        }
+      };
+    } else if (a.formEncType === "application/json") {
+      if (!oe(l))
+        return n();
+      try {
+        let S = typeof a.body == "string" ? JSON.parse(a.body) : a.body;
+        return {
+          path: r,
+          submission: {
+            formMethod: l,
+            formAction: f,
+            formEncType: a.formEncType,
+            formData: void 0,
+            json: S,
+            text: void 0
+          }
+        };
+      } catch {
+        return n();
+      }
+    }
+  }
+  O(typeof FormData == "function", "FormData is not available in this environment");
+  let u, v;
+  if (a.formData)
+    u = gt(a.formData), v = a.formData;
+  else if (a.body instanceof FormData)
+    u = gt(a.body), v = a.body;
+  else if (a.body instanceof URLSearchParams)
+    u = a.body, v = Wt(u);
+  else if (a.body == null)
+    u = new URLSearchParams(), v = new FormData();
+  else
+    try {
+      u = new URLSearchParams(a.body), v = Wt(u);
+    } catch {
+      return n();
+    }
+  let b = {
+    formMethod: l,
+    formAction: f,
+    formEncType: a && a.formEncType || "application/x-www-form-urlencoded",
+    formData: v,
+    json: void 0,
+    text: void 0
+  };
+  if (oe(b.formMethod))
+    return {
+      path: r,
+      submission: b
+    };
+  let p = ie(r);
+  return t && p.search && bt(p.search) && u.append("index", ""), p.search = "?" + u, {
+    path: ue(p),
+    submission: b
+  };
+}
+function fr(e, t) {
+  let r = e;
+  if (t) {
+    let a = e.findIndex((n) => n.route.id === t);
+    a >= 0 && (r = e.slice(0, a));
+  }
+  return r;
+}
+function Nt(e, t, r, a, n, s, l, f, u, v, b, p, S, m, y, g) {
+  let P = g ? ee(g[1]) ? g[1].error : g[1].data : void 0, A = e.createURL(t.location), x = e.createURL(n), _ = g && ee(g[1]) ? g[0] : void 0, R = _ ? fr(r, _) : r, N = g ? g[1].statusCode : void 0, c = l && N && N >= 400, C = R.filter((F, X) => {
+    let {
+      route: K
+    } = F;
+    if (K.lazy)
+      return !0;
+    if (K.loader == null)
+      return !1;
+    if (s)
+      return typeof K.loader != "function" || K.loader.hydrate ? !0 : t.loaderData[K.id] === void 0 && // Don't re-run if the loader ran and threw an error
+      (!t.errors || t.errors[K.id] === void 0);
+    if (Ea(t.loaderData, t.matches[X], F) || u.some((te) => te === F.route.id))
+      return !0;
+    let ne = t.matches[X], le = F;
+    return Ht(F, I({
+      currentUrl: A,
+      currentParams: ne.params,
+      nextUrl: x,
+      nextParams: le.params
+    }, a, {
+      actionResult: P,
+      unstable_actionStatus: N,
+      defaultShouldRevalidate: c ? !1 : (
+        // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+        f || A.pathname + A.search === x.pathname + x.search || // Search params affect all loaders
+        A.search !== x.search || cr(ne, le)
+      )
+    }));
+  }), J = [];
+  return p.forEach((F, X) => {
+    if (s || !r.some((je) => je.route.id === F.routeId) || b.has(X))
+      return;
+    let K = me(m, F.path, y);
+    if (!K) {
+      J.push({
+        key: X,
+        routeId: F.routeId,
+        path: F.path,
+        matches: null,
+        match: null,
+        controller: null
+      });
+      return;
+    }
+    let ne = t.fetchers.get(X), le = Le(K, F.path), te = !1;
+    S.has(X) ? te = !1 : v.includes(X) ? te = !0 : ne && ne.state !== "idle" && ne.data === void 0 ? te = f : te = Ht(le, I({
+      currentUrl: A,
+      currentParams: t.matches[t.matches.length - 1].params,
+      nextUrl: x,
+      nextParams: r[r.length - 1].params
+    }, a, {
+      actionResult: P,
+      unstable_actionStatus: N,
+      defaultShouldRevalidate: c ? !1 : f
+    })), te && J.push({
+      key: X,
+      routeId: F.routeId,
+      path: F.path,
+      matches: K,
+      match: le,
+      controller: new AbortController()
+    });
+  }), [C, J];
+}
+function Ea(e, t, r) {
+  let a = (
+    // [a] -> [a, b]
+    !t || // [a, b] -> [a, c]
+    r.route.id !== t.route.id
+  ), n = e[r.route.id] === void 0;
+  return a || n;
+}
+function cr(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 Ht(e, t) {
+  if (e.route.shouldRevalidate) {
+    let r = e.route.shouldRevalidate(t);
+    if (typeof r == "boolean")
+      return r;
+  }
+  return t.defaultShouldRevalidate;
+}
+async function Pa(e, t, r, a, n, s, l, f) {
+  let u = [t, ...r.map((v) => v.route.id)].join("-");
+  try {
+    let v = l.get(u);
+    v || (v = e({
+      path: t,
+      matches: r,
+      patch: (b, p) => {
+        f.aborted || hr(b, p, a, n, s);
+      }
+    }), l.set(u, v)), v && Ma(v) && await v;
+  } finally {
+    l.delete(u);
+  }
+}
+function hr(e, t, r, a, n) {
+  if (e) {
+    var s;
+    let l = a[e];
+    O(l, "No route found to patch children into: routeId = " + e);
+    let f = Me(t, n, [e, "patch", String(((s = l.children) == null ? void 0 : s.length) || "0")], a);
+    l.children ? l.children.push(...f) : l.children = f;
+  } else {
+    let l = Me(t, n, ["patch", String(r.length || "0")], a);
+    r.push(...l);
+  }
+}
+async function zt(e, t, r) {
+  if (!e.lazy)
+    return;
+  let a = await e.lazy();
+  if (!e.lazy)
+    return;
+  let n = r[e.id];
+  O(n, "No route found in manifest");
+  let s = {};
+  for (let l in a) {
+    let u = n[l] !== void 0 && // This property isn't static since it should always be updated based
+    // on the route updates
+    l !== "hasErrorBoundary";
+    de(!u, 'Route "' + n.id + '" has a static property "' + l + '" defined but its lazy function is also returning a value for this property. ' + ('The lazy route property "' + l + '" will be ignored.')), !u && !kr.has(l) && (s[l] = a[l]);
+  }
+  Object.assign(n, s), Object.assign(n, I({}, t(n), {
+    lazy: void 0
+  }));
+}
+function pr(e) {
+  return Promise.all(e.matches.map((t) => t.resolve()));
+}
+async function mr(e, t, r, a, n, s, l, f) {
+  let u = a.reduce((p, S) => p.add(S.route.id), /* @__PURE__ */ new Set()), v = /* @__PURE__ */ new Set(), b = await e({
+    matches: n.map((p) => {
+      let S = u.has(p.route.id);
+      return I({}, p, {
+        shouldLoad: S,
+        resolve: (y) => (v.add(p.route.id), S ? xa(t, r, p, s, l, y, f) : Promise.resolve({
+          type: z.data,
+          result: void 0
+        }))
+      });
+    }),
+    request: r,
+    params: n[0].params,
+    context: f
+  });
+  return n.forEach((p) => O(v.has(p.route.id), '`match.resolve()` was not called for route id "' + p.route.id + '". You must call `match.resolve()` on every match passed to `dataStrategy` to ensure all routes are properly loaded.')), b.filter((p, S) => u.has(n[S].route.id));
+}
+async function xa(e, t, r, a, n, s, l) {
+  let f, u, v = (b) => {
+    let p, S = new Promise((g, P) => p = P);
+    u = () => p(), t.signal.addEventListener("abort", u);
+    let m = (g) => typeof b != "function" ? Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ('"' + e + '" [routeId: ' + r.route.id + "]"))) : b({
+      request: t,
+      params: r.params,
+      context: l
+    }, ...g !== void 0 ? [g] : []), y;
+    return s ? y = s((g) => m(g)) : y = (async () => {
+      try {
+        return {
+          type: "data",
+          result: await m()
+        };
+      } catch (g) {
+        return {
+          type: "error",
+          result: g
+        };
+      }
+    })(), Promise.race([y, S]);
+  };
+  try {
+    let b = r.route[e];
+    if (r.route.lazy)
+      if (b) {
+        let p, [S] = 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
+          v(b).catch((m) => {
+            p = m;
+          }),
+          zt(r.route, n, a)
+        ]);
+        if (p !== void 0)
+          throw p;
+        f = S;
+      } else if (await zt(r.route, n, a), b = r.route[e], b)
+        f = await v(b);
+      else if (e === "action") {
+        let p = new URL(t.url), S = p.pathname + p.search;
+        throw Y(405, {
+          method: t.method,
+          pathname: S,
+          routeId: r.route.id
+        });
+      } else
+        return {
+          type: z.data,
+          result: void 0
+        };
+    else if (b)
+      f = await v(b);
+    else {
+      let p = new URL(t.url), S = p.pathname + p.search;
+      throw Y(404, {
+        pathname: S
+      });
+    }
+    O(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 (b) {
+    return {
+      type: z.error,
+      result: b
+    };
+  } finally {
+    u && t.signal.removeEventListener("abort", u);
+  }
+  return f;
+}
+async function gr(e) {
+  let {
+    result: t,
+    type: r,
+    status: a
+  } = e;
+  if (Se(t)) {
+    let l;
+    try {
+      let f = t.headers.get("Content-Type");
+      f && /\bapplication\/json\b/.test(f) ? t.body == null ? l = null : l = await t.json() : l = await t.text();
+    } catch (f) {
+      return {
+        type: z.error,
+        error: f
+      };
+    }
+    return r === z.error ? {
+      type: z.error,
+      error: new vt(t.status, t.statusText, l),
+      statusCode: t.status,
+      headers: t.headers
+    } : {
+      type: z.data,
+      data: l,
+      statusCode: t.status,
+      headers: t.headers
+    };
+  }
+  if (r === z.error)
+    return {
+      type: z.error,
+      error: t,
+      statusCode: ze(t) ? t.status : a
+    };
+  if (Sr(t)) {
+    var n, s;
+    return {
+      type: z.deferred,
+      deferredData: t,
+      statusCode: (n = t.init) == null ? void 0 : n.status,
+      headers: ((s = t.init) == null ? void 0 : s.headers) && new Headers(t.init.headers)
+    };
+  }
+  return {
+    type: z.data,
+    data: t,
+    statusCode: a
+  };
+}
+function yr(e, t, r, a, n, s) {
+  let l = e.headers.get("Location");
+  if (O(l, "Redirects returned/thrown from loaders/actions must have a Location header"), !wt.test(l)) {
+    let f = a.slice(0, a.findIndex((u) => u.route.id === r) + 1);
+    l = mt(new URL(t.url), f, n, !0, l, s), e.headers.set("Location", l);
+  }
+  return e;
+}
+function Bt(e, t, r) {
+  if (wt.test(e)) {
+    let a = e, n = a.startsWith("//") ? new URL(t.protocol + a) : new URL(a), s = Ye(n.pathname, r) != null;
+    if (n.origin === t.origin && s)
+      return n.pathname + n.search + n.hash;
+  }
+  return e;
+}
+function Oe(e, t, r, a) {
+  let n = e.createURL(wr(t)).toString(), s = {
+    signal: r
+  };
+  if (a && oe(a.formMethod)) {
+    let {
+      formMethod: l,
+      formEncType: f
+    } = a;
+    s.method = l.toUpperCase(), f === "application/json" ? (s.headers = new Headers({
+      "Content-Type": f
+    }), s.body = JSON.stringify(a.json)) : f === "text/plain" ? s.body = a.text : f === "application/x-www-form-urlencoded" && a.formData ? s.body = gt(a.formData) : s.body = a.formData;
+  }
+  return new Request(n, s);
+}
+function gt(e) {
+  let t = new URLSearchParams();
+  for (let [r, a] of e.entries())
+    t.append(r, typeof a == "string" ? a : a.name);
+  return t;
+}
+function Wt(e) {
+  let t = new FormData();
+  for (let [r, a] of e.entries())
+    t.append(r, a);
+  return t;
+}
+function vr(e, t, r, a, n, s) {
+  let l = {}, f = null, u, v = !1, b = {}, p = a && ee(a[1]) ? a[1].error : void 0;
+  return r.forEach((S, m) => {
+    let y = t[m].route.id;
+    if (O(!De(S), "Cannot handle redirect results in processLoaderData"), ee(S)) {
+      let g = S.error;
+      if (p !== void 0 && (g = p, p = void 0), f = f || {}, s)
+        f[y] = g;
+      else {
+        let P = He(e, y);
+        f[P.route.id] == null && (f[P.route.id] = g);
+      }
+      l[y] = void 0, v || (v = !0, u = ze(S.error) ? S.error.status : 500), S.headers && (b[y] = S.headers);
+    } else
+      Re(S) ? (n.set(y, S.deferredData), l[y] = S.deferredData.data, S.statusCode != null && S.statusCode !== 200 && !v && (u = S.statusCode), S.headers && (b[y] = S.headers)) : (l[y] = S.data, S.statusCode && S.statusCode !== 200 && !v && (u = S.statusCode), S.headers && (b[y] = S.headers));
+  }), p !== void 0 && a && (f = {
+    [a[0]]: p
+  }, l[a[0]] = void 0), {
+    loaderData: l,
+    errors: f,
+    statusCode: u || 200,
+    loaderHeaders: b
+  };
+}
+function Kt(e, t, r, a, n, s, l, f) {
+  let {
+    loaderData: u,
+    errors: v
+  } = vr(
+    t,
+    r,
+    a,
+    n,
+    f,
+    !1
+    // This method is only called client side so we always want to bubble
+  );
+  for (let b = 0; b < s.length; b++) {
+    let {
+      key: p,
+      match: S,
+      controller: m
+    } = s[b];
+    O(l !== void 0 && l[b] !== void 0, "Did not find corresponding fetcher result");
+    let y = l[b];
+    if (!(m && m.signal.aborted))
+      if (ee(y)) {
+        let g = He(e.matches, S == null ? void 0 : S.route.id);
+        v && v[g.route.id] || (v = I({}, v, {
+          [g.route.id]: y.error
+        })), e.fetchers.delete(p);
+      } else if (De(y))
+        O(!1, "Unhandled fetcher revalidation redirect");
+      else if (Re(y))
+        O(!1, "Unhandled fetcher deferred data");
+      else {
+        let g = be(y.data);
+        e.fetchers.set(p, g);
+      }
+  }
+  return {
+    loaderData: u,
+    errors: v
+  };
+}
+function $t(e, t, r, a) {
+  let n = I({}, t);
+  for (let s of r) {
+    let l = s.route.id;
+    if (t.hasOwnProperty(l) ? t[l] !== void 0 && (n[l] = t[l]) : e[l] !== void 0 && s.route.loader && (n[l] = e[l]), a && a.hasOwnProperty(l))
+      break;
+  }
+  return n;
+}
+function kt(e) {
+  return e ? ee(e[1]) ? {
+    // Clear out prior actionData on errors
+    actionData: {}
+  } : {
+    actionData: {
+      [e[0]]: e[1].data
+    }
+  } : {};
+}
+function He(e, t) {
+  return (t ? e.slice(0, e.findIndex((a) => a.route.id === t) + 1) : [...e]).reverse().find((a) => a.route.hasErrorBoundary === !0) || e[0];
+}
+function ot(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 Y(e, t) {
+  let {
+    pathname: r,
+    routeId: a,
+    method: n,
+    type: s,
+    message: l
+  } = t === void 0 ? {} : t, f = "Unknown Server Error", u = "Unknown @remix-run/router error";
+  return e === 400 ? (f = "Bad Request", s === "route-discovery" ? u = 'Unable to match URL "' + r + '" - the `children()` function for ' + ("route `" + a + "` threw the following error:\n" + l) : n && r && a ? u = "You made a " + n + ' request to "' + r + '" but ' + ('did not provide a `loader` for route "' + a + '", ') + "so there is no way to handle the request." : s === "defer-action" ? u = "defer() is not supported in actions" : s === "invalid-body" && (u = "Unable to encode submission body")) : e === 403 ? (f = "Forbidden", u = 'Route "' + a + '" does not match URL "' + r + '"') : e === 404 ? (f = "Not Found", u = 'No route matches URL "' + r + '"') : e === 405 && (f = "Method Not Allowed", n && r && a ? u = "You made a " + n.toUpperCase() + ' request to "' + r + '" but ' + ('did not provide an `action` for route "' + a + '", ') + "so there is no way to handle the request." : n && (u = 'Invalid request method "' + n.toUpperCase() + '"')), new vt(e || 500, f, new Error(u), !0);
+}
+function Vt(e) {
+  for (let t = e.length - 1; t >= 0; t--) {
+    let r = e[t];
+    if (De(r))
+      return {
+        result: r,
+        idx: t
+      };
+  }
+}
+function wr(e) {
+  let t = typeof e == "string" ? ie(e) : e;
+  return ue(I({}, t, {
+    hash: ""
+  }));
+}
+function La(e, t) {
+  return e.pathname !== t.pathname || e.search !== t.search ? !1 : e.hash === "" ? t.hash !== "" : e.hash === t.hash ? !0 : t.hash !== "";
+}
+function Ma(e) {
+  return typeof e == "object" && e != null && "then" in e;
+}
+function ja(e) {
+  return e != null && typeof e == "object" && "type" in e && "result" in e && (e.type === z.data || e.type === z.error);
+}
+function br(e) {
+  return Se(e.result) && va.has(e.result.status);
+}
+function Re(e) {
+  return e.type === z.deferred;
+}
+function ee(e) {
+  return e.type === z.error;
+}
+function De(e) {
+  return (e && e.type) === z.redirect;
+}
+function Sr(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 Se(e) {
+  return e != null && typeof e.status == "number" && typeof e.statusText == "string" && typeof e.headers == "object" && typeof e.body < "u";
+}
+function Ca(e) {
+  if (!Se(e))
+    return !1;
+  let t = e.status, r = e.headers.get("Location");
+  return t >= 300 && t <= 399 && r != null;
+}
+function yt(e) {
+  return ya.has(e.toLowerCase());
+}
+function oe(e) {
+  return ma.has(e.toLowerCase());
+}
+async function Yt(e, t, r, a, n, s) {
+  for (let l = 0; l < r.length; l++) {
+    let f = r[l], u = t[l];
+    if (!u)
+      continue;
+    let v = e.find((p) => p.route.id === u.route.id), b = v != null && !cr(v, u) && (s && s[u.route.id]) !== void 0;
+    if (Re(f) && (n || b)) {
+      let p = a[l];
+      O(p, "Expected an AbortSignal for revalidating fetcher deferred result"), await Rr(f, p, n).then((S) => {
+        S && (r[l] = S || r[l]);
+      });
+    }
+  }
+}
+async function Rr(e, t, r) {
+  if (r === void 0 && (r = !1), !await e.deferredData.resolveData(t)) {
+    if (r)
+      try {
+        return {
+          type: z.data,
+          data: e.deferredData.unwrappedData
+        };
+      } catch (n) {
+        return {
+          type: z.error,
+          error: n
+        };
+      }
+    return {
+      type: z.data,
+      data: e.deferredData.data
+    };
+  }
+}
+function bt(e) {
+  return new URLSearchParams(e).getAll("index").some((t) => t === "");
+}
+function Le(e, t) {
+  let r = typeof t == "string" ? ie(t).search : t.search;
+  if (e[e.length - 1].route.index && bt(r || ""))
+    return e[e.length - 1];
+  let a = er(e);
+  return a[a.length - 1];
+}
+function Jt(e) {
+  let {
+    formMethod: t,
+    formAction: r,
+    formEncType: a,
+    text: n,
+    formData: s,
+    json: l
+  } = e;
+  if (!(!t || !r || !a)) {
+    if (n != null)
+      return {
+        formMethod: t,
+        formAction: r,
+        formEncType: a,
+        formData: void 0,
+        json: void 0,
+        text: n
+      };
+    if (s != null)
+      return {
+        formMethod: t,
+        formAction: r,
+        formEncType: a,
+        formData: s,
+        json: void 0,
+        text: void 0
+      };
+    if (l !== void 0)
+      return {
+        formMethod: t,
+        formAction: r,
+        formEncType: a,
+        formData: void 0,
+        json: l,
+        text: void 0
+      };
+  }
+}
+function ct(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 Ta(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 Ve(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 Fa(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 be(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 _a(e, t) {
+  try {
+    let r = e.sessionStorage.getItem(dr);
+    if (r) {
+      let a = JSON.parse(r);
+      for (let [n, s] of Object.entries(a || {}))
+        s && Array.isArray(s) && t.set(n, new Set(s || []));
+    }
+  } catch {
+  }
+}
+function Ua(e, t) {
+  if (t.size > 0) {
+    let r = {};
+    for (let [a, n] of t)
+      r[a] = [...n];
+    try {
+      e.sessionStorage.setItem(dr, JSON.stringify(r));
+    } catch (a) {
+      de(!1, "Failed to save applied view transitions in sessionStorage (" + a + ").");
+    }
+  }
+}
+const Aa = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AbortedDeferredError: pt,
+  get Action() {
+    return V;
+  },
+  IDLE_BLOCKER: Ie,
+  IDLE_FETCHER: lr,
+  IDLE_NAVIGATION: nt,
+  UNSAFE_DEFERRED_SYMBOL: ur,
+  UNSAFE_DeferredData: nr,
+  UNSAFE_ErrorResponseImpl: vt,
+  UNSAFE_convertRouteMatchToUiMatch: Xt,
+  UNSAFE_convertRoutesToDataRoutes: Me,
+  UNSAFE_getResolveToMatches: tr,
+  UNSAFE_invariant: O,
+  UNSAFE_warning: de,
+  createBrowserHistory: Wr,
+  createHashHistory: Kr,
+  createMemoryHistory: Br,
+  createPath: ue,
+  createRouter: ba,
+  createStaticHandler: Sa,
+  defer: ha,
+  generatePath: aa,
+  getStaticContextFromError: Ra,
+  getToPathname: la,
+  isDeferredData: Sr,
+  isRouteErrorResponse: ze,
+  joinPaths: Ne,
+  json: ua,
+  matchPath: ht,
+  matchRoutes: me,
+  normalizePathname: ar,
+  parsePath: ie,
+  redirect: or,
+  redirectDocument: pa,
+  resolvePath: qt,
+  resolveTo: rr,
+  stripBasename: Ye
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  V as A,
+  vt as E,
+  Ie as I,
+  O as a,
+  rr as b,
+  me as c,
+  Xt as d,
+  Br as e,
+  pt as f,
+  tr as g,
+  ba as h,
+  ze as i,
+  Ne as j,
+  ue as k,
+  ha as l,
+  ht as m,
+  aa as n,
+  ua as o,
+  ie as p,
+  pa as q,
+  or as r,
+  Ye as s,
+  qt as t,
+  Aa as u,
+  Wr as v,
+  de as w,
+  Kr as x,
+  lr as y
+};
+//# sourceMappingURL=router-BkOLuJlq.js.map