@hortiview/modulebase 0.0.20436 → 0.0.20524

package/dist/module-router.js

@@ -1,129 +1,2330 @@
-import { useCallback as r } from "react";
-import { useBasePropsStore as t } from "./stores/BasePropsStore.js";
-import { A as R, B as F, F as E, H as N, I as l, a as A, b as _, L as v, c as d, M as m, d as U, N as g, e as h, f as C, O as p, P, R as H, g as y, h as L, i as k, S as x, j as D, k as w, l as I, m as M, D as O, n as b, E as B, o as T, p as f, q as V, r as q, s as z, t as G, u as K, v as W, V as j, w as J, x as Q, y as X, z as Y, C as Z, G as $, J as aa, K as ea, Q as sa, T as ta, U as ra, W as oa, X as ia, Y as ua, Z as na, _ as ca, $ as Sa, a0 as Ra, a1 as Fa, a2 as Ea, a3 as Na, a4 as la, a5 as Aa, a6 as _a, a7 as va, a8 as da, a9 as ma, aa as Ua, ab as ga, ac as ha, ad as Ca, ae as pa, af as Pa, ag as Ha, ah as ya, ai as La, aj as ka, ak as xa, al as Da, am as wa, an as Ia, ao as Ma, ap as Oa, aq as ba, ar as Ba, as as Ta, at as fa, au as Va, av as qa, aw as za, ax as Ga, ay as Ka, az as Wa, aA as ja, aB as Ja, aC as Qa, aD as Xa, aE as Ya, aF as Za, aG as $a, aH as ae, aI as ee, aJ as se, aK as te, aL as re, aM as oe, aN as ie, aO as ue, aP as ne, aQ as ce, aR as Se, aS as Re, aT as Fe } from "./chunk-IR6S3I6Y-BmDdD3SP.js";
-const n = () => {
-  const s = t((a) => a.navigateTo), e = t((a) => a.navigateInHortiview);
-  return r(
+import * as k from "react";
+import A, { useCallback as ze } from "react";
+import { useBasePropsStore as se } from "./stores/BasePropsStore.js";
+import { aV as qe, a0 as ee, ae as Ce, r as te, v as Ve, n as be, aW as We, aP as Xe, E as O, aj as xe, j as K, aX as Je, a8 as Ke, R as Qe, aY as Ge, aZ as _e, a_ as oe, a$ as ie, b0 as Q, ah as P, b1 as ke, b2 as Ye, b3 as Ze, a4 as et, a5 as tt, a3 as rt, O as at, U as nt, x as I, am as st, ao as ot, al as it, b4 as $, b5 as lt, b6 as le, b7 as ut, b8 as re, b9 as U, ba as dt, bb as ct, bc as ft } from "./chunk-LFPYN7LY-D1ls8FXf.js";
+import { A as Sr, B as vr, F as Er, H as Cr, I as br, a as xr, b as _r, L as kr, d as Ar, M as Dr, e as Hr, N as Tr, f as Fr, g as Pr, P as Nr, h as Ur, i as Lr, k as Or, S as Ir, l as Br, m as Mr, o as $r, D as jr, p as zr, q as qr, s as Vr, t as Wr, w as Xr, V as Jr, W as Kr, y as Qr, z as Gr, C as Yr, G as Zr, J as ea, K as ta, Q as ra, T as aa, X as na, Y as sa, Z as oa, _ as ia, $ as la, a1 as ua, a2 as da, c as ca, a6 as fa, a7 as ha, a9 as pa, aa as ma, ab as ya, ac as wa, ad as ga, af as Ra, ag as Sa, ai as va, ak as Ea, an as Ca, ap as ba, aq as xa, ar as _a, as as ka, at as Aa, au as Da, av as Ha, aw as Ta, ax as Fa, ay as Pa, az as Na, aA as Ua, aB as La, aC as Oa, aD as Ia, aE as Ba, aF as Ma, aG as $a, aH as ja, aI as za, aJ as qa, aK as Va, aL as Wa, aM as Xa, aN as Ja, aO as Ka, aQ as Qa, aR as Ga, aS as Ya, aT as Za, aU as en } from "./chunk-LFPYN7LY-D1ls8FXf.js";
+var T = {}, ue;
+function ht() {
+  if (ue) return T;
+  ue = 1, Object.defineProperty(T, "__esModule", { value: !0 }), T.parseCookie = l, T.parse = l, T.stringifyCookie = s, T.stringifySetCookie = i, T.serialize = i, T.parseSetCookie = u, T.stringifySetCookie = i, T.serialize = i;
+  const e = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/, t = /^[\u0021-\u003A\u003C-\u007E]*$/, r = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i, a = /^[\u0020-\u003A\u003D-\u007E]*$/, n = /^-?\d+$/, o = Object.prototype.toString, f = /* @__PURE__ */ (() => {
+    const c = function() {
+    };
+    return c.prototype = /* @__PURE__ */ Object.create(null), c;
+  })();
+  function l(c, v) {
+    const m = new f(), d = c.length;
+    if (d < 2)
+      return m;
+    const R = v?.decode || y;
+    let S = 0;
+    do {
+      const b = p(c, S, d);
+      if (b === -1)
+        break;
+      const E = h(c, S, d);
+      if (b > E) {
+        S = c.lastIndexOf(";", b - 1) + 1;
+        continue;
+      }
+      const _ = w(c, S, b);
+      m[_] === void 0 && (m[_] = R(w(c, b + 1, E))), S = E + 1;
+    } while (S < d);
+    return m;
+  }
+  function s(c, v) {
+    const m = v?.encode || encodeURIComponent, d = [];
+    for (const R of Object.keys(c)) {
+      const S = c[R];
+      if (S === void 0)
+        continue;
+      if (!e.test(R))
+        throw new TypeError(`cookie name is invalid: ${R}`);
+      const b = m(S);
+      if (!t.test(b))
+        throw new TypeError(`cookie val is invalid: ${S}`);
+      d.push(`${R}=${b}`);
+    }
+    return d.join("; ");
+  }
+  function i(c, v, m) {
+    const d = typeof c == "object" ? c : { ...m, name: c, value: String(v) }, S = (typeof v == "object" ? v : m)?.encode || encodeURIComponent;
+    if (!e.test(d.name))
+      throw new TypeError(`argument name is invalid: ${d.name}`);
+    const b = d.value ? S(d.value) : "";
+    if (!t.test(b))
+      throw new TypeError(`argument val is invalid: ${d.value}`);
+    let E = d.name + "=" + b;
+    if (d.maxAge !== void 0) {
+      if (!Number.isInteger(d.maxAge))
+        throw new TypeError(`option maxAge is invalid: ${d.maxAge}`);
+      E += "; Max-Age=" + d.maxAge;
+    }
+    if (d.domain) {
+      if (!r.test(d.domain))
+        throw new TypeError(`option domain is invalid: ${d.domain}`);
+      E += "; Domain=" + d.domain;
+    }
+    if (d.path) {
+      if (!a.test(d.path))
+        throw new TypeError(`option path is invalid: ${d.path}`);
+      E += "; Path=" + d.path;
+    }
+    if (d.expires) {
+      if (!g(d.expires) || !Number.isFinite(d.expires.valueOf()))
+        throw new TypeError(`option expires is invalid: ${d.expires}`);
+      E += "; Expires=" + d.expires.toUTCString();
+    }
+    if (d.httpOnly && (E += "; HttpOnly"), d.secure && (E += "; Secure"), d.partitioned && (E += "; Partitioned"), d.priority)
+      switch (typeof d.priority == "string" ? d.priority.toLowerCase() : void 0) {
+        case "low":
+          E += "; Priority=Low";
+          break;
+        case "medium":
+          E += "; Priority=Medium";
+          break;
+        case "high":
+          E += "; Priority=High";
+          break;
+        default:
+          throw new TypeError(`option priority is invalid: ${d.priority}`);
+      }
+    if (d.sameSite)
+      switch (typeof d.sameSite == "string" ? d.sameSite.toLowerCase() : d.sameSite) {
+        case !0:
+        case "strict":
+          E += "; SameSite=Strict";
+          break;
+        case "lax":
+          E += "; SameSite=Lax";
+          break;
+        case "none":
+          E += "; SameSite=None";
+          break;
+        default:
+          throw new TypeError(`option sameSite is invalid: ${d.sameSite}`);
+      }
+    return E;
+  }
+  function u(c, v) {
+    const m = v?.decode || y, d = c.length, R = h(c, 0, d), S = p(c, 0, R), b = S === -1 ? { name: "", value: m(w(c, 0, R)) } : {
+      name: w(c, 0, S),
+      value: m(w(c, S + 1, R))
+    };
+    let E = R + 1;
+    for (; E < d; ) {
+      const _ = h(c, E, d), F = p(c, E, _), x = F === -1 ? w(c, E, _) : w(c, E, F), C = F === -1 ? void 0 : w(c, F + 1, _);
+      switch (x.toLowerCase()) {
+        case "httponly":
+          b.httpOnly = !0;
+          break;
+        case "secure":
+          b.secure = !0;
+          break;
+        case "partitioned":
+          b.partitioned = !0;
+          break;
+        case "domain":
+          b.domain = C;
+          break;
+        case "path":
+          b.path = C;
+          break;
+        case "max-age":
+          C && n.test(C) && (b.maxAge = Number(C));
+          break;
+        case "expires":
+          if (!C)
+            break;
+          const D = new Date(C);
+          Number.isFinite(D.valueOf()) && (b.expires = D);
+          break;
+        case "priority":
+          if (!C)
+            break;
+          const H = C.toLowerCase();
+          (H === "low" || H === "medium" || H === "high") && (b.priority = H);
+          break;
+        case "samesite":
+          if (!C)
+            break;
+          const M = C.toLowerCase();
+          (M === "lax" || M === "strict" || M === "none") && (b.sameSite = M);
+          break;
+      }
+      E = _ + 1;
+    }
+    return b;
+  }
+  function h(c, v, m) {
+    const d = c.indexOf(";", v);
+    return d === -1 ? m : d;
+  }
+  function p(c, v, m) {
+    const d = c.indexOf("=", v);
+    return d < m ? d : -1;
+  }
+  function w(c, v, m) {
+    let d = v, R = m;
+    do {
+      const S = c.charCodeAt(d);
+      if (S !== 32 && S !== 9)
+        break;
+    } while (++d < R);
+    for (; R > d; ) {
+      const S = c.charCodeAt(R - 1);
+      if (S !== 32 && S !== 9)
+        break;
+      R--;
+    }
+    return c.slice(d, R);
+  }
+  function y(c) {
+    if (c.indexOf("%") === -1)
+      return c;
+    try {
+      return decodeURIComponent(c);
+    } catch {
+      return c;
+    }
+  }
+  function g(c) {
+    return o.call(c) === "[object Date]";
+  }
+  return T;
+}
+var de = /* @__PURE__ */ ht(), L = { exports: {} }, ce;
+function pt() {
+  if (ce) return L.exports;
+  ce = 1;
+  var e = {
+    decodeValues: !0,
+    map: !1,
+    silent: !1
+  };
+  function t(s) {
+    return typeof s != "string" || s in {};
+  }
+  function r() {
+    return /* @__PURE__ */ Object.create(null);
+  }
+  function a(s) {
+    return typeof s == "string" && !!s.trim();
+  }
+  function n(s, i) {
+    var u = s.split(";").filter(a), h = u.shift(), p = o(h), w = p.name, y = p.value;
+    if (i = i ? Object.assign({}, e, i) : e, t(w))
+      return null;
+    try {
+      y = i.decodeValues ? decodeURIComponent(y) : y;
+    } catch (c) {
+      console.error(
+        "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
+        c
+      );
+    }
+    var g = r();
+    return g.name = w, g.value = y, u.forEach(function(c) {
+      var v = c.split("="), m = v.shift().trimLeft().toLowerCase();
+      if (!t(m)) {
+        var d = v.join("=");
+        if (m === "expires")
+          g.expires = new Date(d);
+        else if (m === "max-age") {
+          var R = parseInt(d, 10);
+          Number.isNaN(R) || (g.maxAge = R);
+        } else m === "secure" ? g.secure = !0 : m === "httponly" ? g.httpOnly = !0 : m === "samesite" ? g.sameSite = d : m === "partitioned" ? g.partitioned = !0 : m && (g[m] = d);
+      }
+    }), g;
+  }
+  function o(s) {
+    var i = "", u = "", h = s.split("=");
+    return h.length > 1 ? (i = h.shift(), u = h.join("=")) : u = s, { name: i, value: u };
+  }
+  function f(s, i) {
+    if (i = i ? Object.assign({}, e, i) : e, !s)
+      return i.map ? r() : [];
+    if (s.headers)
+      if (typeof s.headers.getSetCookie == "function")
+        s = s.headers.getSetCookie();
+      else if (s.headers["set-cookie"])
+        s = s.headers["set-cookie"];
+      else {
+        var u = s.headers[Object.keys(s.headers).find(function(p) {
+          return p.toLowerCase() === "set-cookie";
+        })];
+        !u && s.headers.cookie && !i.silent && console.warn(
+          "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+        ), s = u;
+      }
+    if (Array.isArray(s) || (s = [s]), i.map) {
+      var h = r();
+      return s.filter(a).reduce(function(p, w) {
+        var y = n(w, i);
+        return y && !t(y.name) && (p[y.name] = y), p;
+      }, h);
+    } else
+      return s.filter(a).map(function(p) {
+        return n(p, i);
+      }).filter(Boolean);
+  }
+  function l(s) {
+    if (Array.isArray(s))
+      return s;
+    if (typeof s != "string")
+      return [];
+    var i = [], u = 0, h, p, w, y, g;
+    function c() {
+      for (; u < s.length && /\s/.test(s.charAt(u)); )
+        u += 1;
+      return u < s.length;
+    }
+    function v() {
+      return p = s.charAt(u), p !== "=" && p !== ";" && p !== ",";
+    }
+    for (; u < s.length; ) {
+      for (h = u, g = !1; c(); )
+        if (p = s.charAt(u), p === ",") {
+          for (w = u, u += 1, c(), y = u; u < s.length && v(); )
+            u += 1;
+          u < s.length && s.charAt(u) === "=" ? (g = !0, u = y, i.push(s.substring(h, w)), h = u) : u = w + 1;
+        } else
+          u += 1;
+      (!g || u >= s.length) && i.push(s.substring(h, s.length));
+    }
+    return i;
+  }
+  return L.exports = f, L.exports.parse = f, L.exports.parseString = n, L.exports.splitCookiesString = l, L.exports;
+}
+var mt = /* @__PURE__ */ pt();
+function nr({
+  context: e,
+  url: t,
+  nonce: r
+}) {
+  typeof t == "string" && (t = new URL(t));
+  let { manifest: a, routeModules: n, criticalCss: o, serverHandoffString: f } = e, l = qe(
+    a.routes,
+    n,
+    e.future,
+    e.isSpaMode
+  );
+  e.staticHandlerContext.loaderData = {
+    ...e.staticHandlerContext.loaderData
+  };
+  for (let i of e.staticHandlerContext.matches) {
+    let u = i.route.id, h = n[u], p = e.manifest.routes[u];
+    h && p && ee(
+      u,
+      h.clientLoader,
+      p.hasLoader,
+      e.isSpaMode
+    ) && (h.HydrateFallback || !p.hasLoader) && delete e.staticHandlerContext.loaderData[u];
+  }
+  let s = Ce(l, e.staticHandlerContext);
+  return /* @__PURE__ */ k.createElement(k.Fragment, null, /* @__PURE__ */ k.createElement(
+    te.Provider,
+    {
+      value: {
+        manifest: a,
+        routeModules: n,
+        criticalCss: o,
+        serverHandoffString: f,
+        future: e.future,
+        ssr: e.ssr,
+        isSpaMode: e.isSpaMode,
+        routeDiscovery: e.routeDiscovery,
+        serializeError: e.serializeError,
+        renderMeta: e.renderMeta
+      }
+    },
+    /* @__PURE__ */ k.createElement(Ve, { location: s.state.location }, /* @__PURE__ */ k.createElement(
+      be,
+      {
+        router: s,
+        context: e.staticHandlerContext,
+        hydrate: !1
+      }
+    ))
+  ), e.serverHandoffStream ? /* @__PURE__ */ k.createElement(k.Suspense, null, /* @__PURE__ */ k.createElement(
+    We,
+    {
+      context: e,
+      identifier: 0,
+      reader: e.serverHandoffStream.getReader(),
+      textDecoder: new TextDecoder(),
+      nonce: r
+    }
+  )) : null);
+}
+function sr(e, t) {
+  return function({
+    initialEntries: a,
+    initialIndex: n,
+    hydrationData: o,
+    future: f
+  }) {
+    let l = k.useRef(), s = k.useRef();
+    if (l.current == null) {
+      s.current = {
+        future: {
+          unstable_subResourceIntegrity: f?.unstable_subResourceIntegrity === !0,
+          v8_middleware: f?.v8_middleware === !0,
+          unstable_trailingSlashAwareDataRequests: f?.unstable_trailingSlashAwareDataRequests === !0
+        },
+        manifest: {
+          routes: {},
+          entry: { imports: [], module: "" },
+          url: "",
+          version: ""
+        },
+        routeModules: {},
+        ssr: !1,
+        isSpaMode: !1,
+        routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" }
+      };
+      let i = Ae(
+        // @ts-expect-error `StubRouteObject` is stricter about `loader`/`action`
+        // types compared to `AgnosticRouteObject`
+        Je(e, (u) => u),
+        t !== void 0 ? t : f?.v8_middleware ? new K() : {},
+        s.current.manifest,
+        s.current.routeModules
+      );
+      l.current = Ke(i, {
+        initialEntries: a,
+        initialIndex: n,
+        hydrationData: o
+      });
+    }
+    return /* @__PURE__ */ k.createElement(te.Provider, { value: s.current }, /* @__PURE__ */ k.createElement(Qe, { router: l.current }));
+  };
+}
+function Ae(e, t, r, a, n) {
+  return e.map((o) => {
+    if (!o.id)
+      throw new Error(
+        "Expected a route.id in react-router processRoutes() function"
+      );
+    let f = {
+      id: o.id,
+      path: o.path,
+      index: o.index,
+      Component: o.Component ? rt(o.Component) : void 0,
+      HydrateFallback: o.HydrateFallback ? tt(o.HydrateFallback) : void 0,
+      ErrorBoundary: o.ErrorBoundary ? et(o.ErrorBoundary) : void 0,
+      action: o.action ? (s) => o.action({ ...s, context: t }) : void 0,
+      loader: o.loader ? (s) => o.loader({ ...s, context: t }) : void 0,
+      middleware: o.middleware ? o.middleware.map(
+        (s) => (...i) => s(
+          { ...i[0], context: t },
+          i[1]
+        )
+      ) : void 0,
+      handle: o.handle,
+      shouldRevalidate: o.shouldRevalidate
+    }, l = {
+      id: o.id,
+      path: o.path,
+      index: o.index,
+      parentId: n,
+      hasAction: o.action != null,
+      hasLoader: o.loader != null,
+      // When testing routes, you should be stubbing loader/action/middleware,
+      // not trying to re-implement the full loader/clientLoader/SSR/hydration
+      // flow. That is better tested via E2E tests.
+      hasClientAction: !1,
+      hasClientLoader: !1,
+      hasClientMiddleware: !1,
+      hasErrorBoundary: o.ErrorBoundary != null,
+      // any need for these?
+      module: "build/stub-path-to-module.js",
+      clientActionModule: void 0,
+      clientLoaderModule: void 0,
+      clientMiddlewareModule: void 0,
+      hydrateFallbackModule: void 0
+    };
+    return r.routes[f.id] = l, a[o.id] = {
+      default: f.Component || at,
+      ErrorBoundary: f.ErrorBoundary || void 0,
+      handle: o.handle,
+      links: o.links,
+      meta: o.meta,
+      shouldRevalidate: o.shouldRevalidate
+    }, o.children && (f.children = Ae(
+      o.children,
+      t,
+      r,
+      a,
+      f.id
+    )), f;
+  });
+}
+var ae = /* @__PURE__ */ new TextEncoder(), yt = async (e, t) => {
+  let r = ae.encode(e), a = await De(t, ["sign"]), n = await crypto.subtle.sign("HMAC", a, r), o = btoa(String.fromCharCode(...new Uint8Array(n))).replace(
+    /=+$/,
+    ""
+  );
+  return e + "." + o;
+}, wt = async (e, t) => {
+  let r = e.lastIndexOf("."), a = e.slice(0, r), n = e.slice(r + 1), o = ae.encode(a), f = await De(t, ["verify"]);
+  try {
+    let l = gt(atob(n));
+    return await crypto.subtle.verify("HMAC", f, l, o) ? a : !1;
+  } catch {
+    return !1;
+  }
+}, De = async (e, t) => crypto.subtle.importKey(
+  "raw",
+  ae.encode(e),
+  { name: "HMAC", hash: "SHA-256" },
+  !1,
+  t
+);
+function gt(e) {
+  let t = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    t[r] = e.charCodeAt(r);
+  return t;
+}
+var He = (e, t = {}) => {
+  let { secrets: r = [], ...a } = {
+    path: "/",
+    sameSite: "lax",
+    ...t
+  };
+  return bt(e, a.expires), {
+    get name() {
+      return e;
+    },
+    get isSigned() {
+      return r.length > 0;
+    },
+    get expires() {
+      return typeof a.maxAge < "u" ? new Date(Date.now() + a.maxAge * 1e3) : a.expires;
+    },
+    async parse(n, o) {
+      if (!n) return null;
+      let f = de.parse(n, { ...a, ...o });
+      if (e in f) {
+        let l = f[e];
+        return typeof l == "string" && l !== "" ? await St(l, r) : "";
+      } else
+        return null;
+    },
+    async serialize(n, o) {
+      return de.serialize(
+        e,
+        n === "" ? "" : await Rt(n, r),
+        {
+          ...a,
+          ...o
+        }
+      );
+    }
+  };
+}, Te = (e) => e != null && typeof e.name == "string" && typeof e.isSigned == "boolean" && typeof e.parse == "function" && typeof e.serialize == "function";
+async function Rt(e, t) {
+  let r = vt(e);
+  return t.length > 0 && (r = await yt(r, t[0])), r;
+}
+async function St(e, t) {
+  if (t.length > 0) {
+    for (let r of t) {
+      let a = await wt(e, r);
+      if (a !== !1)
+        return fe(a);
+    }
+    return null;
+  }
+  return fe(e);
+}
+function vt(e) {
+  return btoa(Ct(encodeURIComponent(JSON.stringify(e))));
+}
+function fe(e) {
+  try {
+    return JSON.parse(decodeURIComponent(Et(atob(e))));
+  } catch {
+    return {};
+  }
+}
+function Et(e) {
+  let t = e.toString(), r = "", a = 0, n, o;
+  for (; a < t.length; )
+    n = t.charAt(a++), /[\w*+\-./@]/.exec(n) ? r += n : (o = n.charCodeAt(0), o < 256 ? r += "%" + he(o, 2) : r += "%u" + he(o, 4).toUpperCase());
+  return r;
+}
+function he(e, t) {
+  let r = e.toString(16);
+  for (; r.length < t; ) r = "0" + r;
+  return r;
+}
+function Ct(e) {
+  let t = e.toString(), r = "", a = 0, n, o;
+  for (; a < t.length; ) {
+    if (n = t.charAt(a++), n === "%") {
+      if (t.charAt(a) === "u") {
+        if (o = t.slice(a + 1, a + 5), /^[\da-f]{4}$/i.exec(o)) {
+          r += String.fromCharCode(parseInt(o, 16)), a += 5;
+          continue;
+        }
+      } else if (o = t.slice(a, a + 2), /^[\da-f]{2}$/i.exec(o)) {
+        r += String.fromCharCode(parseInt(o, 16)), a += 2;
+        continue;
+      }
+    }
+    r += n;
+  }
+  return r;
+}
+function bt(e, t) {
+  ke(
+    !t,
+    `The "${e}" cookie has an "expires" property set. This will cause the expires value to not be updated when the session is committed. Instead, you should set the expires value when serializing the cookie. You can use \`commitSession(session, { expires })\` if using a session storage object, or \`cookie.serialize("value", { expires })\` if you're using the cookie directly.`
+  );
+}
+function xt(e) {
+  return Object.keys(e).reduce((t, r) => {
+    let a = e[r];
+    return a && (t[r] = a.module), t;
+  }, {});
+}
+var _t = /* @__PURE__ */ ((e) => (e.Development = "development", e.Production = "production", e.Test = "test", e))(_t || {});
+function kt(e) {
+  return e === "development" || e === "production" || e === "test";
+}
+function V(e, t) {
+  if (e instanceof Error && t !== "development") {
+    let r = new Error("Unexpected Server Error");
+    return r.stack = void 0, r;
+  }
+  return e;
+}
+function z(e, t) {
+  return Object.entries(e).reduce((r, [a, n]) => Object.assign(r, { [a]: V(n, t) }), {});
+}
+function Fe(e, t) {
+  let r = V(e, t);
+  return {
+    message: r.message,
+    stack: r.stack
+  };
+}
+function pe(e, t) {
+  if (!e) return null;
+  let r = Object.entries(e), a = {};
+  for (let [n, o] of r)
+    if (P(o))
+      a[n] = { ...o, __type: "RouteErrorResponse" };
+    else if (o instanceof Error) {
+      let f = V(o, t);
+      a[n] = {
+        message: f.message,
+        stack: f.stack,
+        __type: "Error",
+        // If this is a subclass (i.e., ReferenceError), send up the type so we
+        // can re-create the same type during hydration.  This will only apply
+        // in dev mode since all production errors are sanitized to normal
+        // Error instances
+        ...f.name !== "Error" ? {
+          __subType: f.name
+        } : {}
+      };
+    } else
+      a[n] = o;
+  return a;
+}
+function G(e, t, r) {
+  let a = xe(
+    e,
+    t,
+    r
+  );
+  return a ? a.map((n) => ({
+    params: n.params,
+    pathname: n.pathname,
+    route: n.route
+  })) : null;
+}
+async function me(e, t) {
+  let r = await e({
+    request: Dt(At(t.request)),
+    params: t.params,
+    context: t.context,
+    unstable_pattern: t.unstable_pattern
+  });
+  if (ut(r) && r.init && r.init.status && re(r.init.status))
+    throw new Response(null, r.init);
+  return r;
+}
+function At(e) {
+  let t = new URL(e.url), r = t.searchParams.getAll("index");
+  t.searchParams.delete("index");
+  let a = [];
+  for (let o of r)
+    o && a.push(o);
+  for (let o of a)
+    t.searchParams.append("index", o);
+  let n = {
+    method: e.method,
+    body: e.body,
+    headers: e.headers,
+    signal: e.signal
+  };
+  return n.body && (n.duplex = "half"), new Request(t.href, n);
+}
+function Dt(e) {
+  let t = new URL(e.url);
+  t.searchParams.delete("_routes");
+  let r = {
+    method: e.method,
+    body: e.body,
+    headers: e.headers,
+    signal: e.signal
+  };
+  return r.body && (r.duplex = "half"), new Request(t.href, r);
+}
+function j(e, t) {
+  if (e === !1 || e === null || typeof e > "u")
+    throw console.error(
+      "The following error is a bug in React Router; please open an issue! https://github.com/remix-run/react-router/issues/new/choose"
+    ), new Error(t);
+}
+var Pe = "__reactRouterDevServerHooks";
+function or(e) {
+  globalThis[Pe] = e;
+}
+function W() {
+  return globalThis[Pe];
+}
+function Ne(e, t) {
+  if (typeof process < "u")
+    try {
+      if (process.env?.IS_RR_BUILD_REQUEST === "yes")
+        return e.headers.get(t);
+    } catch {
+    }
+  return null;
+}
+function Ue(e) {
+  let t = {};
+  return Object.values(e).forEach((r) => {
+    if (r) {
+      let a = r.parentId || "";
+      t[a] || (t[a] = []), t[a].push(r);
+    }
+  }), t;
+}
+function Le(e, t = "", r = Ue(e)) {
+  return (r[t] || []).map((a) => ({
+    ...a,
+    children: Le(e, a.id, r)
+  }));
+}
+function Oe(e, t, r = "", a = Ue(e)) {
+  return (a[r] || []).map((n) => {
+    let o = {
+      // Always include root due to default boundaries
+      hasErrorBoundary: n.id === "root" || n.module.ErrorBoundary != null,
+      id: n.id,
+      path: n.path,
+      middleware: n.module.middleware,
+      // Need to use RR's version in the param typed here to permit the optional
+      // context even though we know it'll always be provided in remix
+      loader: n.module.loader ? async (f) => {
+        let l = Ne(
+          f.request,
+          "X-React-Router-Prerender-Data"
+        );
+        if (l != null) {
+          let i = l && decodeURI(l);
+          j(i, "Missing prerendered data for route");
+          let u = new TextEncoder().encode(i), h = new ReadableStream({
+            start(y) {
+              y.enqueue(u), y.close();
+            }
+          }), w = (await nt(h, global)).value;
+          if (w && I in w) {
+            let y = w[I], g = { status: y.status };
+            throw y.reload ? st(y.redirect, g) : y.replace ? ot(y.redirect, g) : it(y.redirect, g);
+          } else {
+            j(
+              w && n.id in w,
+              "Unable to decode prerendered data"
+            );
+            let y = w[n.id];
+            return j(
+              "data" in y,
+              "Unable to process prerendered data"
+            ), y.data;
+          }
+        }
+        return await me(n.module.loader, f);
+      } : void 0,
+      action: n.module.action ? (f) => me(n.module.action, f) : void 0,
+      handle: n.module.handle
+    };
+    return n.index ? {
+      index: !0,
+      ...o
+    } : {
+      caseSensitive: n.caseSensitive,
+      children: Oe(
+        e,
+        t,
+        n.id,
+        a
+      ),
+      ...o
+    };
+  });
+}
+function ye(e) {
+  return Q(JSON.stringify(e));
+}
+function ne(e, t) {
+  return Ht(e, (r) => {
+    let a = t.routes[r.route.id];
+    return j(a, `Route with id "${r.route.id}" not found in build`), a.module.headers;
+  });
+}
+function Ht(e, t, r) {
+  let a = e.errors ? e.matches.findIndex((l) => e.errors[l.route.id]) : -1, n = a >= 0 ? e.matches.slice(0, a + 1) : e.matches, o;
+  if (a >= 0) {
+    let { actionHeaders: l, actionData: s, loaderHeaders: i, loaderData: u } = e;
+    e.matches.slice(a).some((h) => {
+      let p = h.route.id;
+      return l[p] && (!s || !s.hasOwnProperty(p)) ? o = l[p] : i[p] && !u.hasOwnProperty(p) && (o = i[p]), o != null;
+    });
+  }
+  const f = new Headers(r);
+  return n.reduce((l, s, i) => {
+    let { id: u } = s.route, h = e.loaderHeaders[u] || new Headers(), p = e.actionHeaders[u] || new Headers(), w = o != null && i === n.length - 1, y = w && o !== h && o !== p, g = t(s);
+    if (g == null) {
+      let v = new Headers(l);
+      return y && N(o, v), N(p, v), N(h, v), v;
+    }
+    let c = new Headers(
+      typeof g == "function" ? g({
+        loaderHeaders: h,
+        parentHeaders: l,
+        actionHeaders: p,
+        errorHeaders: w ? o : void 0
+      }) : g
+    );
+    return y && N(o, c), N(p, c), N(h, c), N(l, c), c;
+  }, new Headers(f));
+}
+function N(e, t) {
+  let r = e.get("Set-Cookie");
+  if (r) {
+    let a = mt.splitCookiesString(r), n = new Set(t.getSetCookie());
+    a.forEach((o) => {
+      n.has(o) || t.append("Set-Cookie", o);
+    });
+  }
+}
+function Ie(e, t) {
+  let r = e.get("origin"), a = null;
+  try {
+    a = typeof r == "string" && r !== "null" ? new URL(r).host : r;
+  } catch {
+    throw new Error(
+      "`origin` header is not a valid URL. Aborting the action."
+    );
+  }
+  let n = Pt(e);
+  if (a && (!n || a !== n.value) && !Ft(a, t))
+    throw n ? new Error(
+      `${n.type} header does not match \`origin\` header from a forwarded action request. Aborting the action.`
+    ) : new Error(
+      "`x-forwarded-host` or `host` headers are not provided. One of these is needed to compare the `origin` header from a forwarded action request. Aborting the action."
+    );
+}
+function Tt(e, t) {
+  const r = e.split("."), a = t.split(".");
+  if (a.length < 1 || r.length < a.length)
+    return !1;
+  for (; a.length; ) {
+    const n = a.pop(), o = r.pop();
+    switch (n) {
+      case "":
+        return !1;
+      case "*": {
+        if (o)
+          continue;
+        return !1;
+      }
+      case "**":
+        return a.length > 0 ? !1 : o !== void 0;
+      default:
+        if (o !== n)
+          return !1;
+    }
+  }
+  return r.length === 0;
+}
+function Ft(e, t = []) {
+  return t.some(
+    (r) => r && (r === e || Tt(e, r))
+  );
+}
+function Pt(e) {
+  let r = e.get("x-forwarded-host")?.split(",")[0]?.trim(), a = e.get("host");
+  return r ? {
+    type: "x-forwarded-host",
+    value: r
+  } : a ? {
+    type: "host",
+    value: a
+  } : void 0;
+}
+var Be = /* @__PURE__ */ new Set([
+  ...ct,
+  304
+]);
+async function Nt(e, t, r, a, n, o, f) {
+  try {
+    try {
+      Ie(
+        a.headers,
+        Array.isArray(e.allowedActionOrigins) ? e.allowedActionOrigins : []
+      );
+    } catch {
+      return s(new Error("Bad Request"), 400);
+    }
+    let u = new Request(n, {
+      method: a.method,
+      body: a.body,
+      headers: a.headers,
+      signal: a.signal,
+      ...a.body ? { duplex: "half" } : void 0
+    }), h = await r.query(u, {
+      requestContext: o,
+      skipLoaderErrorBubbling: !0,
+      skipRevalidation: !0,
+      generateMiddlewareResponse: e.future.v8_middleware ? async (p) => {
+        try {
+          let w = await p(u);
+          return l(w);
+        } catch (w) {
+          return s(w);
+        }
+      } : void 0
+    });
+    return l(h);
+  } catch (u) {
+    return s(u);
+  }
+  function l(u) {
+    return U(u) ? u : i(u);
+  }
+  function s(u, h = 500) {
+    return f(u), B(a, e, t, {
+      result: { error: u },
+      headers: new Headers(),
+      status: h
+    });
+  }
+  function i(u) {
+    let h = ne(u, e);
+    if (re(u.statusCode) && h.has("Location"))
+      return new Response(null, { status: u.statusCode, headers: h });
+    u.errors && (Object.values(u.errors).forEach((w) => {
+      (!P(w) || w.error) && f(w);
+    }), u.errors = z(u.errors, t));
+    let p;
+    return u.errors ? p = { error: Object.values(u.errors)[0] } : p = {
+      data: Object.values(u.actionData || {})[0]
+    }, B(a, e, t, {
+      result: p,
+      headers: h,
+      status: u.statusCode
+    });
+  }
+}
+async function Ut(e, t, r, a, n, o, f) {
+  let l = new URL(a.url).searchParams.get("_routes"), s = l ? new Set(l.split(",")) : null;
+  try {
+    let p = new Request(n, {
+      headers: a.headers,
+      signal: a.signal
+    }), w = await r.query(p, {
+      requestContext: o,
+      filterMatchesToLoad: (y) => !s || s.has(y.route.id),
+      skipLoaderErrorBubbling: !0,
+      generateMiddlewareResponse: e.future.v8_middleware ? async (y) => {
+        try {
+          let g = await y(p);
+          return i(g);
+        } catch (g) {
+          return u(g);
+        }
+      } : void 0
+    });
+    return i(w);
+  } catch (p) {
+    return u(p);
+  }
+  function i(p) {
+    return U(p) ? p : h(p);
+  }
+  function u(p) {
+    return f(p), B(a, e, t, {
+      result: { error: p },
+      headers: new Headers(),
+      status: 500
+    });
+  }
+  function h(p) {
+    let w = ne(p, e);
+    if (re(p.statusCode) && w.has("Location"))
+      return new Response(null, { status: p.statusCode, headers: w });
+    p.errors && (Object.values(p.errors).forEach((c) => {
+      (!P(c) || c.error) && f(c);
+    }), p.errors = z(p.errors, t));
+    let y = {}, g = new Set(
+      p.matches.filter(
+        (c) => s ? s.has(c.route.id) : c.route.loader != null
+      ).map((c) => c.route.id)
+    );
+    if (p.errors)
+      for (let [c, v] of Object.entries(p.errors))
+        y[c] = { error: v };
+    for (let [c, v] of Object.entries(p.loaderData))
+      !(c in y) && g.has(c) && (y[c] = { data: v });
+    return B(a, e, t, {
+      result: y,
+      headers: w,
+      status: p.statusCode
+    });
+  }
+}
+function B(e, t, r, {
+  result: a,
+  headers: n,
+  status: o
+}) {
+  let f = new Headers(n);
+  return f.set("X-Remix-Response", "yes"), Be.has(o) ? new Response(null, { status: o, headers: f }) : (f.set("Content-Type", "text/x-script"), f.delete("Content-Length"), new Response(
+    Y(
+      a,
+      e.signal,
+      t.entry.module.streamTimeout,
+      r
+    ),
+    {
+      status: o || 200,
+      headers: f
+    }
+  ));
+}
+function we(e, t, r, a) {
+  let n = Lt(
+    e.status,
+    e.headers,
+    r.basename
+  ), o = new Headers(e.headers);
+  return o.delete("Location"), o.set("Content-Type", "text/x-script"), B(t, r, a, {
+    result: t.method === "GET" ? { [I]: n } : n,
+    headers: o,
+    status: _e
+  });
+}
+function Lt(e, t, r) {
+  let a = t.get("Location");
+  return r && (a = $(a, r) || a), {
+    redirect: a,
+    status: e,
+    revalidate: (
+      // Technically X-Remix-Revalidate isn't needed here - that was an implementation
+      // detail of ?_data requests as our way to tell the front end to revalidate when
+      // we didn't have a response body to include that information in.
+      // With single fetch, we tell the front end via this revalidate boolean field.
+      // However, we're respecting it for now because it may be something folks have
+      // used in their own responses
+      // TODO(v3): Consider removing or making this official public API
+      t.has("X-Remix-Revalidate") || t.has("Set-Cookie")
+    ),
+    reload: t.has("X-Remix-Reload-Document"),
+    replace: t.has("X-Remix-Replace")
+  };
+}
+function Y(e, t, r, a) {
+  let n = new AbortController(), o = setTimeout(
+    () => n.abort(new Error("Server Timeout")),
+    typeof r == "number" ? r : 4950
+  ), f = () => clearTimeout(o);
+  return t.addEventListener("abort", f), ft(e, {
+    signal: n.signal,
+    onComplete: f,
+    plugins: [
+      (l) => {
+        if (l instanceof Error) {
+          let { name: s, message: i, stack: u } = a === "production" ? V(l, a) : l;
+          return ["SanitizedError", s, i, u];
+        }
+        if (l instanceof O) {
+          let { data: s, status: i, statusText: u } = l;
+          return ["ErrorResponse", s, i, u];
+        }
+        if (l && typeof l == "object" && I in l)
+          return ["SingleFetchRedirect", l[I]];
+      }
+    ],
+    postPlugins: [
+      (l) => {
+        if (l && typeof l == "object")
+          return [
+            "SingleFetchClassInstance",
+            Object.fromEntries(Object.entries(l))
+          ];
+      },
+      () => ["SingleFetchFallback"]
+    ]
+  });
+}
+function ge(e, t) {
+  let r = Le(e.routes), a = Oe(e.routes, e.future), n = kt(t) ? t : "production", o = Ye(a, {
+    basename: e.basename,
+    unstable_instrumentations: e.entry.module.unstable_instrumentations
+  }), f = e.entry.module.handleError || ((s, { request: i }) => {
+    n !== "test" && !i.signal.aborted && console.error(
+      // @ts-expect-error This is "private" from users but intended for internal use
+      P(s) && s.error ? s.error : s
+    );
+  }), l = async (s, i) => {
+    let u = {}, h, p = (R) => {
+      t === "development" && W()?.processRequestError?.(R), f(R, {
+        context: h,
+        params: u,
+        request: s
+      });
+    };
+    if (e.future.v8_middleware) {
+      if (i && !(i instanceof K)) {
+        let R = new Error(
+          "Invalid `context` value provided to `handleRequest`. When middleware is enabled you must return an instance of `RouterContextProvider` from your `getLoadContext` function."
+        );
+        return p(R), q(R, n);
+      }
+      h = i || new K();
+    } else
+      h = i || {};
+    let w = new URL(s.url), y = e.basename || "/", g = w.pathname;
+    e.future.unstable_trailingSlashAwareDataRequests ? g.endsWith("/_.data") ? g = g.replace(/_.data$/, "") : g = g.replace(/\.data$/, "") : ($(g, y) === "/_root.data" ? g = y : g.endsWith(".data") && (g = g.replace(/\.data$/, "")), $(g, y) !== "/" && g.endsWith("/") && (g = g.slice(0, -1)));
+    let c = Ne(s, "X-React-Router-SPA-Mode") === "yes";
+    if (!e.ssr) {
+      let R = decodeURI(g);
+      if (y !== "/") {
+        let S = $(R, y);
+        if (S == null)
+          return f(
+            new O(
+              404,
+              "Not Found",
+              `Refusing to prerender the \`${R}\` path because it does not start with the basename \`${y}\``
+            ),
+            {
+              context: h,
+              params: u,
+              request: s
+            }
+          ), new Response("Not Found", {
+            status: 404,
+            statusText: "Not Found"
+          });
+        R = S;
+      }
+      if (e.prerender.length === 0)
+        c = !0;
+      else if (!e.prerender.includes(R) && !e.prerender.includes(R + "/")) {
+        if (w.pathname.endsWith(".data"))
+          return f(
+            new O(
+              404,
+              "Not Found",
+              `Refusing to SSR the path \`${R}\` because \`ssr:false\` is set and the path is not included in the \`prerender\` config, so in production the path will be a 404.`
+            ),
+            {
+              context: h,
+              params: u,
+              request: s
+            }
+          ), new Response("Not Found", {
+            status: 404,
+            statusText: "Not Found"
+          });
+        c = !0;
+      }
+    }
+    let v = lt(
+      e.routeDiscovery.manifestPath,
+      y
+    );
+    if (w.pathname === v)
+      try {
+        return await Ot(e, r, w);
+      } catch (R) {
+        return p(R), new Response("Unknown Server Error", { status: 500 });
+      }
+    let m = G(r, g, e.basename);
+    m && m.length > 0 && Object.assign(u, m[0].params);
+    let d;
+    if (w.pathname.endsWith(".data")) {
+      let R = new URL(s.url);
+      R.pathname = g;
+      let S = G(
+        r,
+        R.pathname,
+        e.basename
+      );
+      d = await It(
+        n,
+        e,
+        o,
+        s,
+        R,
+        h,
+        p
+      ), le(d) && (d = we(
+        d,
+        s,
+        e,
+        n
+      )), e.entry.module.handleDataRequest && (d = await e.entry.module.handleDataRequest(d, {
+        context: h,
+        params: S ? S[0].params : {},
+        request: s
+      }), le(d) && (d = we(
+        d,
+        s,
+        e,
+        n
+      )));
+    } else if (!c && m && m[m.length - 1].route.module.default == null && m[m.length - 1].route.module.ErrorBoundary == null)
+      d = await Mt(
+        n,
+        e,
+        o,
+        m.slice(-1)[0].route.id,
+        s,
+        h,
+        p
+      );
+    else {
+      let { pathname: R } = w, S;
+      e.unstable_getCriticalCss ? S = await e.unstable_getCriticalCss({ pathname: R }) : t === "development" && W()?.getCriticalCss && (S = await W()?.getCriticalCss?.(R)), d = await Bt(
+        n,
+        e,
+        o,
+        s,
+        h,
+        p,
+        c,
+        S
+      );
+    }
+    return s.method === "HEAD" ? new Response(null, {
+      headers: d.headers,
+      status: d.status,
+      statusText: d.statusText
+    }) : d;
+  };
+  return e.entry.module.unstable_instrumentations && (l = Ze(
+    l,
+    e.entry.module.unstable_instrumentations.map((s) => s.handler).filter(Boolean)
+  )), {
+    routes: r,
+    dataRoutes: a,
+    serverMode: n,
+    staticHandler: o,
+    errorHandler: f,
+    requestHandler: l
+  };
+}
+var ir = (e, t) => {
+  let r, a, n, o, f, l;
+  return async function(i, u) {
+    if (r = typeof e == "function" ? await e() : e, typeof e == "function") {
+      let h = ge(r, t);
+      a = h.routes, n = h.serverMode, o = h.staticHandler, f = h.errorHandler, l = h.requestHandler;
+    } else if (!a || !n || !o || !f || !l) {
+      let h = ge(r, t);
+      a = h.routes, n = h.serverMode, o = h.staticHandler, f = h.errorHandler, l = h.requestHandler;
+    }
+    return l(i, u);
+  };
+};
+async function Ot(e, t, r) {
+  if (e.assets.version !== r.searchParams.get("version"))
+    return new Response(null, {
+      status: 204,
+      headers: {
+        "X-Remix-Reload-Document": "true"
+      }
+    });
+  let a = {};
+  if (r.searchParams.has("paths")) {
+    let n = /* @__PURE__ */ new Set();
+    (r.searchParams.get("paths") || "").split(",").filter(Boolean).forEach((l) => {
+      l.startsWith("/") || (l = `/${l}`);
+      let s = l.split("/").slice(1);
+      s.forEach((i, u) => {
+        let h = s.slice(0, u + 1).join("/");
+        n.add(`/${h}`);
+      });
+    });
+    for (let l of n) {
+      let s = G(t, l, e.basename);
+      if (s)
+        for (let i of s) {
+          let u = i.route.id, h = e.assets.routes[u];
+          h && (a[u] = h);
+        }
+    }
+    return Response.json(a, {
+      headers: {
+        "Cache-Control": "public, max-age=31536000, immutable"
+      }
+    });
+  }
+  return new Response("Invalid Request", { status: 400 });
+}
+async function It(e, t, r, a, n, o, f) {
+  return a.method !== "GET" ? await Nt(
+    t,
+    e,
+    r,
+    a,
+    n,
+    o,
+    f
+  ) : await Ut(
+    t,
+    e,
+    r,
+    a,
+    n,
+    o,
+    f
+  );
+}
+async function Bt(e, t, r, a, n, o, f, l) {
+  try {
+    if (a.method === "POST")
+      try {
+        Ie(
+          a.headers,
+          Array.isArray(t.allowedActionOrigins) ? t.allowedActionOrigins : []
+        );
+      } catch (u) {
+        return o(u), new Response("Bad Request", { status: 400 });
+      }
+    let i = await r.query(a, {
+      requestContext: n,
+      generateMiddlewareResponse: t.future.v8_middleware ? async (u) => {
+        try {
+          let h = await u(a);
+          return U(h) || (h = await s(h, f)), h;
+        } catch (h) {
+          return o(h), new Response(null, { status: 500 });
+        }
+      } : void 0
+    });
+    return U(i) || (i = await s(i, f)), i;
+  } catch (i) {
+    return o(i), new Response(null, { status: 500 });
+  }
+  async function s(i, u) {
+    let h = ne(i, t);
+    if (Be.has(i.statusCode))
+      return new Response(null, { status: i.statusCode, headers: h });
+    i.errors && (Object.values(i.errors).forEach((c) => {
+      (!P(c) || c.error) && o(c);
+    }), i.errors = z(i.errors, e));
+    let p = {
+      loaderData: i.loaderData,
+      actionData: i.actionData,
+      errors: pe(i.errors, e)
+    }, w = {
+      basename: t.basename,
+      future: t.future,
+      routeDiscovery: t.routeDiscovery,
+      ssr: t.ssr,
+      isSpaMode: u
+    }, y = {
+      manifest: t.assets,
+      routeModules: xt(t.routes),
+      staticHandlerContext: i,
+      criticalCss: l,
+      serverHandoffString: ye({
+        ...w,
+        criticalCss: l
+      }),
+      serverHandoffStream: Y(
+        p,
+        a.signal,
+        t.entry.module.streamTimeout,
+        e
+      ),
+      renderMeta: {},
+      future: t.future,
+      ssr: t.ssr,
+      routeDiscovery: t.routeDiscovery,
+      isSpaMode: u,
+      serializeError: (c) => Fe(c, e)
+    }, g = t.entry.module.default;
+    try {
+      return await g(
+        a,
+        i.statusCode,
+        h,
+        y,
+        n
+      );
+    } catch (c) {
+      o(c);
+      let v = c;
+      if (U(c))
+        try {
+          let d = await jt(c);
+          v = new O(
+            c.status,
+            c.statusText,
+            d
+          );
+        } catch {
+        }
+      i = dt(
+        r.dataRoutes,
+        i,
+        v
+      ), i.errors && (i.errors = z(i.errors, e));
+      let m = {
+        loaderData: i.loaderData,
+        actionData: i.actionData,
+        errors: pe(i.errors, e)
+      };
+      y = {
+        ...y,
+        staticHandlerContext: i,
+        serverHandoffString: ye(w),
+        serverHandoffStream: Y(
+          m,
+          a.signal,
+          t.entry.module.streamTimeout,
+          e
+        ),
+        renderMeta: {}
+      };
+      try {
+        return await g(
+          a,
+          i.statusCode,
+          h,
+          y,
+          n
+        );
+      } catch (d) {
+        return o(d), q(d, e);
+      }
+    }
+  }
+}
+async function Mt(e, t, r, a, n, o, f) {
+  try {
+    let i = await r.queryRoute(n, {
+      routeId: a,
+      requestContext: o,
+      generateMiddlewareResponse: t.future.v8_middleware ? async (u) => {
+        try {
+          let h = await u(n);
+          return l(h);
+        } catch (h) {
+          return s(h);
+        }
+      } : void 0
+    });
+    return l(i);
+  } catch (i) {
+    return s(i);
+  }
+  function l(i) {
+    return U(i) ? i : typeof i == "string" ? new Response(i) : Response.json(i);
+  }
+  function s(i) {
+    if (U(i))
+      return i;
+    if (P(i))
+      return f(i), $t(i, e);
+    if (i instanceof Error && i.message === "Expected a response from queryRoute") {
+      let u = new Error(
+        "Expected a Response to be returned from resource route handler"
+      );
+      return f(u), q(u, e);
+    }
+    return f(i), q(i, e);
+  }
+}
+function $t(e, t) {
+  return Response.json(
+    Fe(
+      // @ts-expect-error This is "private" from users but intended for internal use
+      e.error || new Error("Unexpected Server Error"),
+      t
+    ),
+    {
+      status: e.status,
+      statusText: e.statusText
+    }
+  );
+}
+function q(e, t) {
+  let r = "Unexpected Server Error";
+  return t !== "production" && (r += `
+
+${String(e)}`), new Response(r, {
+    status: 500,
+    headers: {
+      "Content-Type": "text/plain"
+    }
+  });
+}
+function jt(e) {
+  let t = e.headers.get("Content-Type");
+  return t && /\bapplication\/json\b/.test(t) ? e.body == null ? null : e.json() : e.text();
+}
+function X(e) {
+  return `__flash_${e}__`;
+}
+var Me = (e = {}, t = "") => {
+  let r = new Map(Object.entries(e));
+  return {
+    get id() {
+      return t;
+    },
+    get data() {
+      return Object.fromEntries(r);
+    },
+    has(a) {
+      return r.has(a) || r.has(X(a));
+    },
+    get(a) {
+      if (r.has(a)) return r.get(a);
+      let n = X(a);
+      if (r.has(n)) {
+        let o = r.get(n);
+        return r.delete(n), o;
+      }
+    },
+    set(a, n) {
+      r.set(a, n);
+    },
+    flash(a, n) {
+      r.set(X(a), n);
+    },
+    unset(a) {
+      r.delete(a);
+    }
+  };
+}, lr = (e) => e != null && typeof e.id == "string" && typeof e.data < "u" && typeof e.has == "function" && typeof e.get == "function" && typeof e.set == "function" && typeof e.flash == "function" && typeof e.unset == "function";
+function zt({
+  cookie: e,
+  createData: t,
+  readData: r,
+  updateData: a,
+  deleteData: n
+}) {
+  let o = Te(e) ? e : He(e?.name || "__session", e);
+  return $e(o), {
+    async getSession(f, l) {
+      let s = f && await o.parse(f, l), i = s && await r(s);
+      return Me(i || {}, s || "");
+    },
+    async commitSession(f, l) {
+      let { id: s, data: i } = f, u = l?.maxAge != null ? new Date(Date.now() + l.maxAge * 1e3) : l?.expires != null ? l.expires : o.expires;
+      return s ? await a(s, i, u) : s = await t(i, u), o.serialize(s, l);
+    },
+    async destroySession(f, l) {
+      return await n(f.id), o.serialize("", {
+        ...l,
+        maxAge: void 0,
+        expires: /* @__PURE__ */ new Date(0)
+      });
+    }
+  };
+}
+function $e(e) {
+  ke(
+    e.isSigned,
+    `The "${e.name}" cookie is not signed, but session cookies should be signed to prevent tampering on the client before they are sent back to the server. See https://reactrouter.com/explanation/sessions-and-cookies#signing-cookies for more information.`
+  );
+}
+function ur({ cookie: e } = {}) {
+  let t = Te(e) ? e : He(e?.name || "__session", e);
+  return $e(t), {
+    async getSession(r, a) {
+      return Me(
+        r && await t.parse(r, a) || {}
+      );
+    },
+    async commitSession(r, a) {
+      let n = await t.serialize(r.data, a);
+      if (n.length > 4096)
+        throw new Error(
+          "Cookie length will exceed browser maximum. Length: " + n.length
+        );
+      return n;
+    },
+    async destroySession(r, a) {
+      return t.serialize("", {
+        ...a,
+        maxAge: void 0,
+        expires: /* @__PURE__ */ new Date(0)
+      });
+    }
+  };
+}
+function dr({ cookie: e } = {}) {
+  let t = /* @__PURE__ */ new Map();
+  return zt({
+    cookie: e,
+    async createData(r, a) {
+      let n = Math.random().toString(36).substring(2, 10);
+      return t.set(n, { data: r, expires: a }), n;
+    },
+    async readData(r) {
+      if (t.has(r)) {
+        let { data: a, expires: n } = t.get(r);
+        if (!n || n > /* @__PURE__ */ new Date())
+          return a;
+        n && t.delete(r);
+      }
+      return null;
+    },
+    async updateData(r, a, n) {
+      t.set(r, { data: a, expires: n });
+    },
+    async deleteData(r) {
+      t.delete(r);
+    }
+  });
+}
+function cr(e, ...t) {
+  let r = t[0], a = qt(e).replace(
+    /\/:([\w-]+)(\?)?/g,
+    // same regex as in .\router\utils.ts: compilePath().
+    (n, o, f) => {
+      const l = f === void 0, s = r?.[o];
+      if (l && s === void 0)
+        throw new Error(
+          `Path '${e}' requires param '${o}' but it was not provided`
+        );
+      return s === void 0 ? "" : "/" + s;
+    }
+  );
+  if (e.endsWith("*")) {
+    const n = r?.["*"];
+    n !== void 0 && (a += "/" + n);
+  }
+  return a || "/";
+}
+function qt(e) {
+  let t = e.length - 1, r = e[t];
+  if (r !== "*" && r !== "/") return e;
+  for (t--; t >= 0 && e[t] === "/"; t--)
+    ;
+  return e.slice(0, t + 1);
+}
+var Z = new TextEncoder(), Re = "</body></html>";
+function Se(e) {
+  let t = new TextDecoder(), r, a = new Promise(
+    (s) => r = s
+  ), n = !1, o = [], f = null;
+  function l(s) {
+    for (let i of o) {
+      let u = t.decode(i, { stream: !0 });
+      u.endsWith(Re) && (u = u.slice(0, -Re.length)), s.enqueue(Z.encode(u));
+    }
+    o.length = 0, f = null;
+  }
+  return new TransformStream({
+    transform(s, i) {
+      o.push(s), !f && (f = setTimeout(async () => {
+        l(i), n || (n = !0, Vt(e, i).catch((u) => i.error(u)).then(r));
+      }, 0));
+    },
+    async flush(s) {
+      await a, f && (clearTimeout(f), l(s)), s.enqueue(Z.encode("</body></html>"));
+    }
+  });
+}
+async function Vt(e, t) {
+  let r = new TextDecoder("utf-8", { fatal: !0 });
+  const a = e.getReader();
+  try {
+    let o;
+    for (; (o = await a.read()) && !o.done; ) {
+      const f = o.value;
+      try {
+        J(
+          JSON.stringify(r.decode(f, { stream: !0 })),
+          t
+        );
+      } catch {
+        let s = JSON.stringify(btoa(String.fromCodePoint(...f)));
+        J(
+          `Uint8Array.from(atob(${s}), m => m.codePointAt(0))`,
+          t
+        );
+      }
+    }
+  } finally {
+    a.releaseLock();
+  }
+  let n = r.decode();
+  n.length && J(JSON.stringify(n), t);
+}
+function J(e, t) {
+  t.enqueue(
+    Z.encode(
+      `<script>${Wt(
+        `(self.__FLIGHT_DATA||=[]).push(${e})`
+      )}<\/script>`
+    )
+  );
+}
+function Wt(e) {
+  return e.replace(/<!--/g, "<\\!--").replace(/<\/(script)/gi, "</\\$1");
+}
+var Xt = class extends A.Component {
+  constructor(e) {
+    super(e), this.state = { error: null, location: e.location };
+  }
+  static getDerivedStateFromError(e) {
+    return { error: e };
+  }
+  static getDerivedStateFromProps(e, t) {
+    return t.location !== e.location ? { error: null, location: e.location } : { error: t.error, location: t.location };
+  }
+  render() {
+    return this.state.error ? /* @__PURE__ */ A.createElement(
+      je,
+      {
+        error: this.state.error,
+        renderAppShell: !0
+      }
+    ) : this.props.children;
+  }
+};
+function ve({
+  renderAppShell: e,
+  title: t,
+  children: r
+}) {
+  return e ? /* @__PURE__ */ A.createElement("html", { lang: "en" }, /* @__PURE__ */ A.createElement("head", null, /* @__PURE__ */ A.createElement("meta", { charSet: "utf-8" }), /* @__PURE__ */ A.createElement(
+    "meta",
+    {
+      name: "viewport",
+      content: "width=device-width,initial-scale=1,viewport-fit=cover"
+    }
+  ), /* @__PURE__ */ A.createElement("title", null, t)), /* @__PURE__ */ A.createElement("body", null, /* @__PURE__ */ A.createElement("main", { style: { fontFamily: "system-ui, sans-serif", padding: "2rem" } }, r))) : r;
+}
+function je({
+  error: e,
+  renderAppShell: t
+}) {
+  console.error(e);
+  let r = /* @__PURE__ */ A.createElement(
+    "script",
+    {
+      dangerouslySetInnerHTML: {
+        __html: `
+        console.log(
+          "💿 Hey developer 👋. You can provide a way better UX than this when your app throws errors. Check out https://reactrouter.com/how-to/error-boundary for more information."
+        );
+      `
+      }
+    }
+  );
+  if (P(e))
+    return /* @__PURE__ */ A.createElement(
+      ve,
+      {
+        renderAppShell: t,
+        title: "Unhandled Thrown Response!"
+      },
+      /* @__PURE__ */ A.createElement("h1", { style: { fontSize: "24px" } }, e.status, " ", e.statusText),
+      r
+    );
+  let a;
+  if (e instanceof Error)
+    a = e;
+  else {
+    let n = e == null ? "Unknown Error" : typeof e == "object" && "toString" in e ? e.toString() : JSON.stringify(e);
+    a = new Error(n);
+  }
+  return /* @__PURE__ */ A.createElement(ve, { renderAppShell: t, title: "Application Error!" }, /* @__PURE__ */ A.createElement("h1", { style: { fontSize: "24px" } }, "Application Error"), /* @__PURE__ */ A.createElement(
+    "pre",
+    {
+      style: {
+        padding: "2rem",
+        background: "hsla(10, 50%, 50%, 0.1)",
+        color: "red",
+        overflow: "auto"
+      }
+    },
+    a.stack
+  ), r);
+}
+function fr({
+  hasRootLayout: e
+}) {
+  let t = Xe();
+  if (e === void 0)
+    throw new Error("Missing 'hasRootLayout' prop");
+  return /* @__PURE__ */ A.createElement(
+    je,
+    {
+      renderAppShell: !e,
+      error: t
+    }
+  );
+}
+function Jt(e) {
+  const t = {};
+  for (const r of e.matches)
+    Kt(t, r);
+  return t;
+}
+function Kt(e, t) {
+  t = Array.isArray(t) ? t : [t];
+  for (const r of t)
+    e[r.id] = {
+      links: r.links,
+      meta: r.meta,
+      default: Qt
+    };
+}
+var Qt = () => null, Gt = "use", Ee = k[Gt];
+function Yt(e) {
+  if (Ee)
+    return Ee(e);
+  throw new Error("React Router v7 requires React 19+ for RSC features.");
+}
+async function hr({
+  request: e,
+  serverResponse: t,
+  createFromReadableStream: r,
+  renderHTML: a,
+  hydrate: n = !0
+}) {
+  const o = new URL(e.url);
+  if (Zt(o) || er(o) || e.headers.has("rsc-action-id") || t.headers.get("React-Router-Resource") === "true")
+    return t;
+  if (!t.body)
+    throw new Error("Missing body in server response");
+  const s = t.clone();
+  let i = null;
+  n && (i = t.clone());
+  const u = t.body;
+  let h, p = [];
+  const w = () => h ? new ReadableStream({
+    start(m) {
+      h.forEach((d) => m.enqueue(d)), p.push(m);
+    }
+  }) : (h = [], u.pipeThrough(
+    new TransformStream({
+      transform(m, d) {
+        h.push(m), d.enqueue(m), p.forEach((R) => R.enqueue(m));
+      },
+      flush() {
+        p.forEach((m) => m.close()), p = [];
+      }
+    })
+  ));
+  let y = null;
+  const g = () => {
+    const m = Promise.resolve(
+      r(w())
+    );
+    return Object.defineProperties(m, {
+      _deepestRenderedBoundaryId: {
+        get() {
+          return y;
+        },
+        set(d) {
+          y = d;
+        }
+      },
+      formState: {
+        get() {
+          return m.then(
+            (d) => d.type === "render" ? d.formState : void 0
+          );
+        }
+      }
+    });
+  };
+  let c, v;
+  try {
+    if (!s.body)
+      throw new Error("Failed to clone server response");
+    const m = await r(
+      s.body
+    );
+    if (t.status === _e && m.type === "redirect") {
+      const x = new Headers(t.headers);
+      return x.delete("Content-Encoding"), x.delete("Content-Length"), x.delete("Content-Type"), x.delete("X-Remix-Response"), x.set("Location", m.location), new Response(i?.body || "", {
+        headers: x,
+        status: m.status,
+        statusText: t.statusText
+      });
+    }
+    let d = new Headers(), R = t.status, S = t.statusText, b = await a(g, {
+      onError(x) {
+        if (typeof x == "object" && x && "digest" in x && typeof x.digest == "string") {
+          if (c = oe(x.digest), c)
+            return x.digest;
+          let C = ie(x.digest);
+          if (C)
+            return v = C, R = C.status, S = C.statusText, x.digest;
+        }
+      },
+      onHeaders(x) {
+        for (const [C, D] of x)
+          d.append(C, D);
+      }
+    });
+    const E = new Headers(d);
+    for (const [x, C] of t.headers)
+      E.append(x, C);
+    if (E.set("Content-Type", "text/html; charset=utf-8"), c)
+      return E.set("Location", c.location), new Response(b, {
+        status: c.status,
+        headers: E
+      });
+    const _ = new TransformStream({
+      flush(x) {
+        c && x.enqueue(
+          new TextEncoder().encode(
+            `<meta http-equiv="refresh" content="0;url=${Q(c.location)}"/>`
+          )
+        );
+      }
+    });
+    if (!n)
+      return new Response(b.pipeThrough(_), {
+        status: R,
+        statusText: S,
+        headers: E
+      });
+    if (!i?.body)
+      throw new Error("Failed to clone server response");
+    const F = b.pipeThrough(Se(i.body)).pipeThrough(_);
+    return new Response(F, {
+      status: R,
+      statusText: S,
+      headers: E
+    });
+  } catch (m) {
+    if (m instanceof Response)
+      return m;
+    if (c)
+      return new Response(`Redirect: ${c.location}`, {
+        status: c.status,
+        headers: {
+          Location: c.location
+        }
+      });
+    try {
+      m = v ?? m;
+      let [d, R] = P(m) ? [m.status, m.statusText] : [500, ""], S, b = new Headers();
+      const E = await a(
+        () => {
+          const D = Promise.resolve(
+            r(w())
+          ).then(
+            (H) => Object.assign(H, {
+              status: d,
+              errors: y ? {
+                [y]: m
+              } : {}
+            })
+          );
+          return Object.defineProperties(D, {
+            _deepestRenderedBoundaryId: {
+              get() {
+                return y;
+              },
+              set(H) {
+                y = H;
+              }
+            },
+            formState: {
+              get() {
+                return D.then(
+                  (H) => H.type === "render" ? H.formState : void 0
+                );
+              }
+            }
+          });
+        },
+        {
+          onError(C) {
+            if (typeof C == "object" && C && "digest" in C && typeof C.digest == "string") {
+              if (S = oe(C.digest), S)
+                return C.digest;
+              let D = ie(
+                C.digest
+              );
+              if (D)
+                return d = D.status, R = D.statusText, C.digest;
+            }
+          },
+          onHeaders(C) {
+            for (const [D, H] of C)
+              b.append(D, H);
+          }
+        }
+      ), _ = new Headers(b);
+      for (const [C, D] of t.headers)
+        _.append(C, D);
+      if (_.set("Content-Type", "text/html; charset=utf-8"), S)
+        return _.set("Location", S.location), new Response(E, {
+          status: S.status,
+          headers: _
+        });
+      const F = new TransformStream({
+        flush(C) {
+          S && C.enqueue(
+            new TextEncoder().encode(
+              `<meta http-equiv="refresh" content="0;url=${Q(S.location)}"/>`
+            )
+          );
+        }
+      });
+      if (!n)
+        return new Response(E.pipeThrough(F), {
+          status: d,
+          statusText: R,
+          headers: _
+        });
+      if (!i?.body)
+        throw new Error("Failed to clone server response");
+      const x = E.pipeThrough(Se(i.body)).pipeThrough(F);
+      return new Response(x, {
+        status: d,
+        statusText: R,
+        headers: _
+      });
+    } catch {
+    }
+    throw m;
+  }
+}
+function pr({ getPayload: e }) {
+  const t = e(), r = Yt(t);
+  if (r.type === "redirect")
+    throw new Response(null, {
+      status: r.status,
+      headers: {
+        Location: r.location
+      }
+    });
+  if (r.type !== "render") return null;
+  let a = { ...r.loaderData };
+  for (const l of r.matches)
+    ee(
+      l.id,
+      l.clientLoader,
+      l.hasLoader,
+      !1
+    ) && (l.hydrateFallbackElement || !l.hasLoader) && delete a[l.id];
+  const n = {
+    get _deepestRenderedBoundaryId() {
+      return t._deepestRenderedBoundaryId ?? null;
+    },
+    set _deepestRenderedBoundaryId(l) {
+      t._deepestRenderedBoundaryId = l;
+    },
+    actionData: r.actionData,
+    actionHeaders: {},
+    basename: r.basename,
+    errors: r.errors,
+    loaderData: a,
+    loaderHeaders: {},
+    location: r.location,
+    statusCode: 200,
+    matches: r.matches.map((l) => ({
+      params: l.params,
+      pathname: l.pathname,
+      pathnameBase: l.pathnameBase,
+      route: {
+        id: l.id,
+        action: l.hasAction || !!l.clientAction,
+        handle: l.handle,
+        hasErrorBoundary: l.hasErrorBoundary,
+        loader: l.hasLoader || !!l.clientLoader,
+        index: l.index,
+        path: l.path,
+        shouldRevalidate: l.shouldRevalidate
+      }
+    }))
+  }, o = Ce(
+    r.matches.reduceRight((l, s) => {
+      const i = {
+        id: s.id,
+        action: s.hasAction || !!s.clientAction,
+        element: s.element,
+        errorElement: s.errorElement,
+        handle: s.handle,
+        hasErrorBoundary: !!s.errorElement,
+        hydrateFallbackElement: s.hydrateFallbackElement,
+        index: s.index,
+        loader: s.hasLoader || !!s.clientLoader,
+        path: s.path,
+        shouldRevalidate: s.shouldRevalidate
+      };
+      return l.length > 0 && (i.children = l), [i];
+    }, []),
+    n
+  ), f = {
+    future: {
+      // These flags have no runtime impact so can always be false.  If we add
+      // flags that drive runtime behavior they'll need to be proxied through.
+      v8_middleware: !1,
+      unstable_subResourceIntegrity: !1,
+      unstable_trailingSlashAwareDataRequests: !0
+      // always on for RSC
+    },
+    isSpaMode: !1,
+    ssr: !0,
+    criticalCss: "",
+    manifest: {
+      routes: {},
+      version: "1",
+      url: "",
+      entry: {
+        module: "",
+        imports: []
+      }
+    },
+    routeDiscovery: { mode: "lazy", manifestPath: "/__manifest" },
+    routeModules: Jt(r)
+  };
+  return /* @__PURE__ */ k.createElement(Ge.Provider, { value: !0 }, /* @__PURE__ */ k.createElement(Xt, { location: r.location }, /* @__PURE__ */ k.createElement(te.Provider, { value: f }, /* @__PURE__ */ k.createElement(
+    be,
+    {
+      context: n,
+      router: o,
+      hydrate: !1,
+      nonce: r.nonce
+    }
+  ))));
+}
+function Zt(e) {
+  return e.pathname.endsWith(".rsc");
+}
+function er(e) {
+  return e.pathname.endsWith(".manifest");
+}
+function mr(e) {
+  if (!e) return null;
+  let t = Object.entries(e), r = {};
+  for (let [a, n] of t)
+    if (n && n.__type === "RouteErrorResponse")
+      r[a] = new O(
+        n.status,
+        n.statusText,
+        n.data,
+        n.internal === !0
+      );
+    else if (n && n.__type === "Error") {
+      if (n.__subType) {
+        let o = window[n.__subType];
+        if (typeof o == "function")
+          try {
+            let f = new o(n.message);
+            f.stack = n.stack, r[a] = f;
+          } catch {
+          }
+      }
+      if (r[a] == null) {
+        let o = new Error(n.message);
+        o.stack = n.stack, r[a] = o;
+      }
+    } else
+      r[a] = n;
+  return r;
+}
+function yr({
+  state: e,
+  routes: t,
+  getRouteInfo: r,
+  location: a,
+  basename: n,
+  isSpaMode: o
+}) {
+  let f = {
+    ...e,
+    loaderData: { ...e.loaderData }
+  }, l = xe(t, a, n);
+  if (l)
+    for (let s of l) {
+      let i = s.route.id, u = r(i);
+      ee(
+        i,
+        u.clientLoader,
+        u.hasLoader,
+        o
+      ) && (u.hasHydrateFallback || !u.hasLoader) ? delete f.loaderData[i] : u.hasLoader || (f.loaderData[i] = null);
+    }
+  return f;
+}
+const wr = () => {
+  const e = se((a) => a.navigateTo), t = se((a) => a.navigateInHortiview);
+  return ze(
     (a) => {
-      if (e) {
-        e(a);
+      if (t) {
+        t(a);
         return;
       }
-      s?.(a);
+      e?.(a);
     },
-    [e, s]
+    [t, e]
   );
 };
 export {
-  R as Await,
-  F as BrowserRouter,
-  E as Form,
-  N as HashRouter,
-  l as IDLE_BLOCKER,
-  A as IDLE_FETCHER,
-  _ as IDLE_NAVIGATION,
-  v as Link,
-  d as Links,
-  m as MemoryRouter,
-  U as Meta,
-  g as NavLink,
-  h as Navigate,
-  C as NavigationType,
-  p as Outlet,
-  P as PrefetchPageLinks,
-  H as Route,
-  y as Router,
-  L as RouterProvider,
-  k as Routes,
-  x as Scripts,
-  D as ScrollRestoration,
-  w as ServerRouter,
-  I as StaticRouter,
-  M as StaticRouterProvider,
-  O as UNSAFE_DataRouterContext,
-  b as UNSAFE_DataRouterStateContext,
-  B as UNSAFE_ErrorResponseImpl,
-  T as UNSAFE_FetchersContext,
-  f as UNSAFE_FrameworkContext,
-  V as UNSAFE_LocationContext,
-  q as UNSAFE_NavigationContext,
-  z as UNSAFE_RemixErrorBoundary,
-  G as UNSAFE_RouteContext,
-  K as UNSAFE_ServerMode,
-  W as UNSAFE_SingleFetchRedirectSymbol,
-  j as UNSAFE_ViewTransitionContext,
-  J as UNSAFE_createBrowserHistory,
-  Q as UNSAFE_createClientRoutes,
-  X as UNSAFE_createClientRoutesWithHMRRevalidationOptOut,
-  Y as UNSAFE_createRouter,
-  Z as UNSAFE_decodeViaTurboStream,
-  $ as UNSAFE_deserializeErrors,
-  aa as UNSAFE_getPatchRoutesOnNavigationFunction,
-  ea as UNSAFE_getSingleFetchDataStrategy,
-  sa as UNSAFE_invariant,
-  ta as UNSAFE_mapRouteProperties,
-  ra as UNSAFE_shouldHydrateRouteLoader,
-  oa as UNSAFE_useFogOFWarDiscovery,
-  ia as UNSAFE_useScrollRestoration,
-  ua as createBrowserRouter,
-  na as createCookie,
-  ca as createCookieSessionStorage,
-  Sa as createHashRouter,
-  Ra as createMemoryRouter,
-  Fa as createMemorySessionStorage,
-  Ea as createPath,
-  Na as createRequestHandler,
-  la as createRoutesFromChildren,
-  Aa as createRoutesFromElements,
-  _a as createRoutesStub,
-  va as createSearchParams,
-  da as createSession,
-  ma as createSessionStorage,
-  Ua as createStaticHandler,
-  ga as createStaticRouter,
-  ha as data,
-  Ca as generatePath,
-  pa as isCookie,
-  Pa as isRouteErrorResponse,
-  Ha as isSession,
-  ya as matchPath,
-  La as matchRoutes,
-  ka as parsePath,
-  xa as redirect,
-  Da as redirectDocument,
-  wa as renderMatches,
-  Ia as replace,
-  Ma as resolvePath,
-  Oa as unstable_HistoryRouter,
-  ba as unstable_setDevServerHooks,
-  Ba as unstable_usePrompt,
-  Ta as useActionData,
-  fa as useAsyncError,
-  Va as useAsyncValue,
-  qa as useBeforeUnload,
-  za as useBlocker,
-  Ga as useFetcher,
-  Ka as useFetchers,
-  Wa as useFormAction,
-  ja as useHref,
-  Ja as useInRouterContext,
-  Qa as useLinkClickHandler,
-  Xa as useLoaderData,
-  Ya as useLocation,
-  Za as useMatch,
-  $a as useMatches,
-  n as useNavigate,
-  ae as useNavigation,
-  ee as useNavigationType,
-  se as useOutlet,
-  te as useOutletContext,
-  re as useParams,
-  oe as useResolvedPath,
-  ie as useRevalidator,
-  ue as useRouteError,
-  ne as useRouteLoaderData,
-  ce as useRoutes,
-  Se as useSearchParams,
-  Re as useSubmit,
-  Fe as useViewTransitionState
+  Sr as Await,
+  vr as BrowserRouter,
+  Er as Form,
+  Cr as HashRouter,
+  br as IDLE_BLOCKER,
+  xr as IDLE_FETCHER,
+  _r as IDLE_NAVIGATION,
+  kr as Link,
+  Ar as Links,
+  Dr as MemoryRouter,
+  Hr as Meta,
+  Tr as NavLink,
+  Fr as Navigate,
+  Pr as NavigationType,
+  at as Outlet,
+  Nr as PrefetchPageLinks,
+  Ur as Route,
+  Lr as Router,
+  K as RouterContextProvider,
+  Qe as RouterProvider,
+  Or as Routes,
+  Ir as Scripts,
+  Br as ScrollRestoration,
+  nr as ServerRouter,
+  Mr as StaticRouter,
+  be as StaticRouterProvider,
+  $r as UNSAFE_AwaitContextProvider,
+  jr as UNSAFE_DataRouterContext,
+  zr as UNSAFE_DataRouterStateContext,
+  O as UNSAFE_ErrorResponseImpl,
+  qr as UNSAFE_FetchersContext,
+  te as UNSAFE_FrameworkContext,
+  Vr as UNSAFE_LocationContext,
+  Wr as UNSAFE_NavigationContext,
+  fr as UNSAFE_RSCDefaultRootErrorBoundary,
+  Ve as UNSAFE_RemixErrorBoundary,
+  Xr as UNSAFE_RouteContext,
+  _t as UNSAFE_ServerMode,
+  I as UNSAFE_SingleFetchRedirectSymbol,
+  Jr as UNSAFE_ViewTransitionContext,
+  Kr as UNSAFE_WithComponentProps,
+  Qr as UNSAFE_WithErrorBoundaryProps,
+  Gr as UNSAFE_WithHydrateFallbackProps,
+  Yr as UNSAFE_createBrowserHistory,
+  Zr as UNSAFE_createClientRoutes,
+  ea as UNSAFE_createClientRoutesWithHMRRevalidationOptOut,
+  ta as UNSAFE_createHashHistory,
+  ra as UNSAFE_createMemoryHistory,
+  aa as UNSAFE_createRouter,
+  nt as UNSAFE_decodeViaTurboStream,
+  mr as UNSAFE_deserializeErrors,
+  yr as UNSAFE_getHydrationData,
+  na as UNSAFE_getPatchRoutesOnNavigationFunction,
+  sa as UNSAFE_getTurboStreamSingleFetchDataStrategy,
+  oa as UNSAFE_hydrationRouteProperties,
+  ia as UNSAFE_invariant,
+  la as UNSAFE_mapRouteProperties,
+  ee as UNSAFE_shouldHydrateRouteLoader,
+  ua as UNSAFE_useFogOFWarDiscovery,
+  da as UNSAFE_useScrollRestoration,
+  rt as UNSAFE_withComponentProps,
+  et as UNSAFE_withErrorBoundaryProps,
+  tt as UNSAFE_withHydrateFallbackProps,
+  ca as createBrowserRouter,
+  fa as createContext,
+  He as createCookie,
+  ur as createCookieSessionStorage,
+  ha as createHashRouter,
+  Ke as createMemoryRouter,
+  dr as createMemorySessionStorage,
+  pa as createPath,
+  ir as createRequestHandler,
+  ma as createRoutesFromChildren,
+  ya as createRoutesFromElements,
+  sr as createRoutesStub,
+  wa as createSearchParams,
+  Me as createSession,
+  zt as createSessionStorage,
+  ga as createStaticHandler,
+  Ce as createStaticRouter,
+  Ra as data,
+  Sa as generatePath,
+  cr as href,
+  Te as isCookie,
+  P as isRouteErrorResponse,
+  lr as isSession,
+  va as matchPath,
+  xe as matchRoutes,
+  Ea as parsePath,
+  it as redirect,
+  st as redirectDocument,
+  Ca as renderMatches,
+  ot as replace,
+  ba as resolvePath,
+  xa as unstable_HistoryRouter,
+  pr as unstable_RSCStaticRouter,
+  hr as unstable_routeRSCServerRequest,
+  or as unstable_setDevServerHooks,
+  _a as unstable_usePrompt,
+  ka as unstable_useRoute,
+  Aa as useActionData,
+  Da as useAsyncError,
+  Ha as useAsyncValue,
+  Ta as useBeforeUnload,
+  Fa as useBlocker,
+  Pa as useFetcher,
+  Na as useFetchers,
+  Ua as useFormAction,
+  La as useHref,
+  Oa as useInRouterContext,
+  Ia as useLinkClickHandler,
+  Ba as useLoaderData,
+  Ma as useLocation,
+  $a as useMatch,
+  ja as useMatches,
+  wr as useNavigate,
+  za as useNavigation,
+  qa as useNavigationType,
+  Va as useOutlet,
+  Wa as useOutletContext,
+  Xa as useParams,
+  Ja as useResolvedPath,
+  Ka as useRevalidator,
+  Xe as useRouteError,
+  Qa as useRouteLoaderData,
+  Ga as useRoutes,
+  Ya as useSearchParams,
+  Za as useSubmit,
+  en as useViewTransitionState
 };