zudoku 0.3.0-dev.7 → 0.3.0-dev.71

package/lib/router-BiRCp01d.js

@@ -0,0 +1,2971 @@
+/**
+ * @remix-run/router v1.18.0
+ *
+ * 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 Wr(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" ? oe(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 Kr(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 $r(e) {
+  e === void 0 && (e = {});
+  function t(n, s) {
+    let {
+      pathname: l = "/",
+      search: f = "",
+      hash: u = ""
+    } = oe(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 kr() {
+  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" ? oe(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 || kr()
+  });
+}
+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 oe(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 R(P, A) {
+    f = V.Push;
+    let x = ge(g.location, P, A);
+    r && r(x, P), v = b() + 1;
+    let U = Ut(x, v), S = g.createHref(x);
+    try {
+      l.pushState(U, "", S);
+    } catch (N) {
+      if (N instanceof DOMException && N.name === "DataCloneError")
+        throw N;
+      n.location.assign(S);
+    }
+    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 U = Ut(x, v), S = g.createHref(x);
+    l.replaceState(U, "", S), 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: R,
+    replace: m,
+    go(P) {
+      return l.go(P);
+    }
+  };
+  return g;
+}
+var H;
+(function(e) {
+  e.data = "data", e.deferred = "deferred", e.redirect = "redirect", e.error = "error";
+})(H || (H = {}));
+const Vr = /* @__PURE__ */ new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
+function Yr(e) {
+  return e.index === !0;
+}
+function je(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`), Yr(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 = je(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" ? oe(t) : t, s = Ye(n.pathname || "/", r);
+  if (s == null)
+    return null;
+  let l = Qt(e);
+  Jr(l);
+  let f = null;
+  for (let u = 0; f == null && u < l.length; ++u) {
+    let v = qt(s);
+    f = aa(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 = He([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: ta(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 Jr(e) {
+  e.sort((t, r) => t.score !== r.score ? r.score - t.score : ra(t.routesMeta.map((a) => a.childrenIndex), r.routesMeta.map((a) => a.childrenIndex)));
+}
+const Gr = /^:[\w-]+$/, Xr = 3, Qr = 2, Zr = 1, qr = 10, ea = -2, At = (e) => e === "*";
+function ta(e, t) {
+  let r = e.split("/"), a = r.length;
+  return r.some(At) && (a += ea), t && (a += Qr), r.filter((n) => !At(n)).reduce((n, s) => n + (Gr.test(s) ? Xr : s === "" ? Zr : qr), a);
+}
+function ra(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 aa(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), R = 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: He([s, p.pathname]),
+      pathnameBase: nr(He([s, p.pathnameBase])),
+      route: R
+    }), p.pathnameBase !== "/" && (s = He([s, p.pathnameBase]));
+  }
+  return l;
+}
+function na(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, R] = b;
+      let m = t[p];
+      return O(R === "?" || 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] = ia(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: R,
+        isOptional: m
+      } = b;
+      if (R === "*") {
+        let g = f[p] || "";
+        l = s.slice(0, s.length - g.length).replace(/(.)\/+$/, "$1");
+      }
+      const y = f[p];
+      return m && !y ? v[R] = void 0 : v[R] = (y || "").replace(/%2F/g, "/"), v;
+    }, {}),
+    pathname: s,
+    pathnameBase: l,
+    pattern: e
+  };
+}
+function ia(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 qt(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 er(e, t) {
+  t === void 0 && (t = "/");
+  let {
+    pathname: r,
+    search: a = "",
+    hash: n = ""
+  } = typeof e == "string" ? oe(e) : e;
+  return {
+    pathname: r ? r.startsWith("/") ? r : oa(r, t) : t,
+    search: sa(a),
+    hash: da(n)
+  };
+}
+function oa(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 tr(e) {
+  return e.filter((t, r) => r === 0 || t.route.path && t.route.path.length > 0);
+}
+function rr(e, t) {
+  let r = tr(e);
+  return t ? r.map((a, n) => n === r.length - 1 ? a.pathname : a.pathnameBase) : r.map((a) => a.pathnameBase);
+}
+function ar(e, t, r, a) {
+  a === void 0 && (a = !1);
+  let n;
+  typeof e == "string" ? n = oe(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 R = l.split("/");
+      for (; R[0] === ".."; )
+        R.shift(), p -= 1;
+      n.pathname = R.join("/");
+    }
+    f = p >= 0 ? t[p] : "/";
+  }
+  let u = er(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" ? oe(e).pathname : e.pathname;
+}
+const He = (e) => e.join("/").replace(/\/\/+/g, "/"), nr = (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 ir {
+  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 ir(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 lr = ["post", "put", "patch", "delete"], ma = new Set(lr), ga = ["get", ...lr], 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
+}, sr = {
+  state: "idle",
+  data: void 0,
+  formMethod: void 0,
+  formAction: void 0,
+  formEncType: void 0,
+  formData: void 0,
+  json: void 0,
+  text: void 0
+}, Ne = {
+  state: "unblocked",
+  proceed: void 0,
+  reset: void 0,
+  location: void 0
+}, wt = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i, dr = (e) => ({
+  hasErrorBoundary: !!e.hasErrorBoundary
+}), ur = "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 i = e.detectErrorBoundary;
+    n = (o) => ({
+      hasErrorBoundary: i(o)
+    });
+  } else
+    n = dr;
+  let s = {}, l = je(e.routes, n, void 0, s), f, u = e.basename || "/", v = e.unstable_dataStrategy || mr, b = e.unstable_patchRoutesOnMiss, p = I({
+    v7_fetcherPersist: !1,
+    v7_normalizeFormMethod: !1,
+    v7_partialHydration: !1,
+    v7_prependBasename: !1,
+    v7_relativeSplatPath: !1,
+    v7_skipActionErrorRevalidation: !1
+  }, e.future), R = null, m = /* @__PURE__ */ new Set(), y = null, g = null, P = null, A = e.hydrationData != null, x = me(l, e.history.location, u), U = null;
+  if (x == null && !b) {
+    let i = Y(404, {
+      pathname: e.history.location.pathname
+    }), {
+      matches: o,
+      route: d
+    } = it(l);
+    x = o, U = {
+      [d.id]: i
+    };
+  }
+  x && b && !e.hydrationData && ut(x, l, e.history.location.pathname).active && (x = null);
+  let S;
+  if (!x)
+    S = !1, x = [];
+  else if (x.some((i) => i.route.lazy))
+    S = !1;
+  else if (!x.some((i) => i.route.loader))
+    S = !0;
+  else if (p.v7_partialHydration) {
+    let i = e.hydrationData ? e.hydrationData.loaderData : null, o = e.hydrationData ? e.hydrationData.errors : null, d = (h) => h.route.loader ? typeof h.route.loader == "function" && h.route.loader.hydrate === !0 ? !1 : i && i[h.route.id] !== void 0 || o && o[h.route.id] !== void 0 : !0;
+    if (o) {
+      let h = x.findIndex((D) => o[D.route.id] !== void 0);
+      S = x.slice(0, h + 1).every(d);
+    } else
+      S = x.every(d);
+  } else
+    S = e.hydrationData != null;
+  let N, c = {
+    historyAction: e.history.action,
+    location: e.history.location,
+    matches: x,
+    initialized: S,
+    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 || U,
+    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, Ce = [], Je = [], Q = /* @__PURE__ */ new Map(), Ge = 0, Be = -1, Te = /* @__PURE__ */ new Map(), fe = /* @__PURE__ */ new Set(), Fe = /* @__PURE__ */ new Map(), We = /* @__PURE__ */ new Map(), ce = /* @__PURE__ */ new Set(), Ee = /* @__PURE__ */ new Map(), Pe = /* @__PURE__ */ new Map(), Er = /* @__PURE__ */ new Map(), ot = !1;
+  function Pr() {
+    if (R = e.history.listen((i) => {
+      let {
+        action: o,
+        location: d,
+        delta: h
+      } = i;
+      if (ot) {
+        ot = !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: o
+      });
+      if (D && h != null) {
+        ot = !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, Ne), re({
+              blockers: E
+            });
+          }
+        });
+        return;
+      }
+      return xe(o, d);
+    }), r) {
+      _a(t, K);
+      let i = () => Ua(t, K);
+      t.addEventListener("pagehide", i), ne = () => t.removeEventListener("pagehide", i);
+    }
+    return c.initialized || xe(V.Pop, c.location, {
+      initialHydration: !0
+    }), N;
+  }
+  function xr() {
+    R && R(), ne && ne(), m.clear(), F && F.abort(), c.fetchers.forEach((i, o) => Xe(o)), c.blockers.forEach((i, o) => Mt(o));
+  }
+  function Lr(i) {
+    return m.add(i), () => m.delete(i);
+  }
+  function re(i, o) {
+    o === void 0 && (o = {}), c = I({}, c, i);
+    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: o.viewTransitionOpts,
+      unstable_flushSync: o.flushSync === !0
+    })), p.v7_fetcherPersist && (d.forEach((D) => c.fetchers.delete(D)), h.forEach((D) => Xe(D)));
+  }
+  function _e(i, o, d) {
+    var h, D;
+    let {
+      flushSync: E
+    } = d === void 0 ? {} : d, j = c.actionData != null && c.navigation.formMethod != null && ie(c.navigation.formMethod) && c.navigation.state === "loading" && ((h = i.state) == null ? void 0 : h._isRedirect) !== !0, w;
+    o.actionData ? Object.keys(o.actionData).length > 0 ? w = o.actionData : w = null : j ? w = c.actionData : w = null;
+    let T = o.loaderData ? $t(c.loaderData, o.loaderData, o.matches || [], o.errors) : c.loaderData, L = c.blockers;
+    L.size > 0 && (L = new Map(L), L.forEach((B, $) => L.set($, Ne)));
+    let M = J === !0 || c.navigation.formMethod != null && ie(c.navigation.formMethod) && ((D = i.state) == null ? void 0 : D._isRedirect) !== !0;
+    f && (l = f, f = void 0), le || C === V.Pop || (C === V.Push ? e.history.push(i, i.state) : C === V.Replace && e.history.replace(i, i.state));
+    let W;
+    if (C === V.Pop) {
+      let B = K.get(c.location.pathname);
+      B && B.has(i.pathname) ? W = {
+        currentLocation: c.location,
+        nextLocation: i
+      } : K.has(i.pathname) && (W = {
+        currentLocation: i,
+        nextLocation: c.location
+      });
+    } else if (X) {
+      let B = K.get(c.location.pathname);
+      B ? B.add(i.pathname) : (B = /* @__PURE__ */ new Set([i.pathname]), K.set(c.location.pathname, B)), W = {
+        currentLocation: c.location,
+        nextLocation: i
+      };
+    }
+    re(I({}, o, {
+      actionData: w,
+      loaderData: T,
+      historyAction: C,
+      location: i,
+      initialized: !0,
+      navigation: nt,
+      revalidation: "idle",
+      restoreScrollPosition: Tt(i, o.matches || c.matches),
+      preventScrollReset: M,
+      blockers: L
+    }), {
+      viewTransitionOpts: W,
+      flushSync: E === !0
+    }), C = V.Pop, J = !1, X = !1, le = !1, te = !1, Ce = [], Je = [];
+  }
+  async function Rt(i, o) {
+    if (typeof i == "number") {
+      e.history.go(i);
+      return;
+    }
+    let d = mt(c.location, c.matches, u, p.v7_prependBasename, i, p.v7_relativeSplatPath, o == null ? void 0 : o.fromRouteId, o == null ? void 0 : o.relative), {
+      path: h,
+      submission: D,
+      error: E
+    } = It(p.v7_normalizeFormMethod, !1, d, o), j = c.location, w = ge(c.location, h, o && o.state);
+    w = I({}, w, e.history.encodeLocation(w));
+    let T = o && o.replace != null ? o.replace : void 0, L = V.Push;
+    T === !0 ? L = V.Replace : T === !1 || D != null && ie(D.formMethod) && D.formAction === c.location.pathname + c.location.search && (L = V.Replace);
+    let M = o && "preventScrollReset" in o ? o.preventScrollReset === !0 : void 0, W = (o && o.unstable_flushSync) === !0, B = jt({
+      currentLocation: j,
+      nextLocation: w,
+      historyAction: L
+    });
+    if (B) {
+      Qe(B, {
+        state: "blocked",
+        location: w,
+        proceed() {
+          Qe(B, {
+            state: "proceeding",
+            proceed: void 0,
+            reset: void 0,
+            location: w
+          }), Rt(i, o);
+        },
+        reset() {
+          let $ = new Map(c.blockers);
+          $.set(B, Ne), 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: o && o.replace,
+      enableViewTransition: o && o.unstable_viewTransition,
+      flushSync: W
+    });
+  }
+  function Mr() {
+    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(i, o, d) {
+    F && F.abort(), F = null, C = i, le = (d && d.startUninterruptedRevalidation) === !0, Nr(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, o, u), j = (d && d.flushSync) === !0, w = ut(E, h, o.pathname);
+    if (w.active && w.matches && (E = w.matches), !E) {
+      let {
+        error: z,
+        notFoundMatches: q,
+        route: Z
+      } = st(o.pathname);
+      _e(o, {
+        matches: q,
+        loaderData: {},
+        errors: {
+          [Z.id]: z
+        }
+      }, {
+        flushSync: j
+      });
+      return;
+    }
+    if (c.initialized && !te && La(c.location, o) && !(d && d.submission && ie(d.submission.formMethod))) {
+      _e(o, {
+        matches: E
+      }, {
+        flushSync: j
+      });
+      return;
+    }
+    F = new AbortController();
+    let T = Ie(e.history, o, F.signal, d && d.submission), L;
+    if (d && d.pendingError)
+      L = [Le(E).route.id, {
+        type: H.error,
+        error: d.pendingError
+      }];
+    else if (d && d.submission && ie(d.submission.formMethod)) {
+      let z = await jr(T, o, d.submission, E, w.active, {
+        replace: d.replace,
+        flushSync: j
+      });
+      if (z.shortCircuited)
+        return;
+      if (z.pendingActionResult) {
+        let [q, Z] = z.pendingActionResult;
+        if (ee(Z) && ze(Z.error) && Z.error.status === 404) {
+          F = null, _e(o, {
+            matches: z.matches,
+            loaderData: {},
+            errors: {
+              [q]: Z.error
+            }
+          });
+          return;
+        }
+      }
+      E = z.matches || E, L = z.pendingActionResult, D = ct(o, d.submission), j = !1, w.active = !1, T = Ie(e.history, T.url, T.signal);
+    }
+    let {
+      shortCircuited: M,
+      matches: W,
+      loaderData: B,
+      errors: $
+    } = await Cr(T, o, E, w.active, D, d && d.submission, d && d.fetcherSubmission, d && d.replace, d && d.initialHydration === !0, j, L);
+    M || (F = null, _e(o, I({
+      matches: W || E
+    }, kt(L), {
+      loaderData: B,
+      errors: $
+    })));
+  }
+  async function jr(i, o, d, h, D, E) {
+    E === void 0 && (E = {}), lt();
+    let j = Ta(o, d);
+    if (re({
+      navigation: j
+    }, {
+      flushSync: E.flushSync === !0
+    }), D) {
+      let L = await qe(h, o.pathname, i.signal);
+      if (L.type === "aborted")
+        return {
+          shortCircuited: !0
+        };
+      if (L.type === "error") {
+        let {
+          boundaryId: M,
+          error: W
+        } = Ze(o.pathname, L);
+        return {
+          matches: L.partialMatches,
+          pendingActionResult: [M, {
+            type: H.error,
+            error: W
+          }]
+        };
+      } else if (L.matches)
+        h = L.matches;
+      else {
+        let {
+          notFoundMatches: M,
+          error: W,
+          route: B
+        } = st(o.pathname);
+        return {
+          matches: M,
+          pendingActionResult: [B.id, {
+            type: H.error,
+            error: W
+          }]
+        };
+      }
+    }
+    let w, T = Me(h, o);
+    if (!T.route.action && !T.route.lazy)
+      w = {
+        type: H.error,
+        error: Y(405, {
+          method: i.method,
+          pathname: o.pathname,
+          routeId: T.route.id
+        })
+      };
+    else if (w = (await $e("action", i, [T], h))[0], i.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(i.url), u) === c.location.pathname + c.location.search, await Ke(i, w, {
+        submission: d,
+        replace: L
+      }), {
+        shortCircuited: !0
+      };
+    }
+    if (Se(w))
+      throw Y(400, {
+        type: "defer-action"
+      });
+    if (ee(w)) {
+      let L = Le(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 Cr(i, o, d, h, D, E, j, w, T, L, M) {
+    let W = D || ct(o, E), B = E || j || Jt(W), $ = !le && (!p.v7_partialHydration || !T);
+    if (h) {
+      if ($) {
+        let G = St(M);
+        re(I({
+          navigation: W
+        }, G !== void 0 ? {
+          actionData: G
+        } : {}), {
+          flushSync: L
+        });
+      }
+      let _ = await qe(d, o.pathname, i.signal);
+      if (_.type === "aborted")
+        return {
+          shortCircuited: !0
+        };
+      if (_.type === "error") {
+        let {
+          boundaryId: G,
+          error: ae
+        } = Ze(o.pathname, _);
+        return {
+          matches: _.partialMatches,
+          loaderData: {},
+          errors: {
+            [G]: ae
+          }
+        };
+      } else if (_.matches)
+        d = _.matches;
+      else {
+        let {
+          error: G,
+          notFoundMatches: ae,
+          route: k
+        } = st(o.pathname);
+        return {
+          matches: ae,
+          loaderData: {},
+          errors: {
+            [k.id]: G
+          }
+        };
+      }
+    }
+    let z = f || l, [q, Z] = Nt(e.history, c, d, B, o, p.v7_partialHydration && T === !0, p.v7_skipActionErrorRevalidation, te, Ce, Je, ce, Fe, fe, z, u, M);
+    if (dt((_) => !(d && d.some((G) => G.route.id === _)) || q && q.some((G) => G.route.id === _)), Be = ++Ge, q.length === 0 && Z.length === 0) {
+      let _ = xt();
+      return _e(o, 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), _ ? {
+        fetchers: new Map(c.fetchers)
+      } : {}), {
+        flushSync: L
+      }), {
+        shortCircuited: !0
+      };
+    }
+    if ($) {
+      let _ = {};
+      if (!h) {
+        _.navigation = W;
+        let G = St(M);
+        G !== void 0 && (_.actionData = G);
+      }
+      Z.length > 0 && (_.fetchers = Tr(Z)), re(_, {
+        flushSync: L
+      });
+    }
+    Z.forEach((_) => {
+      Q.has(_.key) && ve(_.key), _.controller && Q.set(_.key, _.controller);
+    });
+    let ke = () => Z.forEach((_) => ve(_.key));
+    F && F.signal.addEventListener("abort", ke);
+    let {
+      loaderResults: we,
+      fetcherResults: Ue
+    } = await Dt(c.matches, d, q, Z, i);
+    if (i.signal.aborted)
+      return {
+        shortCircuited: !0
+      };
+    F && F.signal.removeEventListener("abort", ke), Z.forEach((_) => Q.delete(_.key));
+    let Ae = Vt([...we, ...Ue]);
+    if (Ae) {
+      if (Ae.idx >= q.length) {
+        let _ = Z[Ae.idx - q.length].key;
+        fe.add(_);
+      }
+      return await Ke(i, Ae.result, {
+        replace: w
+      }), {
+        shortCircuited: !0
+      };
+    }
+    let {
+      loaderData: Oe,
+      errors: se
+    } = Kt(c, d, q, we, M, Z, Ue, Ee);
+    Ee.forEach((_, G) => {
+      _.subscribe((ae) => {
+        (ae || _.done) && Ee.delete(G);
+      });
+    }), p.v7_partialHydration && T && c.errors && Object.entries(c.errors).filter((_) => {
+      let [G] = _;
+      return !q.some((ae) => ae.route.id === G);
+    }).forEach((_) => {
+      let [G, ae] = _;
+      se = Object.assign(se || {}, {
+        [G]: ae
+      });
+    });
+    let et = xt(), tt = Lt(Be), rt = et || tt || Z.length > 0;
+    return I({
+      matches: d,
+      loaderData: Oe,
+      errors: se
+    }, rt ? {
+      fetchers: new Map(c.fetchers)
+    } : {});
+  }
+  function St(i) {
+    if (i && !ee(i[1]))
+      return {
+        [i[0]]: i[1].data
+      };
+    if (c.actionData)
+      return Object.keys(c.actionData).length === 0 ? null : c.actionData;
+  }
+  function Tr(i) {
+    return i.forEach((o) => {
+      let d = c.fetchers.get(o.key), h = Ve(void 0, d ? d.data : void 0);
+      c.fetchers.set(o.key, h);
+    }), new Map(c.fetchers);
+  }
+  function Fr(i, o, 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(i) && ve(i);
+    let D = (h && h.unstable_flushSync) === !0, E = f || l, j = mt(c.location, c.matches, u, p.v7_prependBasename, d, p.v7_relativeSplatPath, o, 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(i, o, Y(404, {
+        pathname: j
+      }), {
+        flushSync: D
+      });
+      return;
+    }
+    let {
+      path: L,
+      submission: M,
+      error: W
+    } = It(p.v7_normalizeFormMethod, !0, j, h);
+    if (W) {
+      he(i, o, W, {
+        flushSync: D
+      });
+      return;
+    }
+    let B = Me(w, L);
+    if (J = (h && h.preventScrollReset) === !0, M && ie(M.formMethod)) {
+      _r(i, o, L, B, w, T.active, D, M);
+      return;
+    }
+    Fe.set(i, {
+      routeId: o,
+      path: L
+    }), Ur(i, o, L, B, w, T.active, D, M);
+  }
+  async function _r(i, o, d, h, D, E, j, w) {
+    lt(), Fe.delete(i);
+    function T(k) {
+      if (!k.route.action && !k.route.lazy) {
+        let pe = Y(405, {
+          method: w.formMethod,
+          pathname: d,
+          routeId: o
+        });
+        return he(i, o, pe, {
+          flushSync: j
+        }), !0;
+      }
+      return !1;
+    }
+    if (!E && T(h))
+      return;
+    let L = c.fetchers.get(i);
+    ye(i, Fa(w, L), {
+      flushSync: j
+    });
+    let M = new AbortController(), W = Ie(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(i, o, pe, {
+          flushSync: j
+        });
+        return;
+      } else if (k.matches) {
+        if (D = k.matches, h = Me(D, d), T(h))
+          return;
+      } else {
+        he(i, o, Y(404, {
+          pathname: d
+        }), {
+          flushSync: j
+        });
+        return;
+      }
+    }
+    Q.set(i, M);
+    let B = Ge, z = (await $e("action", W, [h], D))[0];
+    if (W.signal.aborted) {
+      Q.get(i) === M && Q.delete(i);
+      return;
+    }
+    if (p.v7_fetcherPersist && ce.has(i)) {
+      if (De(z) || ee(z)) {
+        ye(i, be(void 0));
+        return;
+      }
+    } else {
+      if (De(z))
+        if (Q.delete(i), Be > B) {
+          ye(i, be(void 0));
+          return;
+        } else
+          return fe.add(i), ye(i, Ve(w)), Ke(W, z, {
+            fetcherSubmission: w
+          });
+      if (ee(z)) {
+        he(i, o, z.error);
+        return;
+      }
+    }
+    if (Se(z))
+      throw Y(400, {
+        type: "defer-action"
+      });
+    let q = c.navigation.location || c.location, Z = Ie(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 Ue = ++Ge;
+    Te.set(i, Ue);
+    let Ae = Ve(w, z.data);
+    c.fetchers.set(i, Ae);
+    let [Oe, se] = Nt(e.history, c, we, w, q, !1, p.v7_skipActionErrorRevalidation, te, Ce, Je, ce, Fe, fe, ke, u, [h.route.id, z]);
+    se.filter((k) => k.key !== i).forEach((k) => {
+      let pe = k.key, Ft = c.fetchers.get(pe), Br = Ve(void 0, Ft ? Ft.data : void 0);
+      c.fetchers.set(pe, Br), 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, Oe, se, Z);
+    if (M.signal.aborted)
+      return;
+    M.signal.removeEventListener("abort", et), Te.delete(i), Q.delete(i), se.forEach((k) => Q.delete(k.key));
+    let _ = Vt([...tt, ...rt]);
+    if (_) {
+      if (_.idx >= Oe.length) {
+        let k = se[_.idx - Oe.length].key;
+        fe.add(k);
+      }
+      return Ke(Z, _.result);
+    }
+    let {
+      loaderData: G,
+      errors: ae
+    } = Kt(c, c.matches, Oe, tt, void 0, se, rt, Ee);
+    if (c.fetchers.has(i)) {
+      let k = be(z.data);
+      c.fetchers.set(i, k);
+    }
+    Lt(Ue), c.navigation.state === "loading" && Ue > Be ? (O(C, "Expected pending action"), F && F.abort(), _e(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 Ur(i, o, d, h, D, E, j, w) {
+    let T = c.fetchers.get(i);
+    ye(i, Ve(w, T ? T.data : void 0), {
+      flushSync: j
+    });
+    let L = new AbortController(), M = Ie(e.history, d, L.signal);
+    if (E) {
+      let z = await qe(D, d, M.signal);
+      if (z.type === "aborted")
+        return;
+      if (z.type === "error") {
+        let {
+          error: q
+        } = Ze(d, z);
+        he(i, o, q, {
+          flushSync: j
+        });
+        return;
+      } else if (z.matches)
+        D = z.matches, h = Me(D, d);
+      else {
+        he(i, o, Y(404, {
+          pathname: d
+        }), {
+          flushSync: j
+        });
+        return;
+      }
+    }
+    Q.set(i, L);
+    let W = Ge, $ = (await $e("loader", M, [h], D))[0];
+    if (Se($) && ($ = await Dr($, M.signal, !0) || $), Q.get(i) === L && Q.delete(i), !M.signal.aborted) {
+      if (ce.has(i)) {
+        ye(i, be(void 0));
+        return;
+      }
+      if (De($))
+        if (Be > W) {
+          ye(i, be(void 0));
+          return;
+        } else {
+          fe.add(i), await Ke(M, $);
+          return;
+        }
+      if (ee($)) {
+        he(i, o, $.error);
+        return;
+      }
+      O(!Se($), "Unhandled fetcher deferred data"), ye(i, be($.data));
+    }
+  }
+  async function Ke(i, o, d) {
+    let {
+      submission: h,
+      fetcherSubmission: D,
+      replace: E
+    } = d === void 0 ? {} : d;
+    o.response.headers.has("X-Remix-Revalidate") && (te = !0);
+    let j = o.response.headers.get("Location");
+    O(j, "Expected a Location header on the redirect Response"), j = Bt(j, new URL(i.url), u);
+    let w = ge(c.location, j, {
+      _isRedirect: !0
+    });
+    if (r) {
+      let $ = !1;
+      if (o.response.headers.has("X-Remix-Reload-Document"))
+        $ = !0;
+      else if (wt.test(j)) {
+        const z = e.history.createURL(j);
+        $ = // Hard reload if it's an absolute URL to a new origin
+        z.origin !== t.location.origin || // Hard reload if it's an absolute URL that does not match our basename
+        Ye(z.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 B = h || D;
+    if (wa.has(o.response.status) && B && ie(B.formMethod))
+      await xe(T, w, {
+        submission: I({}, B, {
+          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(i, o, d, h) {
+    try {
+      let D = await gr(v, i, o, d, h, s, n);
+      return await Promise.all(D.map((E, j) => {
+        if (Rr(E)) {
+          let w = E.result;
+          return {
+            type: H.redirect,
+            response: vr(w, o, d[j].route.id, h, u, p.v7_relativeSplatPath)
+          };
+        }
+        return yr(E);
+      }));
+    } catch (D) {
+      return d.map(() => ({
+        type: H.error,
+        error: D
+      }));
+    }
+  }
+  async function Dt(i, o, d, h, D) {
+    let [E, ...j] = await Promise.all([d.length ? $e("loader", D, d, o) : [], ...h.map((w) => {
+      if (w.matches && w.match && w.controller) {
+        let T = Ie(e.history, w.path, w.controller.signal);
+        return $e("loader", T, [w.match], w.matches).then((L) => L[0]);
+      } else
+        return Promise.resolve({
+          type: H.error,
+          error: Y(404, {
+            pathname: w.path
+          })
+        });
+    })]);
+    return await Promise.all([Yt(i, d, E, E.map(() => D.signal), !1, c.loaderData), Yt(i, h.map((w) => w.match), j, h.map((w) => w.controller ? w.controller.signal : null), !0)]), {
+      loaderResults: E,
+      fetcherResults: j
+    };
+  }
+  function lt() {
+    te = !0, Ce.push(...dt()), Fe.forEach((i, o) => {
+      Q.has(o) && (Je.push(o), ve(o));
+    });
+  }
+  function ye(i, o, d) {
+    d === void 0 && (d = {}), c.fetchers.set(i, o), re({
+      fetchers: new Map(c.fetchers)
+    }, {
+      flushSync: (d && d.flushSync) === !0
+    });
+  }
+  function he(i, o, d, h) {
+    h === void 0 && (h = {});
+    let D = Le(c.matches, o);
+    Xe(i), re({
+      errors: {
+        [D.route.id]: d
+      },
+      fetchers: new Map(c.fetchers)
+    }, {
+      flushSync: (h && h.flushSync) === !0
+    });
+  }
+  function Et(i) {
+    return p.v7_fetcherPersist && (We.set(i, (We.get(i) || 0) + 1), ce.has(i) && ce.delete(i)), c.fetchers.get(i) || sr;
+  }
+  function Xe(i) {
+    let o = c.fetchers.get(i);
+    Q.has(i) && !(o && o.state === "loading" && Te.has(i)) && ve(i), Fe.delete(i), Te.delete(i), fe.delete(i), ce.delete(i), c.fetchers.delete(i);
+  }
+  function Ar(i) {
+    if (p.v7_fetcherPersist) {
+      let o = (We.get(i) || 0) - 1;
+      o <= 0 ? (We.delete(i), ce.add(i)) : We.set(i, o);
+    } else
+      Xe(i);
+    re({
+      fetchers: new Map(c.fetchers)
+    });
+  }
+  function ve(i) {
+    let o = Q.get(i);
+    O(o, "Expected fetch controller: " + i), o.abort(), Q.delete(i);
+  }
+  function Pt(i) {
+    for (let o of i) {
+      let d = Et(o), h = be(d.data);
+      c.fetchers.set(o, h);
+    }
+  }
+  function xt() {
+    let i = [], o = !1;
+    for (let d of fe) {
+      let h = c.fetchers.get(d);
+      O(h, "Expected fetcher: " + d), h.state === "loading" && (fe.delete(d), i.push(d), o = !0);
+    }
+    return Pt(i), o;
+  }
+  function Lt(i) {
+    let o = [];
+    for (let [d, h] of Te)
+      if (h < i) {
+        let D = c.fetchers.get(d);
+        O(D, "Expected fetcher: " + d), D.state === "loading" && (ve(d), Te.delete(d), o.push(d));
+      }
+    return Pt(o), o.length > 0;
+  }
+  function Or(i, o) {
+    let d = c.blockers.get(i) || Ne;
+    return Pe.get(i) !== o && Pe.set(i, o), d;
+  }
+  function Mt(i) {
+    c.blockers.delete(i), Pe.delete(i);
+  }
+  function Qe(i, o) {
+    let d = c.blockers.get(i) || Ne;
+    O(d.state === "unblocked" && o.state === "blocked" || d.state === "blocked" && o.state === "blocked" || d.state === "blocked" && o.state === "proceeding" || d.state === "blocked" && o.state === "unblocked" || d.state === "proceeding" && o.state === "unblocked", "Invalid blocker state transition: " + d.state + " -> " + o.state);
+    let h = new Map(c.blockers);
+    h.set(i, o), re({
+      blockers: h
+    });
+  }
+  function jt(i) {
+    let {
+      currentLocation: o,
+      nextLocation: d,
+      historyAction: h
+    } = i;
+    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: o,
+      nextLocation: d,
+      historyAction: h
+    }))
+      return E;
+  }
+  function st(i) {
+    let o = Y(404, {
+      pathname: i
+    }), d = f || l, {
+      matches: h,
+      route: D
+    } = it(d);
+    return dt(), {
+      notFoundMatches: h,
+      route: D,
+      error: o
+    };
+  }
+  function Ze(i, o) {
+    return {
+      boundaryId: Le(o.partialMatches).route.id,
+      error: Y(400, {
+        type: "route-discovery",
+        pathname: i,
+        message: o.error != null && "message" in o.error ? o.error : String(o.error)
+      })
+    };
+  }
+  function dt(i) {
+    let o = [];
+    return Ee.forEach((d, h) => {
+      (!i || i(h)) && (d.cancel(), o.push(h), Ee.delete(h));
+    }), o;
+  }
+  function Ir(i, o, d) {
+    if (y = i, P = o, 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(i, o) {
+    return g && g(i, o.map((h) => Xt(h, c.loaderData))) || i.key;
+  }
+  function Nr(i, o) {
+    if (y && P) {
+      let d = Ct(i, o);
+      y[d] = P();
+    }
+  }
+  function Tt(i, o) {
+    if (y) {
+      let d = Ct(i, o), h = y[d];
+      if (typeof h == "number")
+        return h;
+    }
+    return null;
+  }
+  function ut(i, o, d) {
+    if (b)
+      if (i) {
+        let h = i[i.length - 1].route;
+        if (h.path && (h.path === "*" || h.path.endsWith("/*")))
+          return {
+            active: !0,
+            matches: at(o, d, u, !0)
+          };
+      } else
+        return {
+          active: !0,
+          matches: at(o, d, u, !0) || []
+        };
+    return {
+      active: !1,
+      matches: null
+    };
+  }
+  async function qe(i, o, d) {
+    let h = i, D = h.length > 0 ? h[h.length - 1].route : null;
+    for (; ; ) {
+      let E = f == null, j = f || l;
+      try {
+        await Pa(b, o, h, j, s, n, Er, d);
+      } catch (M) {
+        return {
+          type: "error",
+          error: M,
+          partialMatches: h
+        };
+      } finally {
+        E && (l = [...l]);
+      }
+      if (d.aborted)
+        return {
+          type: "aborted"
+        };
+      let w = me(j, o, 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, o, 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 Hr(i) {
+    s = {}, f = je(i, n, void 0, s);
+  }
+  function zr(i, o) {
+    let d = f == null;
+    pr(i, o, 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: Pr,
+    subscribe: Lr,
+    enableScrollRestoration: Ir,
+    navigate: Rt,
+    fetch: Fr,
+    revalidate: Mr,
+    // Passthrough to history-aware createHref used by useHref so we get proper
+    // hash-aware URLs in DOM paths
+    createHref: (i) => e.history.createHref(i),
+    encodeLocation: (i) => e.history.encodeLocation(i),
+    getFetcher: Et,
+    deleteFetcher: Ar,
+    dispose: xr,
+    getBlocker: Or,
+    deleteBlocker: Mt,
+    patchRoutes: zr,
+    _internalFetchControllers: Q,
+    _internalActiveDeferreds: Ee,
+    // TODO: Remove setRoutes, it's temporary to avoid dealing with
+    // updating the tree while validating the update algorithm.
+    _internalSetRoutes: Hr
+  }, N;
+}
+const fr = Symbol("deferred");
+function Ra(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 = dr;
+  let s = I({
+    v7_relativeSplatPath: !1,
+    v7_throwAbortReason: !1
+  }, t ? t.future : null), l = je(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), U = m.method, S = ge("", ue(x), null, "default"), N = me(l, S, a);
+    if (!yt(U) && U !== "HEAD") {
+      let C = Y(405, {
+        method: U
+      }), {
+        matches: J,
+        route: F
+      } = it(l);
+      return {
+        basename: a,
+        location: S,
+        matches: J,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [F.id]: C
+        },
+        statusCode: C.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    } else if (!N) {
+      let C = Y(404, {
+        pathname: S.pathname
+      }), {
+        matches: J,
+        route: F
+      } = it(l);
+      return {
+        basename: a,
+        location: S,
+        matches: J,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [F.id]: C
+        },
+        statusCode: C.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    }
+    let c = await v(m, S, N, g, A || null, P === !0, null);
+    return Re(c) ? c : I({
+      location: S,
+      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), U = m.method, S = ge("", ue(x), null, "default"), N = me(l, S, a);
+    if (!yt(U) && U !== "HEAD" && U !== "OPTIONS")
+      throw Y(405, {
+        method: U
+      });
+    if (!N)
+      throw Y(404, {
+        pathname: S.pathname
+      });
+    let c = g ? N.find((X) => X.route.id === g) : Me(N, S);
+    if (g && !c)
+      throw Y(403, {
+        pathname: S.pathname,
+        routeId: g
+      });
+    if (!c)
+      throw Y(404, {
+        pathname: S.pathname
+      });
+    let C = await v(m, S, N, P, A || null, !1, c);
+    if (Re(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[fr] = C.activeDeferreds[c.route.id]), X;
+    }
+  }
+  async function v(m, y, g, P, A, x, U) {
+    O(m.signal, "query()/queryRoute() requests must contain an AbortController signal");
+    try {
+      if (ie(m.method.toLowerCase()))
+        return await b(m, g, U || Me(g, y), P, A, x, U != null);
+      let S = await p(m, g, P, A, x, U);
+      return Re(S) ? S : I({}, S, {
+        actionData: null,
+        actionHeaders: {}
+      });
+    } catch (S) {
+      if (ja(S) && Re(S.result)) {
+        if (S.type === H.error)
+          throw S.result;
+        return S.result;
+      }
+      if (Ca(S))
+        return S;
+      throw S;
+    }
+  }
+  async function b(m, y, g, P, A, x, U) {
+    let S;
+    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 (U)
+        throw C;
+      S = {
+        type: H.error,
+        error: C
+      };
+    } else
+      S = (await R("action", m, [g], y, U, P, A))[0], m.signal.aborted && Ot(m, U, s);
+    if (De(S))
+      throw new Response(null, {
+        status: S.response.status,
+        headers: {
+          Location: S.response.headers.get("Location")
+        }
+      });
+    if (Se(S)) {
+      let C = Y(400, {
+        type: "defer-action"
+      });
+      if (U)
+        throw C;
+      S = {
+        type: H.error,
+        error: C
+      };
+    }
+    if (U) {
+      if (ee(S))
+        throw S.error;
+      return {
+        matches: [g],
+        loaderData: {},
+        actionData: {
+          [g.route.id]: S.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(S)) {
+      let C = x ? g : Le(y, g.route.id), J = await p(N, y, P, A, x, null, [C.route.id, S]);
+      return I({}, J, {
+        statusCode: ze(S.error) ? S.error.status : S.statusCode != null ? S.statusCode : 500,
+        actionData: null,
+        actionHeaders: I({}, S.headers ? {
+          [g.route.id]: S.headers
+        } : {})
+      });
+    }
+    let c = await p(N, y, P, A, x, null);
+    return I({}, c, {
+      actionData: {
+        [g.route.id]: S.data
+      }
+    }, S.statusCode ? {
+      statusCode: S.statusCode
+    } : {}, {
+      actionHeaders: S.headers ? {
+        [g.route.id]: S.headers
+      } : {}
+    });
+  }
+  async function p(m, y, g, P, A, x, U) {
+    let S = x != null;
+    if (S && !(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] : U && ee(U[1]) ? cr(y, U[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: U && ee(U[1]) ? {
+          [U[0]]: U[1].error
+        } : null,
+        statusCode: 200,
+        loaderHeaders: {},
+        activeDeferreds: null
+      };
+    let C = await R("loader", m, c, y, S, g, P);
+    m.signal.aborted && Ot(m, S, s);
+    let J = /* @__PURE__ */ new Map(), F = wr(y, c, C, U, 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 R(m, y, g, P, A, x, U) {
+    let S = await gr(U || mr, m, y, g, P, r, n, x);
+    return await Promise.all(S.map((N, c) => {
+      if (Rr(N)) {
+        let C = N.result;
+        throw vr(C, y, g[c].route.id, P, a, s.v7_relativeSplatPath);
+      }
+      if (Re(N.result) && A)
+        throw N;
+      return yr(N);
+    }));
+  }
+  return {
+    dataRoutes: l,
+    query: f,
+    queryRoute: u
+  };
+}
+function Sa(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 = ar(n || ".", rr(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 : He([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 = br(r);
+  if (a.body !== void 0) {
+    if (a.formEncType === "text/plain") {
+      if (!ie(l))
+        return n();
+      let R = 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: R
+        }
+      };
+    } else if (a.formEncType === "application/json") {
+      if (!ie(l))
+        return n();
+      try {
+        let R = 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: R,
+            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 (ie(b.formMethod))
+    return {
+      path: r,
+      submission: b
+    };
+  let p = oe(r);
+  return t && p.search && bt(p.search) && u.append("index", ""), p.search = "?" + u, {
+    path: ue(p),
+    submission: b
+  };
+}
+function cr(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, R, 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), U = g && ee(g[1]) ? g[0] : void 0, S = U ? cr(r, U) : r, N = g ? g[1].statusCode : void 0, c = l && N && N >= 400, C = S.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,
+      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 || hr(ne, le)
+      )
+    }));
+  }), J = [];
+  return p.forEach((F, X) => {
+    if (s || !r.some((Ce) => Ce.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 = Me(K, F.path), te = !1;
+    R.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,
+      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 hr(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 || pr(b, p, a, n, s);
+      }
+    }), l.set(u, v)), v && Ma(v) && await v;
+  } finally {
+    l.delete(u);
+  }
+}
+function pr(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 = je(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 = je(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 && !Vr.has(l) && (s[l] = a[l]);
+  }
+  Object.assign(n, s), Object.assign(n, I({}, t(n), {
+    lazy: void 0
+  }));
+}
+function mr(e) {
+  return Promise.all(e.matches.map((t) => t.resolve()));
+}
+async function gr(e, t, r, a, n, s, l, f) {
+  let u = a.reduce((p, R) => p.add(R.route.id), /* @__PURE__ */ new Set()), v = /* @__PURE__ */ new Set(), b = await e({
+    matches: n.map((p) => {
+      let R = u.has(p.route.id);
+      return I({}, p, {
+        shouldLoad: R,
+        resolve: (y) => (v.add(p.route.id), R ? xa(t, r, p, s, l, y, f) : Promise.resolve({
+          type: H.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, R) => u.has(n[R].route.id));
+}
+async function xa(e, t, r, a, n, s, l) {
+  let f, u, v = (b) => {
+    let p, R = 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, R]);
+  };
+  try {
+    let b = r.route[e];
+    if (r.route.lazy)
+      if (b) {
+        let p, [R] = 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 = R;
+      } 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), R = p.pathname + p.search;
+        throw Y(405, {
+          method: t.method,
+          pathname: R,
+          routeId: r.route.id
+        });
+      } else
+        return {
+          type: H.data,
+          result: void 0
+        };
+    else if (b)
+      f = await v(b);
+    else {
+      let p = new URL(t.url), R = p.pathname + p.search;
+      throw Y(404, {
+        pathname: R
+      });
+    }
+    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: H.error,
+      result: b
+    };
+  } finally {
+    u && t.signal.removeEventListener("abort", u);
+  }
+  return f;
+}
+async function yr(e) {
+  let {
+    result: t,
+    type: r,
+    status: a
+  } = e;
+  if (Re(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: H.error,
+        error: f
+      };
+    }
+    return r === H.error ? {
+      type: H.error,
+      error: new vt(t.status, t.statusText, l),
+      statusCode: t.status,
+      headers: t.headers
+    } : {
+      type: H.data,
+      data: l,
+      statusCode: t.status,
+      headers: t.headers
+    };
+  }
+  if (r === H.error)
+    return {
+      type: H.error,
+      error: t,
+      statusCode: ze(t) ? t.status : a
+    };
+  if (Sr(t)) {
+    var n, s;
+    return {
+      type: H.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: H.data,
+    data: t,
+    statusCode: a
+  };
+}
+function vr(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 Ie(e, t, r, a) {
+  let n = e.createURL(br(t)).toString(), s = {
+    signal: r
+  };
+  if (a && ie(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 wr(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((R, m) => {
+    let y = t[m].route.id;
+    if (O(!De(R), "Cannot handle redirect results in processLoaderData"), ee(R)) {
+      let g = R.error;
+      if (p !== void 0 && (g = p, p = void 0), f = f || {}, s)
+        f[y] = g;
+      else {
+        let P = Le(e, y);
+        f[P.route.id] == null && (f[P.route.id] = g);
+      }
+      l[y] = void 0, v || (v = !0, u = ze(R.error) ? R.error.status : 500), R.headers && (b[y] = R.headers);
+    } else
+      Se(R) ? (n.set(y, R.deferredData), l[y] = R.deferredData.data, R.statusCode != null && R.statusCode !== 200 && !v && (u = R.statusCode), R.headers && (b[y] = R.headers)) : (l[y] = R.data, R.statusCode && R.statusCode !== 200 && !v && (u = R.statusCode), R.headers && (b[y] = R.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
+  } = wr(
+    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: R,
+      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 = Le(e.matches, R == null ? void 0 : R.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 (Se(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 Le(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 it(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 `unstable_patchRoutesOnMiss()` ' + (`function threw the following error:
+` + 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 br(e) {
+  let t = typeof e == "string" ? oe(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 === H.data || e.type === H.error);
+}
+function Rr(e) {
+  return Re(e.result) && va.has(e.result.status);
+}
+function Se(e) {
+  return e.type === H.deferred;
+}
+function ee(e) {
+  return e.type === H.error;
+}
+function De(e) {
+  return (e && e.type) === H.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 Re(e) {
+  return e != null && typeof e.status == "number" && typeof e.statusText == "string" && typeof e.headers == "object" && typeof e.body < "u";
+}
+function Ca(e) {
+  if (!Re(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 ie(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 && !hr(v, u) && (s && s[u.route.id]) !== void 0;
+    if (Se(f) && (n || b)) {
+      let p = a[l];
+      O(p, "Expected an AbortSignal for revalidating fetcher deferred result"), await Dr(f, p, n).then((R) => {
+        R && (r[l] = R || r[l]);
+      });
+    }
+  }
+}
+async function Dr(e, t, r) {
+  if (r === void 0 && (r = !1), !await e.deferredData.resolveData(t)) {
+    if (r)
+      try {
+        return {
+          type: H.data,
+          data: e.deferredData.unwrappedData
+        };
+      } catch (n) {
+        return {
+          type: H.error,
+          error: n
+        };
+      }
+    return {
+      type: H.data,
+      data: e.deferredData.data
+    };
+  }
+}
+function bt(e) {
+  return new URLSearchParams(e).getAll("index").some((t) => t === "");
+}
+function Me(e, t) {
+  let r = typeof t == "string" ? oe(t).search : t.search;
+  if (e[e.length - 1].route.index && bt(r || ""))
+    return e[e.length - 1];
+  let a = tr(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(ur);
+    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(ur, 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: Ne,
+  IDLE_FETCHER: sr,
+  IDLE_NAVIGATION: nt,
+  UNSAFE_DEFERRED_SYMBOL: fr,
+  UNSAFE_DeferredData: ir,
+  UNSAFE_ErrorResponseImpl: vt,
+  UNSAFE_convertRouteMatchToUiMatch: Xt,
+  UNSAFE_convertRoutesToDataRoutes: je,
+  UNSAFE_decodePath: qt,
+  UNSAFE_getResolveToMatches: rr,
+  UNSAFE_invariant: O,
+  UNSAFE_warning: de,
+  createBrowserHistory: Kr,
+  createHashHistory: $r,
+  createMemoryHistory: Wr,
+  createPath: ue,
+  createRouter: ba,
+  createStaticHandler: Ra,
+  defer: ha,
+  generatePath: na,
+  getStaticContextFromError: Sa,
+  getToPathname: la,
+  isDeferredData: Sr,
+  isRouteErrorResponse: ze,
+  joinPaths: He,
+  json: ua,
+  matchPath: ht,
+  matchRoutes: me,
+  normalizePathname: nr,
+  parsePath: oe,
+  redirect: or,
+  redirectDocument: pa,
+  resolvePath: er,
+  resolveTo: ar,
+  stripBasename: Ye
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  V as A,
+  vt as E,
+  Ne as I,
+  or as a,
+  O as b,
+  ar as c,
+  me as d,
+  qt as e,
+  Xt as f,
+  rr as g,
+  Wr as h,
+  ze as i,
+  He as j,
+  pt as k,
+  ba as l,
+  ht as m,
+  ue as n,
+  ha as o,
+  oe as p,
+  na as q,
+  Aa as r,
+  Ye as s,
+  ua as t,
+  pa as u,
+  er as v,
+  de as w,
+  Kr as x,
+  $r as y,
+  sr as z
+};
+//# sourceMappingURL=router-BiRCp01d.js.map