@0xchain/token 1.0.0 → 1.1.0-beta.10

package/dist/headers-CbQpA7HX.js

@@ -0,0 +1,3838 @@
+function ar(h, a) {
+  for (var E = 0; E < a.length; E++) {
+    const b = a[E];
+    if (typeof b != "string" && !Array.isArray(b)) {
+      for (const R in b)
+        if (R !== "default" && !(R in h)) {
+          const w = Object.getOwnPropertyDescriptor(b, R);
+          w && Object.defineProperty(h, R, w.get ? w : {
+            enumerable: !0,
+            get: () => b[R]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(h, Symbol.toStringTag, { value: "Module" }));
+}
+var ge = {}, Ie = {}, Me = {}, He = {}, xe, gt;
+function sr() {
+  if (gt) return xe;
+  gt = 1;
+  var h = Object.defineProperty, a = Object.getOwnPropertyDescriptor, E = Object.getOwnPropertyNames, b = Object.prototype.hasOwnProperty, R = (t, l) => {
+    for (var o in l)
+      h(t, o, { get: l[o], enumerable: !0 });
+  }, w = (t, l, o, u) => {
+    if (l && typeof l == "object" || typeof l == "function")
+      for (let g of E(l))
+        !b.call(t, g) && g !== o && h(t, g, { get: () => l[g], enumerable: !(u = a(l, g)) || u.enumerable });
+    return t;
+  }, c = (t) => w(h({}, "__esModule", { value: !0 }), t), p = {};
+  R(p, {
+    RequestCookies: () => P,
+    ResponseCookies: () => A,
+    parseCookie: () => s,
+    parseSetCookie: () => v,
+    stringifyCookie: () => d
+  }), xe = c(p);
+  function d(t) {
+    var l;
+    const o = [
+      "path" in t && t.path && `Path=${t.path}`,
+      "expires" in t && (t.expires || t.expires === 0) && `Expires=${(typeof t.expires == "number" ? new Date(t.expires) : t.expires).toUTCString()}`,
+      "maxAge" in t && typeof t.maxAge == "number" && `Max-Age=${t.maxAge}`,
+      "domain" in t && t.domain && `Domain=${t.domain}`,
+      "secure" in t && t.secure && "Secure",
+      "httpOnly" in t && t.httpOnly && "HttpOnly",
+      "sameSite" in t && t.sameSite && `SameSite=${t.sameSite}`,
+      "partitioned" in t && t.partitioned && "Partitioned",
+      "priority" in t && t.priority && `Priority=${t.priority}`
+    ].filter(Boolean), u = `${t.name}=${encodeURIComponent((l = t.value) != null ? l : "")}`;
+    return o.length === 0 ? u : `${u}; ${o.join("; ")}`;
+  }
+  function s(t) {
+    const l = /* @__PURE__ */ new Map();
+    for (const o of t.split(/; */)) {
+      if (!o)
+        continue;
+      const u = o.indexOf("=");
+      if (u === -1) {
+        l.set(o, "true");
+        continue;
+      }
+      const [g, M] = [o.slice(0, u), o.slice(u + 1)];
+      try {
+        l.set(g, decodeURIComponent(M ?? "true"));
+      } catch {
+      }
+    }
+    return l;
+  }
+  function v(t) {
+    if (!t)
+      return;
+    const [[l, o], ...u] = s(t), {
+      domain: g,
+      expires: M,
+      httponly: F,
+      maxage: H,
+      path: J,
+      samesite: te,
+      secure: ae,
+      partitioned: re,
+      priority: oe
+    } = Object.fromEntries(
+      u.map(([se, fe]) => [
+        se.toLowerCase().replace(/-/g, ""),
+        fe
+      ])
+    ), ue = {
+      name: l,
+      value: decodeURIComponent(o),
+      domain: g,
+      ...M && { expires: new Date(M) },
+      ...F && { httpOnly: !0 },
+      ...typeof H == "string" && { maxAge: Number(H) },
+      path: J,
+      ...te && { sameSite: G(te) },
+      ...ae && { secure: !0 },
+      ...oe && { priority: S(oe) },
+      ...re && { partitioned: !0 }
+    };
+    return T(ue);
+  }
+  function T(t) {
+    const l = {};
+    for (const o in t)
+      t[o] && (l[o] = t[o]);
+    return l;
+  }
+  var j = ["strict", "lax", "none"];
+  function G(t) {
+    return t = t.toLowerCase(), j.includes(t) ? t : void 0;
+  }
+  var L = ["low", "medium", "high"];
+  function S(t) {
+    return t = t.toLowerCase(), L.includes(t) ? t : void 0;
+  }
+  function C(t) {
+    if (!t)
+      return [];
+    var l = [], o = 0, u, g, M, F, H;
+    function J() {
+      for (; o < t.length && /\s/.test(t.charAt(o)); )
+        o += 1;
+      return o < t.length;
+    }
+    function te() {
+      return g = t.charAt(o), g !== "=" && g !== ";" && g !== ",";
+    }
+    for (; o < t.length; ) {
+      for (u = o, H = !1; J(); )
+        if (g = t.charAt(o), g === ",") {
+          for (M = o, o += 1, J(), F = o; o < t.length && te(); )
+            o += 1;
+          o < t.length && t.charAt(o) === "=" ? (H = !0, o = F, l.push(t.substring(u, M)), u = o) : o = M + 1;
+        } else
+          o += 1;
+      (!H || o >= t.length) && l.push(t.substring(u, t.length));
+    }
+    return l;
+  }
+  var P = class {
+    constructor(t) {
+      this._parsed = /* @__PURE__ */ new Map(), this._headers = t;
+      const l = t.get("cookie");
+      if (l) {
+        const o = s(l);
+        for (const [u, g] of o)
+          this._parsed.set(u, { name: u, value: g });
+      }
+    }
+    [Symbol.iterator]() {
+      return this._parsed[Symbol.iterator]();
+    }
+    /**
+     * The amount of cookies received from the client
+     */
+    get size() {
+      return this._parsed.size;
+    }
+    get(...t) {
+      const l = typeof t[0] == "string" ? t[0] : t[0].name;
+      return this._parsed.get(l);
+    }
+    getAll(...t) {
+      var l;
+      const o = Array.from(this._parsed);
+      if (!t.length)
+        return o.map(([g, M]) => M);
+      const u = typeof t[0] == "string" ? t[0] : (l = t[0]) == null ? void 0 : l.name;
+      return o.filter(([g]) => g === u).map(([g, M]) => M);
+    }
+    has(t) {
+      return this._parsed.has(t);
+    }
+    set(...t) {
+      const [l, o] = t.length === 1 ? [t[0].name, t[0].value] : t, u = this._parsed;
+      return u.set(l, { name: l, value: o }), this._headers.set(
+        "cookie",
+        Array.from(u).map(([g, M]) => d(M)).join("; ")
+      ), this;
+    }
+    /**
+     * Delete the cookies matching the passed name or names in the request.
+     */
+    delete(t) {
+      const l = this._parsed, o = Array.isArray(t) ? t.map((u) => l.delete(u)) : l.delete(t);
+      return this._headers.set(
+        "cookie",
+        Array.from(l).map(([u, g]) => d(g)).join("; ")
+      ), o;
+    }
+    /**
+     * Delete all the cookies in the cookies in the request.
+     */
+    clear() {
+      return this.delete(Array.from(this._parsed.keys())), this;
+    }
+    /**
+     * Format the cookies in the request as a string for logging
+     */
+    [Symbol.for("edge-runtime.inspect.custom")]() {
+      return `RequestCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+    }
+    toString() {
+      return [...this._parsed.values()].map((t) => `${t.name}=${encodeURIComponent(t.value)}`).join("; ");
+    }
+  }, A = class {
+    constructor(t) {
+      this._parsed = /* @__PURE__ */ new Map();
+      var l, o, u;
+      this._headers = t;
+      const g = (u = (o = (l = t.getSetCookie) == null ? void 0 : l.call(t)) != null ? o : t.get("set-cookie")) != null ? u : [], M = Array.isArray(g) ? g : C(g);
+      for (const F of M) {
+        const H = v(F);
+        H && this._parsed.set(H.name, H);
+      }
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
+     */
+    get(...t) {
+      const l = typeof t[0] == "string" ? t[0] : t[0].name;
+      return this._parsed.get(l);
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
+     */
+    getAll(...t) {
+      var l;
+      const o = Array.from(this._parsed.values());
+      if (!t.length)
+        return o;
+      const u = typeof t[0] == "string" ? t[0] : (l = t[0]) == null ? void 0 : l.name;
+      return o.filter((g) => g.name === u);
+    }
+    has(t) {
+      return this._parsed.has(t);
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
+     */
+    set(...t) {
+      const [l, o, u] = t.length === 1 ? [t[0].name, t[0].value, t[0]] : t, g = this._parsed;
+      return g.set(l, D({ name: l, value: o, ...u })), N(g, this._headers), this;
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
+     */
+    delete(...t) {
+      const [l, o] = typeof t[0] == "string" ? [t[0]] : [t[0].name, t[0]];
+      return this.set({ ...o, name: l, value: "", expires: /* @__PURE__ */ new Date(0) });
+    }
+    [Symbol.for("edge-runtime.inspect.custom")]() {
+      return `ResponseCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
+    }
+    toString() {
+      return [...this._parsed.values()].map(d).join("; ");
+    }
+  };
+  function N(t, l) {
+    l.delete("set-cookie");
+    for (const [, o] of t) {
+      const u = d(o);
+      l.append("set-cookie", u);
+    }
+  }
+  function D(t = { name: "", value: "" }) {
+    return typeof t.expires == "number" && (t.expires = new Date(t.expires)), t.maxAge && (t.expires = new Date(Date.now() + t.maxAge * 1e3)), (t.path === null || t.path === void 0) && (t.path = "/"), t;
+  }
+  return xe;
+}
+var _t;
+function Kt() {
+  return _t || (_t = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(b, R) {
+      for (var w in R) Object.defineProperty(b, w, {
+        enumerable: !0,
+        get: R[w]
+      });
+    }
+    a(h, {
+      RequestCookies: function() {
+        return E.RequestCookies;
+      },
+      ResponseCookies: function() {
+        return E.ResponseCookies;
+      },
+      stringifyCookie: function() {
+        return E.stringifyCookie;
+      }
+    });
+    const E = sr();
+  })(He)), He;
+}
+var qe = {}, Et;
+function st() {
+  return Et || (Et = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "ReflectAdapter", {
+      enumerable: !0,
+      get: function() {
+        return a;
+      }
+    });
+    class a {
+      static get(b, R, w) {
+        const c = Reflect.get(b, R, w);
+        return typeof c == "function" ? c.bind(b) : c;
+      }
+      static set(b, R, w, c) {
+        return Reflect.set(b, R, w, c);
+      }
+      static has(b, R) {
+        return Reflect.has(b, R);
+      }
+      static deleteProperty(b, R) {
+        return Reflect.deleteProperty(b, R);
+      }
+    }
+  })(qe)), qe;
+}
+var Le = {}, Ue = {}, We = {}, Rt;
+function it() {
+  return Rt || (Rt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(d, s) {
+      for (var v in s) Object.defineProperty(d, v, {
+        enumerable: !0,
+        get: s[v]
+      });
+    }
+    a(h, {
+      bindSnapshot: function() {
+        return c;
+      },
+      createAsyncLocalStorage: function() {
+        return w;
+      },
+      createSnapshot: function() {
+        return p;
+      }
+    });
+    const E = Object.defineProperty(new Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available"), "__NEXT_ERROR_CODE", {
+      value: "E504",
+      enumerable: !1,
+      configurable: !0
+    });
+    class b {
+      disable() {
+        throw E;
+      }
+      getStore() {
+      }
+      run() {
+        throw E;
+      }
+      exit() {
+        throw E;
+      }
+      enterWith() {
+        throw E;
+      }
+      static bind(s) {
+        return s;
+      }
+    }
+    const R = typeof globalThis < "u" && globalThis.AsyncLocalStorage;
+    function w() {
+      return R ? new R() : new b();
+    }
+    function c(d) {
+      return R ? R.bind(d) : b.bind(d);
+    }
+    function p() {
+      return R ? R.snapshot() : function(d, ...s) {
+        return d(...s);
+      };
+    }
+  })(We)), We;
+}
+var bt;
+function ir() {
+  return bt || (bt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "workAsyncStorageInstance", {
+      enumerable: !0,
+      get: function() {
+        return E;
+      }
+    });
+    const E = (0, it().createAsyncLocalStorage)();
+  })(Ue)), Ue;
+}
+var vt;
+function Ee() {
+  return vt || (vt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "workAsyncStorage", {
+      enumerable: !0,
+      get: function() {
+        return a.workAsyncStorageInstance;
+      }
+    });
+    const a = ir();
+  })(Le)), Le;
+}
+var Xe = {}, wt;
+function ur() {
+  return wt || (wt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(w, c) {
+      for (var p in c) Object.defineProperty(w, p, {
+        enumerable: !0,
+        get: c[p]
+      });
+    }
+    a(h, {
+      ActionDidNotRevalidate: function() {
+        return E;
+      },
+      ActionDidRevalidateDynamicOnly: function() {
+        return R;
+      },
+      ActionDidRevalidateStaticAndDynamic: function() {
+        return b;
+      }
+    });
+    const E = 0, b = 1, R = 2;
+  })(Xe)), Xe;
+}
+var Ot;
+function cr() {
+  return Ot || (Ot = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(C, P) {
+      for (var A in P) Object.defineProperty(C, A, {
+        enumerable: !0,
+        get: P[A]
+      });
+    }
+    a(h, {
+      MutableRequestCookiesAdapter: function() {
+        return T;
+      },
+      ReadonlyRequestCookiesError: function() {
+        return c;
+      },
+      RequestCookiesAdapter: function() {
+        return p;
+      },
+      appendMutableCookies: function() {
+        return v;
+      },
+      areCookiesMutableInCurrentPhase: function() {
+        return G;
+      },
+      createCookiesWithMutableAccessCheck: function() {
+        return j;
+      },
+      getModifiedCookieValues: function() {
+        return s;
+      },
+      responseCookiesToRequestCookies: function() {
+        return S;
+      }
+    });
+    const E = Kt(), b = st(), R = Ee(), w = ur();
+    class c extends Error {
+      constructor() {
+        super("Cookies can only be modified in a Server Action or Route Handler. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options");
+      }
+      static callable() {
+        throw new c();
+      }
+    }
+    class p {
+      static seal(P) {
+        return new Proxy(P, {
+          get(A, N, D) {
+            switch (N) {
+              case "clear":
+              case "delete":
+              case "set":
+                return c.callable;
+              default:
+                return b.ReflectAdapter.get(A, N, D);
+            }
+          }
+        });
+      }
+    }
+    const d = Symbol.for("next.mutated.cookies");
+    function s(C) {
+      const P = C[d];
+      return !P || !Array.isArray(P) || P.length === 0 ? [] : P;
+    }
+    function v(C, P) {
+      const A = s(P);
+      if (A.length === 0)
+        return !1;
+      const N = new E.ResponseCookies(C), D = N.getAll();
+      for (const t of A)
+        N.set(t);
+      for (const t of D)
+        N.set(t);
+      return !0;
+    }
+    class T {
+      static wrap(P, A) {
+        const N = new E.ResponseCookies(new Headers());
+        for (const u of P.getAll())
+          N.set(u);
+        let D = [];
+        const t = /* @__PURE__ */ new Set(), l = () => {
+          const u = R.workAsyncStorage.getStore();
+          if (u && (u.pathWasRevalidated = w.ActionDidRevalidateStaticAndDynamic), D = N.getAll().filter((M) => t.has(M.name)), A) {
+            const M = [];
+            for (const F of D) {
+              const H = new E.ResponseCookies(new Headers());
+              H.set(F), M.push(H.toString());
+            }
+            A(M);
+          }
+        }, o = new Proxy(N, {
+          get(u, g, M) {
+            switch (g) {
+              // A special symbol to get the modified cookie values
+              case d:
+                return D;
+              // TODO: Throw error if trying to set a cookie after the response
+              // headers have been set.
+              case "delete":
+                return function(...F) {
+                  t.add(typeof F[0] == "string" ? F[0] : F[0].name);
+                  try {
+                    return u.delete(...F), o;
+                  } finally {
+                    l();
+                  }
+                };
+              case "set":
+                return function(...F) {
+                  t.add(typeof F[0] == "string" ? F[0] : F[0].name);
+                  try {
+                    return u.set(...F), o;
+                  } finally {
+                    l();
+                  }
+                };
+              default:
+                return b.ReflectAdapter.get(u, g, M);
+            }
+          }
+        });
+        return o;
+      }
+    }
+    function j(C) {
+      const P = new Proxy(C.mutableCookies, {
+        get(A, N, D) {
+          switch (N) {
+            case "delete":
+              return function(...t) {
+                return L(C), A.delete(...t), P;
+              };
+            case "set":
+              return function(...t) {
+                return L(C), A.set(...t), P;
+              };
+            default:
+              return b.ReflectAdapter.get(A, N, D);
+          }
+        }
+      });
+      return P;
+    }
+    function G(C) {
+      return C.phase === "action";
+    }
+    function L(C, P) {
+      if (!G(C))
+        throw new c();
+    }
+    function S(C) {
+      const P = new E.RequestCookies(new Headers());
+      for (const A of C.getAll())
+        P.set(A);
+      return P;
+    }
+  })(Me)), Me;
+}
+var Be = {}, $e = {}, At;
+function fr() {
+  return At || (At = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "workUnitAsyncStorageInstance", {
+      enumerable: !0,
+      get: function() {
+        return E;
+      }
+    });
+    const E = (0, it().createAsyncLocalStorage)();
+  })($e)), $e;
+}
+var De = { exports: {} }, Tt;
+function lr() {
+  return Tt || (Tt = 1, (function(h, a) {
+    Object.defineProperty(a, "__esModule", {
+      value: !0
+    });
+    function E(o, u) {
+      for (var g in u) Object.defineProperty(o, g, {
+        enumerable: !0,
+        get: u[g]
+      });
+    }
+    E(a, {
+      ACTION_HEADER: function() {
+        return R;
+      },
+      FLIGHT_HEADERS: function() {
+        return j;
+      },
+      NEXT_ACTION_NOT_FOUND_HEADER: function() {
+        return N;
+      },
+      NEXT_ACTION_REVALIDATED_HEADER: function() {
+        return l;
+      },
+      NEXT_DID_POSTPONE_HEADER: function() {
+        return S;
+      },
+      NEXT_HMR_REFRESH_HASH_COOKIE: function() {
+        return s;
+      },
+      NEXT_HMR_REFRESH_HEADER: function() {
+        return d;
+      },
+      NEXT_HTML_REQUEST_ID_HEADER: function() {
+        return t;
+      },
+      NEXT_IS_PRERENDER_HEADER: function() {
+        return A;
+      },
+      NEXT_REQUEST_ID_HEADER: function() {
+        return D;
+      },
+      NEXT_REWRITTEN_PATH_HEADER: function() {
+        return C;
+      },
+      NEXT_REWRITTEN_QUERY_HEADER: function() {
+        return P;
+      },
+      NEXT_ROUTER_PREFETCH_HEADER: function() {
+        return c;
+      },
+      NEXT_ROUTER_SEGMENT_PREFETCH_HEADER: function() {
+        return p;
+      },
+      NEXT_ROUTER_STALE_TIME_HEADER: function() {
+        return L;
+      },
+      NEXT_ROUTER_STATE_TREE_HEADER: function() {
+        return w;
+      },
+      NEXT_RSC_UNION_QUERY: function() {
+        return G;
+      },
+      NEXT_URL: function() {
+        return v;
+      },
+      RSC_CONTENT_TYPE_HEADER: function() {
+        return T;
+      },
+      RSC_HEADER: function() {
+        return b;
+      }
+    });
+    const b = "rsc", R = "next-action", w = "next-router-state-tree", c = "next-router-prefetch", p = "next-router-segment-prefetch", d = "next-hmr-refresh", s = "__next_hmr_refresh_hash__", v = "next-url", T = "text/x-component", j = [
+      b,
+      w,
+      c,
+      d,
+      p
+    ], G = "_rsc", L = "x-nextjs-stale-time", S = "x-nextjs-postponed", C = "x-nextjs-rewritten-path", P = "x-nextjs-rewritten-query", A = "x-nextjs-prerender", N = "x-nextjs-action-not-found", D = "x-nextjs-request-id", t = "x-nextjs-html-request-id", l = "x-action-revalidated";
+    (typeof a.default == "function" || typeof a.default == "object" && a.default !== null) && typeof a.default.__esModule > "u" && (Object.defineProperty(a.default, "__esModule", { value: !0 }), Object.assign(a.default, a), h.exports = a.default);
+  })(De, De.exports)), De.exports;
+}
+var Ye = {}, St;
+function he() {
+  return St || (St = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "InvariantError", {
+      enumerable: !0,
+      get: function() {
+        return a;
+      }
+    });
+    class a extends Error {
+      constructor(b, R) {
+        super(`Invariant: ${b.endsWith(".") ? b : b + "."} This is a bug in Next.js.`, R), this.name = "InvariantError";
+      }
+    }
+  })(Ye)), Ye;
+}
+var Dt;
+function je() {
+  return Dt || (Dt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(S, C) {
+      for (var P in C) Object.defineProperty(S, P, {
+        enumerable: !0,
+        get: C[P]
+      });
+    }
+    a(h, {
+      getCacheSignal: function() {
+        return G;
+      },
+      getDraftModeProviderForCacheScope: function() {
+        return j;
+      },
+      getHmrRefreshHash: function() {
+        return s;
+      },
+      getPrerenderResumeDataCache: function() {
+        return p;
+      },
+      getRenderResumeDataCache: function() {
+        return d;
+      },
+      getRuntimeStagePromise: function() {
+        return L;
+      },
+      getServerComponentsHmrCache: function() {
+        return T;
+      },
+      isHmrRefresh: function() {
+        return v;
+      },
+      throwForMissingRequestStore: function() {
+        return w;
+      },
+      throwInvariantForMissingStore: function() {
+        return c;
+      },
+      workUnitAsyncStorage: function() {
+        return E.workUnitAsyncStorageInstance;
+      }
+    });
+    const E = fr(), b = lr(), R = he();
+    function w(S) {
+      throw Object.defineProperty(new Error(`\`${S}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
+        value: "E251",
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+    function c() {
+      throw Object.defineProperty(new R.InvariantError("Expected workUnitAsyncStorage to have a store."), "__NEXT_ERROR_CODE", {
+        value: "E696",
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+    function p(S) {
+      switch (S.type) {
+        case "prerender":
+        case "prerender-runtime":
+        case "prerender-ppr":
+          return S.prerenderResumeDataCache;
+        case "prerender-client":
+          return S.prerenderResumeDataCache;
+        case "request":
+          if (S.prerenderResumeDataCache)
+            return S.prerenderResumeDataCache;
+        case "prerender-legacy":
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+          return null;
+        default:
+          return S;
+      }
+    }
+    function d(S) {
+      switch (S.type) {
+        case "request":
+        case "prerender":
+        case "prerender-runtime":
+        case "prerender-client":
+          if (S.renderResumeDataCache)
+            return S.renderResumeDataCache;
+        // fallthrough
+        case "prerender-ppr":
+          return S.prerenderResumeDataCache ?? null;
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+        case "prerender-legacy":
+          return null;
+        default:
+          return S;
+      }
+    }
+    function s(S, C) {
+      if (S.dev)
+        switch (C.type) {
+          case "cache":
+          case "private-cache":
+          case "prerender":
+          case "prerender-runtime":
+            return C.hmrRefreshHash;
+          case "request":
+            var P;
+            return (P = C.cookies.get(b.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : P.value;
+        }
+    }
+    function v(S, C) {
+      if (S.dev)
+        switch (C.type) {
+          case "cache":
+          case "private-cache":
+          case "request":
+            return C.isHmrRefresh ?? !1;
+        }
+      return !1;
+    }
+    function T(S, C) {
+      if (S.dev)
+        switch (C.type) {
+          case "cache":
+          case "private-cache":
+          case "request":
+            return C.serverComponentsHmrCache;
+        }
+    }
+    function j(S, C) {
+      if (S.isDraftMode)
+        switch (C.type) {
+          case "cache":
+          case "private-cache":
+          case "unstable-cache":
+          case "prerender-runtime":
+          case "request":
+            return C.draftMode;
+        }
+    }
+    function G(S) {
+      switch (S.type) {
+        case "prerender":
+        case "prerender-client":
+        case "prerender-runtime":
+          return S.cacheSignal;
+        case "request":
+          if (S.cacheSignal)
+            return S.cacheSignal;
+        case "prerender-ppr":
+        case "prerender-legacy":
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+          return null;
+        default:
+          return S;
+      }
+    }
+    function L(S) {
+      switch (S.type) {
+        case "prerender-runtime":
+        case "private-cache":
+          return S.runtimeStagePromise;
+        case "prerender":
+        case "prerender-client":
+        case "prerender-ppr":
+        case "prerender-legacy":
+        case "request":
+        case "cache":
+        case "unstable-cache":
+          return null;
+        default:
+          return S;
+      }
+    }
+  })(Be)), Be;
+}
+var Ge = {}, Ce = { exports: {} }, U = {};
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ct;
+function dr() {
+  if (Ct) return U;
+  Ct = 1;
+  var h = Symbol.for("react.transitional.element"), a = Symbol.for("react.portal"), E = Symbol.for("react.fragment"), b = Symbol.for("react.strict_mode"), R = Symbol.for("react.profiler"), w = Symbol.for("react.consumer"), c = Symbol.for("react.context"), p = Symbol.for("react.forward_ref"), d = Symbol.for("react.suspense"), s = Symbol.for("react.memo"), v = Symbol.for("react.lazy"), T = Symbol.for("react.activity"), j = Symbol.iterator;
+  function G(r) {
+    return r === null || typeof r != "object" ? null : (r = j && r[j] || r["@@iterator"], typeof r == "function" ? r : null);
+  }
+  var L = {
+    isMounted: function() {
+      return !1;
+    },
+    enqueueForceUpdate: function() {
+    },
+    enqueueReplaceState: function() {
+    },
+    enqueueSetState: function() {
+    }
+  }, S = Object.assign, C = {};
+  function P(r, y, q) {
+    this.props = r, this.context = y, this.refs = C, this.updater = q || L;
+  }
+  P.prototype.isReactComponent = {}, P.prototype.setState = function(r, y) {
+    if (typeof r != "object" && typeof r != "function" && r != null)
+      throw Error(
+        "takes an object of state variables to update or a function which returns an object of state variables."
+      );
+    this.updater.enqueueSetState(this, r, y, "setState");
+  }, P.prototype.forceUpdate = function(r) {
+    this.updater.enqueueForceUpdate(this, r, "forceUpdate");
+  };
+  function A() {
+  }
+  A.prototype = P.prototype;
+  function N(r, y, q) {
+    this.props = r, this.context = y, this.refs = C, this.updater = q || L;
+  }
+  var D = N.prototype = new A();
+  D.constructor = N, S(D, P.prototype), D.isPureReactComponent = !0;
+  var t = Array.isArray;
+  function l() {
+  }
+  var o = { H: null, A: null, T: null, S: null }, u = Object.prototype.hasOwnProperty;
+  function g(r, y, q) {
+    var I = q.ref;
+    return {
+      $$typeof: h,
+      type: r,
+      key: y,
+      ref: I !== void 0 ? I : null,
+      props: q
+    };
+  }
+  function M(r, y) {
+    return g(r.type, y, r.props);
+  }
+  function F(r) {
+    return typeof r == "object" && r !== null && r.$$typeof === h;
+  }
+  function H(r) {
+    var y = { "=": "=0", ":": "=2" };
+    return "$" + r.replace(/[=:]/g, function(q) {
+      return y[q];
+    });
+  }
+  var J = /\/+/g;
+  function te(r, y) {
+    return typeof r == "object" && r !== null && r.key != null ? H("" + r.key) : y.toString(36);
+  }
+  function ae(r) {
+    switch (r.status) {
+      case "fulfilled":
+        return r.value;
+      case "rejected":
+        throw r.reason;
+      default:
+        switch (typeof r.status == "string" ? r.then(l, l) : (r.status = "pending", r.then(
+          function(y) {
+            r.status === "pending" && (r.status = "fulfilled", r.value = y);
+          },
+          function(y) {
+            r.status === "pending" && (r.status = "rejected", r.reason = y);
+          }
+        )), r.status) {
+          case "fulfilled":
+            return r.value;
+          case "rejected":
+            throw r.reason;
+        }
+    }
+    throw r;
+  }
+  function re(r, y, q, I, $) {
+    var Y = typeof r;
+    (Y === "undefined" || Y === "boolean") && (r = null);
+    var z = !1;
+    if (r === null) z = !0;
+    else
+      switch (Y) {
+        case "bigint":
+        case "string":
+        case "number":
+          z = !0;
+          break;
+        case "object":
+          switch (r.$$typeof) {
+            case h:
+            case a:
+              z = !0;
+              break;
+            case v:
+              return z = r._init, re(
+                z(r._payload),
+                y,
+                q,
+                I,
+                $
+              );
+          }
+      }
+    if (z)
+      return $ = $(r), z = I === "" ? "." + te(r, 0) : I, t($) ? (q = "", z != null && (q = z.replace(J, "$&/") + "/"), re($, y, q, "", function(ce) {
+        return ce;
+      })) : $ != null && (F($) && ($ = M(
+        $,
+        q + ($.key == null || r && r.key === $.key ? "" : ("" + $.key).replace(
+          J,
+          "$&/"
+        ) + "/") + z
+      )), y.push($)), 1;
+    z = 0;
+    var ee = I === "" ? "." : I + ":";
+    if (t(r))
+      for (var V = 0; V < r.length; V++)
+        I = r[V], Y = ee + te(I, V), z += re(
+          I,
+          y,
+          q,
+          Y,
+          $
+        );
+    else if (V = G(r), typeof V == "function")
+      for (r = V.call(r), V = 0; !(I = r.next()).done; )
+        I = I.value, Y = ee + te(I, V++), z += re(
+          I,
+          y,
+          q,
+          Y,
+          $
+        );
+    else if (Y === "object") {
+      if (typeof r.then == "function")
+        return re(
+          ae(r),
+          y,
+          q,
+          I,
+          $
+        );
+      throw y = String(r), Error(
+        "Objects are not valid as a React child (found: " + (y === "[object Object]" ? "object with keys {" + Object.keys(r).join(", ") + "}" : y) + "). If you meant to render a collection of children, use an array instead."
+      );
+    }
+    return z;
+  }
+  function oe(r, y, q) {
+    if (r == null) return r;
+    var I = [], $ = 0;
+    return re(r, I, "", "", function(Y) {
+      return y.call(q, Y, $++);
+    }), I;
+  }
+  function ue(r) {
+    if (r._status === -1) {
+      var y = r._result;
+      y = y(), y.then(
+        function(q) {
+          (r._status === 0 || r._status === -1) && (r._status = 1, r._result = q);
+        },
+        function(q) {
+          (r._status === 0 || r._status === -1) && (r._status = 2, r._result = q);
+        }
+      ), r._status === -1 && (r._status = 0, r._result = y);
+    }
+    if (r._status === 1) return r._result.default;
+    throw r._result;
+  }
+  var se = typeof reportError == "function" ? reportError : function(r) {
+    if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+      var y = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: typeof r == "object" && r !== null && typeof r.message == "string" ? String(r.message) : String(r),
+        error: r
+      });
+      if (!window.dispatchEvent(y)) return;
+    } else if (typeof process == "object" && typeof process.emit == "function") {
+      process.emit("uncaughtException", r);
+      return;
+    }
+    console.error(r);
+  }, fe = {
+    map: oe,
+    forEach: function(r, y, q) {
+      oe(
+        r,
+        function() {
+          y.apply(this, arguments);
+        },
+        q
+      );
+    },
+    count: function(r) {
+      var y = 0;
+      return oe(r, function() {
+        y++;
+      }), y;
+    },
+    toArray: function(r) {
+      return oe(r, function(y) {
+        return y;
+      }) || [];
+    },
+    only: function(r) {
+      if (!F(r))
+        throw Error(
+          "React.Children.only expected to receive a single React element child."
+        );
+      return r;
+    }
+  };
+  return U.Activity = T, U.Children = fe, U.Component = P, U.Fragment = E, U.Profiler = R, U.PureComponent = N, U.StrictMode = b, U.Suspense = d, U.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = o, U.__COMPILER_RUNTIME = {
+    __proto__: null,
+    c: function(r) {
+      return o.H.useMemoCache(r);
+    }
+  }, U.cache = function(r) {
+    return function() {
+      return r.apply(null, arguments);
+    };
+  }, U.cacheSignal = function() {
+    return null;
+  }, U.cloneElement = function(r, y, q) {
+    if (r == null)
+      throw Error(
+        "The argument must be a React element, but you passed " + r + "."
+      );
+    var I = S({}, r.props), $ = r.key;
+    if (y != null)
+      for (Y in y.key !== void 0 && ($ = "" + y.key), y)
+        !u.call(y, Y) || Y === "key" || Y === "__self" || Y === "__source" || Y === "ref" && y.ref === void 0 || (I[Y] = y[Y]);
+    var Y = arguments.length - 2;
+    if (Y === 1) I.children = q;
+    else if (1 < Y) {
+      for (var z = Array(Y), ee = 0; ee < Y; ee++)
+        z[ee] = arguments[ee + 2];
+      I.children = z;
+    }
+    return g(r.type, $, I);
+  }, U.createContext = function(r) {
+    return r = {
+      $$typeof: c,
+      _currentValue: r,
+      _currentValue2: r,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null
+    }, r.Provider = r, r.Consumer = {
+      $$typeof: w,
+      _context: r
+    }, r;
+  }, U.createElement = function(r, y, q) {
+    var I, $ = {}, Y = null;
+    if (y != null)
+      for (I in y.key !== void 0 && (Y = "" + y.key), y)
+        u.call(y, I) && I !== "key" && I !== "__self" && I !== "__source" && ($[I] = y[I]);
+    var z = arguments.length - 2;
+    if (z === 1) $.children = q;
+    else if (1 < z) {
+      for (var ee = Array(z), V = 0; V < z; V++)
+        ee[V] = arguments[V + 2];
+      $.children = ee;
+    }
+    if (r && r.defaultProps)
+      for (I in z = r.defaultProps, z)
+        $[I] === void 0 && ($[I] = z[I]);
+    return g(r, Y, $);
+  }, U.createRef = function() {
+    return { current: null };
+  }, U.forwardRef = function(r) {
+    return { $$typeof: p, render: r };
+  }, U.isValidElement = F, U.lazy = function(r) {
+    return {
+      $$typeof: v,
+      _payload: { _status: -1, _result: r },
+      _init: ue
+    };
+  }, U.memo = function(r, y) {
+    return {
+      $$typeof: s,
+      type: r,
+      compare: y === void 0 ? null : y
+    };
+  }, U.startTransition = function(r) {
+    var y = o.T, q = {};
+    o.T = q;
+    try {
+      var I = r(), $ = o.S;
+      $ !== null && $(q, I), typeof I == "object" && I !== null && typeof I.then == "function" && I.then(l, se);
+    } catch (Y) {
+      se(Y);
+    } finally {
+      y !== null && q.types !== null && (y.types = q.types), o.T = y;
+    }
+  }, U.unstable_useCacheRefresh = function() {
+    return o.H.useCacheRefresh();
+  }, U.use = function(r) {
+    return o.H.use(r);
+  }, U.useActionState = function(r, y, q) {
+    return o.H.useActionState(r, y, q);
+  }, U.useCallback = function(r, y) {
+    return o.H.useCallback(r, y);
+  }, U.useContext = function(r) {
+    return o.H.useContext(r);
+  }, U.useDebugValue = function() {
+  }, U.useDeferredValue = function(r, y) {
+    return o.H.useDeferredValue(r, y);
+  }, U.useEffect = function(r, y) {
+    return o.H.useEffect(r, y);
+  }, U.useEffectEvent = function(r) {
+    return o.H.useEffectEvent(r);
+  }, U.useId = function() {
+    return o.H.useId();
+  }, U.useImperativeHandle = function(r, y, q) {
+    return o.H.useImperativeHandle(r, y, q);
+  }, U.useInsertionEffect = function(r, y) {
+    return o.H.useInsertionEffect(r, y);
+  }, U.useLayoutEffect = function(r, y) {
+    return o.H.useLayoutEffect(r, y);
+  }, U.useMemo = function(r, y) {
+    return o.H.useMemo(r, y);
+  }, U.useOptimistic = function(r, y) {
+    return o.H.useOptimistic(r, y);
+  }, U.useReducer = function(r, y, q) {
+    return o.H.useReducer(r, y, q);
+  }, U.useRef = function(r) {
+    return o.H.useRef(r);
+  }, U.useState = function(r) {
+    return o.H.useState(r);
+  }, U.useSyncExternalStore = function(r, y, q) {
+    return o.H.useSyncExternalStore(
+      r,
+      y,
+      q
+    );
+  }, U.useTransition = function() {
+    return o.H.useTransition();
+  }, U.version = "19.2.3", U;
+}
+var _e = { exports: {} };
+/**
+ * @license React
+ * react.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+_e.exports;
+var kt;
+function pr() {
+  return kt || (kt = 1, (function(h, a) {
+    process.env.NODE_ENV !== "production" && (function() {
+      function E(e, n) {
+        Object.defineProperty(w.prototype, e, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              n[0],
+              n[1]
+            );
+          }
+        });
+      }
+      function b(e) {
+        return e === null || typeof e != "object" ? null : (e = ve && e[ve] || e["@@iterator"], typeof e == "function" ? e : null);
+      }
+      function R(e, n) {
+        e = (e = e.constructor) && (e.displayName || e.name) || "ReactClass";
+        var m = e + "." + n;
+        ie[m] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          n,
+          e
+        ), ie[m] = !0);
+      }
+      function w(e, n, m) {
+        this.props = e, this.context = n, this.refs = ye, this.updater = m || we;
+      }
+      function c() {
+      }
+      function p(e, n, m) {
+        this.props = e, this.context = n, this.refs = ye, this.updater = m || we;
+      }
+      function d() {
+      }
+      function s(e) {
+        return "" + e;
+      }
+      function v(e) {
+        try {
+          s(e);
+          var n = !1;
+        } catch {
+          n = !0;
+        }
+        if (n) {
+          n = console;
+          var m = n.error, O = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
+          return m.call(
+            n,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            O
+          ), s(e);
+        }
+      }
+      function T(e) {
+        if (e == null) return null;
+        if (typeof e == "function")
+          return e.$$typeof === f ? null : e.displayName || e.name || null;
+        if (typeof e == "string") return e;
+        switch (e) {
+          case r:
+            return "Fragment";
+          case q:
+            return "Profiler";
+          case y:
+            return "StrictMode";
+          case z:
+            return "Suspense";
+          case ee:
+            return "SuspenseList";
+          case be:
+            return "Activity";
+        }
+        if (typeof e == "object")
+          switch (typeof e.tag == "number" && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), e.$$typeof) {
+            case fe:
+              return "Portal";
+            case $:
+              return e.displayName || "Context";
+            case I:
+              return (e._context.displayName || "Context") + ".Consumer";
+            case Y:
+              var n = e.render;
+              return e = e.displayName, e || (e = n.displayName || n.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
+            case V:
+              return n = e.displayName || null, n !== null ? n : T(e.type) || "Memo";
+            case ce:
+              n = e._payload, e = e._init;
+              try {
+                return T(e(n));
+              } catch {
+              }
+          }
+        return null;
+      }
+      function j(e) {
+        if (e === r) return "<>";
+        if (typeof e == "object" && e !== null && e.$$typeof === ce)
+          return "<...>";
+        try {
+          var n = T(e);
+          return n ? "<" + n + ">" : "<...>";
+        } catch {
+          return "<...>";
+        }
+      }
+      function G() {
+        var e = i.A;
+        return e === null ? null : e.getOwner();
+      }
+      function L() {
+        return Error("react-stack-top-frame");
+      }
+      function S(e) {
+        if (_.call(e, "key")) {
+          var n = Object.getOwnPropertyDescriptor(e, "key").get;
+          if (n && n.isReactWarning) return !1;
+        }
+        return e.key !== void 0;
+      }
+      function C(e, n) {
+        function m() {
+          K || (K = !0, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            n
+          ));
+        }
+        m.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: m,
+          configurable: !0
+        });
+      }
+      function P() {
+        var e = T(this.type);
+        return lt[e] || (lt[e] = !0, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        )), e = this.props.ref, e !== void 0 ? e : null;
+      }
+      function A(e, n, m, O, k, X) {
+        var W = m.ref;
+        return e = {
+          $$typeof: se,
+          type: e,
+          key: n,
+          props: m,
+          _owner: O
+        }, (W !== void 0 ? W : null) !== null ? Object.defineProperty(e, "ref", {
+          enumerable: !1,
+          get: P
+        }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: 0
+        }), Object.defineProperty(e, "_debugInfo", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: null
+        }), Object.defineProperty(e, "_debugStack", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: k
+        }), Object.defineProperty(e, "_debugTask", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: X
+        }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+      }
+      function N(e, n) {
+        return n = A(
+          e.type,
+          n,
+          e.props,
+          e._owner,
+          e._debugStack,
+          e._debugTask
+        ), e._store && (n._store.validated = e._store.validated), n;
+      }
+      function D(e) {
+        t(e) ? e._store && (e._store.validated = 1) : typeof e == "object" && e !== null && e.$$typeof === ce && (e._payload.status === "fulfilled" ? t(e._payload.value) && e._payload.value._store && (e._payload.value._store.validated = 1) : e._store && (e._store.validated = 1));
+      }
+      function t(e) {
+        return typeof e == "object" && e !== null && e.$$typeof === se;
+      }
+      function l(e) {
+        var n = { "=": "=0", ":": "=2" };
+        return "$" + e.replace(/[=:]/g, function(m) {
+          return n[m];
+        });
+      }
+      function o(e, n) {
+        return typeof e == "object" && e !== null && e.key != null ? (v(e.key), l("" + e.key)) : n.toString(36);
+      }
+      function u(e) {
+        switch (e.status) {
+          case "fulfilled":
+            return e.value;
+          case "rejected":
+            throw e.reason;
+          default:
+            switch (typeof e.status == "string" ? e.then(d, d) : (e.status = "pending", e.then(
+              function(n) {
+                e.status === "pending" && (e.status = "fulfilled", e.value = n);
+              },
+              function(n) {
+                e.status === "pending" && (e.status = "rejected", e.reason = n);
+              }
+            )), e.status) {
+              case "fulfilled":
+                return e.value;
+              case "rejected":
+                throw e.reason;
+            }
+        }
+        throw e;
+      }
+      function g(e, n, m, O, k) {
+        var X = typeof e;
+        (X === "undefined" || X === "boolean") && (e = null);
+        var W = !1;
+        if (e === null) W = !0;
+        else
+          switch (X) {
+            case "bigint":
+            case "string":
+            case "number":
+              W = !0;
+              break;
+            case "object":
+              switch (e.$$typeof) {
+                case se:
+                case fe:
+                  W = !0;
+                  break;
+                case ce:
+                  return W = e._init, g(
+                    W(e._payload),
+                    n,
+                    m,
+                    O,
+                    k
+                  );
+              }
+          }
+        if (W) {
+          W = e, k = k(W);
+          var Z = O === "" ? "." + o(W, 0) : O;
+          return Oe(k) ? (m = "", Z != null && (m = Z.replace(pt, "$&/") + "/"), g(k, n, m, "", function(le) {
+            return le;
+          })) : k != null && (t(k) && (k.key != null && (W && W.key === k.key || v(k.key)), m = N(
+            k,
+            m + (k.key == null || W && W.key === k.key ? "" : ("" + k.key).replace(
+              pt,
+              "$&/"
+            ) + "/") + Z
+          ), O !== "" && W != null && t(W) && W.key == null && W._store && !W._store.validated && (m._store.validated = 2), k = m), n.push(k)), 1;
+        }
+        if (W = 0, Z = O === "" ? "." : O + ":", Oe(e))
+          for (var B = 0; B < e.length; B++)
+            O = e[B], X = Z + o(O, B), W += g(
+              O,
+              n,
+              m,
+              X,
+              k
+            );
+        else if (B = b(e), typeof B == "function")
+          for (B === e.entries && (dt || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), dt = !0), e = B.call(e), B = 0; !(O = e.next()).done; )
+            O = O.value, X = Z + o(O, B++), W += g(
+              O,
+              n,
+              m,
+              X,
+              k
+            );
+        else if (X === "object") {
+          if (typeof e.then == "function")
+            return g(
+              u(e),
+              n,
+              m,
+              O,
+              k
+            );
+          throw n = String(e), Error(
+            "Objects are not valid as a React child (found: " + (n === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : n) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return W;
+      }
+      function M(e, n, m) {
+        if (e == null) return e;
+        var O = [], k = 0;
+        return g(e, O, "", "", function(X) {
+          return n.call(m, X, k++);
+        }), O;
+      }
+      function F(e) {
+        if (e._status === -1) {
+          var n = e._ioInfo;
+          n != null && (n.start = n.end = performance.now()), n = e._result;
+          var m = n();
+          if (m.then(
+            function(k) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 1, e._result = k;
+                var X = e._ioInfo;
+                X != null && (X.end = performance.now()), m.status === void 0 && (m.status = "fulfilled", m.value = k);
+              }
+            },
+            function(k) {
+              if (e._status === 0 || e._status === -1) {
+                e._status = 2, e._result = k;
+                var X = e._ioInfo;
+                X != null && (X.end = performance.now()), m.status === void 0 && (m.status = "rejected", m.reason = k);
+              }
+            }
+          ), n = e._ioInfo, n != null) {
+            n.value = m;
+            var O = m.displayName;
+            typeof O == "string" && (n.name = O);
+          }
+          e._status === -1 && (e._status = 0, e._result = m);
+        }
+        if (e._status === 1)
+          return n = e._result, n === void 0 && console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`,
+            n
+          ), "default" in n || console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`,
+            n
+          ), n.default;
+        throw e._result;
+      }
+      function H() {
+        var e = i.H;
+        return e === null && console.error(
+          `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+        ), e;
+      }
+      function J() {
+        i.asyncTransitions--;
+      }
+      function te(e) {
+        if (Ae === null)
+          try {
+            var n = ("require" + Math.random()).slice(0, 7);
+            Ae = (h && h[n]).call(
+              h,
+              "timers"
+            ).setImmediate;
+          } catch {
+            Ae = function(O) {
+              yt === !1 && (yt = !0, typeof MessageChannel > "u" && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var k = new MessageChannel();
+              k.port1.onmessage = O, k.port2.postMessage(void 0);
+            };
+          }
+        return Ae(e);
+      }
+      function ae(e) {
+        return 1 < e.length && typeof AggregateError == "function" ? new AggregateError(e) : e[0];
+      }
+      function re(e, n) {
+        n !== Te - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        ), Te = n;
+      }
+      function oe(e, n, m) {
+        var O = i.actQueue;
+        if (O !== null)
+          if (O.length !== 0)
+            try {
+              ue(O), te(function() {
+                return oe(e, n, m);
+              });
+              return;
+            } catch (k) {
+              i.thrownErrors.push(k);
+            }
+          else i.actQueue = null;
+        0 < i.thrownErrors.length ? (O = ae(i.thrownErrors), i.thrownErrors.length = 0, m(O)) : n(e);
+      }
+      function ue(e) {
+        if (!Ne) {
+          Ne = !0;
+          var n = 0;
+          try {
+            for (; n < e.length; n++) {
+              var m = e[n];
+              do {
+                i.didUsePromise = !1;
+                var O = m(!1);
+                if (O !== null) {
+                  if (i.didUsePromise) {
+                    e[n] = m, e.splice(0, n);
+                    return;
+                  }
+                  m = O;
+                } else break;
+              } while (!0);
+            }
+            e.length = 0;
+          } catch (k) {
+            e.splice(0, n + 1), i.thrownErrors.push(k);
+          } finally {
+            Ne = !1;
+          }
+        }
+      }
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var se = Symbol.for("react.transitional.element"), fe = Symbol.for("react.portal"), r = Symbol.for("react.fragment"), y = Symbol.for("react.strict_mode"), q = Symbol.for("react.profiler"), I = Symbol.for("react.consumer"), $ = Symbol.for("react.context"), Y = Symbol.for("react.forward_ref"), z = Symbol.for("react.suspense"), ee = Symbol.for("react.suspense_list"), V = Symbol.for("react.memo"), ce = Symbol.for("react.lazy"), be = Symbol.for("react.activity"), ve = Symbol.iterator, ie = {}, we = {
+        isMounted: function() {
+          return !1;
+        },
+        enqueueForceUpdate: function(e) {
+          R(e, "forceUpdate");
+        },
+        enqueueReplaceState: function(e) {
+          R(e, "replaceState");
+        },
+        enqueueSetState: function(e) {
+          R(e, "setState");
+        }
+      }, de = Object.assign, ye = {};
+      Object.freeze(ye), w.prototype.isReactComponent = {}, w.prototype.setState = function(e, n) {
+        if (typeof e != "object" && typeof e != "function" && e != null)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, e, n, "setState");
+      }, w.prototype.forceUpdate = function(e) {
+        this.updater.enqueueForceUpdate(this, e, "forceUpdate");
+      };
+      var ne = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      };
+      for (me in ne)
+        ne.hasOwnProperty(me) && E(me, ne[me]);
+      c.prototype = w.prototype, ne = p.prototype = new c(), ne.constructor = p, de(ne, w.prototype), ne.isPureReactComponent = !0;
+      var Oe = Array.isArray, f = Symbol.for("react.client.reference"), i = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        actQueue: null,
+        asyncTransitions: 0,
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1,
+        didUsePromise: !1,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, _ = Object.prototype.hasOwnProperty, x = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      ne = {
+        react_stack_bottom_frame: function(e) {
+          return e();
+        }
+      };
+      var K, Q, lt = {}, tr = ne.react_stack_bottom_frame.bind(
+        ne,
+        L
+      )(), rr = x(j(L)), dt = !1, pt = /\/+/g, ht = typeof reportError == "function" ? reportError : function(e) {
+        if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+          var n = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: typeof e == "object" && e !== null && typeof e.message == "string" ? String(e.message) : String(e),
+            error: e
+          });
+          if (!window.dispatchEvent(n)) return;
+        } else if (typeof process == "object" && typeof process.emit == "function") {
+          process.emit("uncaughtException", e);
+          return;
+        }
+        console.error(e);
+      }, yt = !1, Ae = null, Te = 0, Se = !1, Ne = !1, mt = typeof queueMicrotask == "function" ? function(e) {
+        queueMicrotask(function() {
+          return queueMicrotask(e);
+        });
+      } : te;
+      ne = Object.freeze({
+        __proto__: null,
+        c: function(e) {
+          return H().useMemoCache(e);
+        }
+      });
+      var me = {
+        map: M,
+        forEach: function(e, n, m) {
+          M(
+            e,
+            function() {
+              n.apply(this, arguments);
+            },
+            m
+          );
+        },
+        count: function(e) {
+          var n = 0;
+          return M(e, function() {
+            n++;
+          }), n;
+        },
+        toArray: function(e) {
+          return M(e, function(n) {
+            return n;
+          }) || [];
+        },
+        only: function(e) {
+          if (!t(e))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return e;
+        }
+      };
+      a.Activity = be, a.Children = me, a.Component = w, a.Fragment = r, a.Profiler = q, a.PureComponent = p, a.StrictMode = y, a.Suspense = z, a.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = i, a.__COMPILER_RUNTIME = ne, a.act = function(e) {
+        var n = i.actQueue, m = Te;
+        Te++;
+        var O = i.actQueue = n !== null ? n : [], k = !1;
+        try {
+          var X = e();
+        } catch (B) {
+          i.thrownErrors.push(B);
+        }
+        if (0 < i.thrownErrors.length)
+          throw re(n, m), e = ae(i.thrownErrors), i.thrownErrors.length = 0, e;
+        if (X !== null && typeof X == "object" && typeof X.then == "function") {
+          var W = X;
+          return mt(function() {
+            k || Se || (Se = !0, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          }), {
+            then: function(B, le) {
+              k = !0, W.then(
+                function(pe) {
+                  if (re(n, m), m === 0) {
+                    try {
+                      ue(O), te(function() {
+                        return oe(
+                          pe,
+                          B,
+                          le
+                        );
+                      });
+                    } catch (or) {
+                      i.thrownErrors.push(or);
+                    }
+                    if (0 < i.thrownErrors.length) {
+                      var nr = ae(
+                        i.thrownErrors
+                      );
+                      i.thrownErrors.length = 0, le(nr);
+                    }
+                  } else B(pe);
+                },
+                function(pe) {
+                  re(n, m), 0 < i.thrownErrors.length && (pe = ae(
+                    i.thrownErrors
+                  ), i.thrownErrors.length = 0), le(pe);
+                }
+              );
+            }
+          };
+        }
+        var Z = X;
+        if (re(n, m), m === 0 && (ue(O), O.length !== 0 && mt(function() {
+          k || Se || (Se = !0, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), i.actQueue = null), 0 < i.thrownErrors.length)
+          throw e = ae(i.thrownErrors), i.thrownErrors.length = 0, e;
+        return {
+          then: function(B, le) {
+            k = !0, m === 0 ? (i.actQueue = O, te(function() {
+              return oe(
+                Z,
+                B,
+                le
+              );
+            })) : B(Z);
+          }
+        };
+      }, a.cache = function(e) {
+        return function() {
+          return e.apply(null, arguments);
+        };
+      }, a.cacheSignal = function() {
+        return null;
+      }, a.captureOwnerStack = function() {
+        var e = i.getCurrentStack;
+        return e === null ? null : e();
+      }, a.cloneElement = function(e, n, m) {
+        if (e == null)
+          throw Error(
+            "The argument must be a React element, but you passed " + e + "."
+          );
+        var O = de({}, e.props), k = e.key, X = e._owner;
+        if (n != null) {
+          var W;
+          e: {
+            if (_.call(n, "ref") && (W = Object.getOwnPropertyDescriptor(
+              n,
+              "ref"
+            ).get) && W.isReactWarning) {
+              W = !1;
+              break e;
+            }
+            W = n.ref !== void 0;
+          }
+          W && (X = G()), S(n) && (v(n.key), k = "" + n.key);
+          for (Z in n)
+            !_.call(n, Z) || Z === "key" || Z === "__self" || Z === "__source" || Z === "ref" && n.ref === void 0 || (O[Z] = n[Z]);
+        }
+        var Z = arguments.length - 2;
+        if (Z === 1) O.children = m;
+        else if (1 < Z) {
+          W = Array(Z);
+          for (var B = 0; B < Z; B++)
+            W[B] = arguments[B + 2];
+          O.children = W;
+        }
+        for (O = A(
+          e.type,
+          k,
+          O,
+          X,
+          e._debugStack,
+          e._debugTask
+        ), k = 2; k < arguments.length; k++)
+          D(arguments[k]);
+        return O;
+      }, a.createContext = function(e) {
+        return e = {
+          $$typeof: $,
+          _currentValue: e,
+          _currentValue2: e,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        }, e.Provider = e, e.Consumer = {
+          $$typeof: I,
+          _context: e
+        }, e._currentRenderer = null, e._currentRenderer2 = null, e;
+      }, a.createElement = function(e, n, m) {
+        for (var O = 2; O < arguments.length; O++)
+          D(arguments[O]);
+        O = {};
+        var k = null;
+        if (n != null)
+          for (B in Q || !("__self" in n) || "key" in n || (Q = !0, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), S(n) && (v(n.key), k = "" + n.key), n)
+            _.call(n, B) && B !== "key" && B !== "__self" && B !== "__source" && (O[B] = n[B]);
+        var X = arguments.length - 2;
+        if (X === 1) O.children = m;
+        else if (1 < X) {
+          for (var W = Array(X), Z = 0; Z < X; Z++)
+            W[Z] = arguments[Z + 2];
+          Object.freeze && Object.freeze(W), O.children = W;
+        }
+        if (e && e.defaultProps)
+          for (B in X = e.defaultProps, X)
+            O[B] === void 0 && (O[B] = X[B]);
+        k && C(
+          O,
+          typeof e == "function" ? e.displayName || e.name || "Unknown" : e
+        );
+        var B = 1e4 > i.recentlyCreatedOwnerStacks++;
+        return A(
+          e,
+          k,
+          O,
+          G(),
+          B ? Error("react-stack-top-frame") : tr,
+          B ? x(j(e)) : rr
+        );
+      }, a.createRef = function() {
+        var e = { current: null };
+        return Object.seal(e), e;
+      }, a.forwardRef = function(e) {
+        e != null && e.$$typeof === V ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : typeof e != "function" ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          e === null ? "null" : typeof e
+        ) : e.length !== 0 && e.length !== 2 && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          e.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        ), e != null && e.defaultProps != null && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var n = { $$typeof: Y, render: e }, m;
+        return Object.defineProperty(n, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return m;
+          },
+          set: function(O) {
+            m = O, e.name || e.displayName || (Object.defineProperty(e, "name", { value: O }), e.displayName = O);
+          }
+        }), n;
+      }, a.isValidElement = t, a.lazy = function(e) {
+        e = { _status: -1, _result: e };
+        var n = {
+          $$typeof: ce,
+          _payload: e,
+          _init: F
+        }, m = {
+          name: "lazy",
+          start: -1,
+          end: -1,
+          value: null,
+          owner: null,
+          debugStack: Error("react-stack-top-frame"),
+          debugTask: console.createTask ? console.createTask("lazy()") : null
+        };
+        return e._ioInfo = m, n._debugInfo = [{ awaited: m }], n;
+      }, a.memo = function(e, n) {
+        e == null && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          e === null ? "null" : typeof e
+        ), n = {
+          $$typeof: V,
+          type: e,
+          compare: n === void 0 ? null : n
+        };
+        var m;
+        return Object.defineProperty(n, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return m;
+          },
+          set: function(O) {
+            m = O, e.name || e.displayName || (Object.defineProperty(e, "name", { value: O }), e.displayName = O);
+          }
+        }), n;
+      }, a.startTransition = function(e) {
+        var n = i.T, m = {};
+        m._updatedFibers = /* @__PURE__ */ new Set(), i.T = m;
+        try {
+          var O = e(), k = i.S;
+          k !== null && k(m, O), typeof O == "object" && O !== null && typeof O.then == "function" && (i.asyncTransitions++, O.then(J, J), O.then(d, ht));
+        } catch (X) {
+          ht(X);
+        } finally {
+          n === null && m._updatedFibers && (e = m._updatedFibers.size, m._updatedFibers.clear(), 10 < e && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), n !== null && m.types !== null && (n.types !== null && n.types !== m.types && console.error(
+            "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
+          ), n.types = m.types), i.T = n;
+        }
+      }, a.unstable_useCacheRefresh = function() {
+        return H().useCacheRefresh();
+      }, a.use = function(e) {
+        return H().use(e);
+      }, a.useActionState = function(e, n, m) {
+        return H().useActionState(
+          e,
+          n,
+          m
+        );
+      }, a.useCallback = function(e, n) {
+        return H().useCallback(e, n);
+      }, a.useContext = function(e) {
+        var n = H();
+        return e.$$typeof === I && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        ), n.useContext(e);
+      }, a.useDebugValue = function(e, n) {
+        return H().useDebugValue(e, n);
+      }, a.useDeferredValue = function(e, n) {
+        return H().useDeferredValue(e, n);
+      }, a.useEffect = function(e, n) {
+        return e == null && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), H().useEffect(e, n);
+      }, a.useEffectEvent = function(e) {
+        return H().useEffectEvent(e);
+      }, a.useId = function() {
+        return H().useId();
+      }, a.useImperativeHandle = function(e, n, m) {
+        return H().useImperativeHandle(e, n, m);
+      }, a.useInsertionEffect = function(e, n) {
+        return e == null && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), H().useInsertionEffect(e, n);
+      }, a.useLayoutEffect = function(e, n) {
+        return e == null && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), H().useLayoutEffect(e, n);
+      }, a.useMemo = function(e, n) {
+        return H().useMemo(e, n);
+      }, a.useOptimistic = function(e, n) {
+        return H().useOptimistic(e, n);
+      }, a.useReducer = function(e, n, m) {
+        return H().useReducer(e, n, m);
+      }, a.useRef = function(e) {
+        return H().useRef(e);
+      }, a.useState = function(e) {
+        return H().useState(e);
+      }, a.useSyncExternalStore = function(e, n, m) {
+        return H().useSyncExternalStore(
+          e,
+          n,
+          m
+        );
+      }, a.useTransition = function() {
+        return H().useTransition();
+      }, a.version = "19.2.3", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  })(_e, _e.exports)), _e.exports;
+}
+var Pt;
+function Zt() {
+  return Pt || (Pt = 1, process.env.NODE_ENV === "production" ? Ce.exports = dr() : Ce.exports = pr()), Ce.exports;
+}
+var ke = { exports: {} }, jt;
+function Vt() {
+  return jt || (jt = 1, (function(h, a) {
+    Object.defineProperty(a, "__esModule", {
+      value: !0
+    });
+    function E(c, p) {
+      for (var d in p) Object.defineProperty(c, d, {
+        enumerable: !0,
+        get: p[d]
+      });
+    }
+    E(a, {
+      DynamicServerError: function() {
+        return R;
+      },
+      isDynamicServerError: function() {
+        return w;
+      }
+    });
+    const b = "DYNAMIC_SERVER_USAGE";
+    class R extends Error {
+      constructor(p) {
+        super(`Dynamic server usage: ${p}`), this.description = p, this.digest = b;
+      }
+    }
+    function w(c) {
+      return typeof c != "object" || c === null || !("digest" in c) || typeof c.digest != "string" ? !1 : c.digest === b;
+    }
+    (typeof a.default == "function" || typeof a.default == "object" && a.default !== null) && typeof a.default.__esModule > "u" && (Object.defineProperty(a.default, "__esModule", { value: !0 }), Object.assign(a.default, a), h.exports = a.default);
+  })(ke, ke.exports)), ke.exports;
+}
+var Pe = { exports: {} }, Nt;
+function Re() {
+  return Nt || (Nt = 1, (function(h, a) {
+    Object.defineProperty(a, "__esModule", {
+      value: !0
+    });
+    function E(c, p) {
+      for (var d in p) Object.defineProperty(c, d, {
+        enumerable: !0,
+        get: p[d]
+      });
+    }
+    E(a, {
+      StaticGenBailoutError: function() {
+        return R;
+      },
+      isStaticGenBailoutError: function() {
+        return w;
+      }
+    });
+    const b = "NEXT_STATIC_GEN_BAILOUT";
+    class R extends Error {
+      constructor(...p) {
+        super(...p), this.code = b;
+      }
+    }
+    function w(c) {
+      return typeof c != "object" || c === null || !("code" in c) ? !1 : c.code === b;
+    }
+    (typeof a.default == "function" || typeof a.default == "object" && a.default !== null) && typeof a.default.__esModule > "u" && (Object.defineProperty(a.default, "__esModule", { value: !0 }), Object.assign(a.default, a), h.exports = a.default);
+  })(Pe, Pe.exports)), Pe.exports;
+}
+var Fe = {}, It;
+function ut() {
+  return It || (It = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(s, v) {
+      for (var T in v) Object.defineProperty(s, T, {
+        enumerable: !0,
+        get: v[T]
+      });
+    }
+    a(h, {
+      isHangingPromiseRejectionError: function() {
+        return E;
+      },
+      makeDevtoolsIOAwarePromise: function() {
+        return d;
+      },
+      makeHangingPromise: function() {
+        return c;
+      }
+    });
+    function E(s) {
+      return typeof s != "object" || s === null || !("digest" in s) ? !1 : s.digest === b;
+    }
+    const b = "HANGING_PROMISE_REJECTION";
+    class R extends Error {
+      constructor(v, T) {
+        super(`During prerendering, ${T} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${T} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context. This occurred at route "${v}".`), this.route = v, this.expression = T, this.digest = b;
+      }
+    }
+    const w = /* @__PURE__ */ new WeakMap();
+    function c(s, v, T) {
+      if (s.aborted)
+        return Promise.reject(new R(v, T));
+      {
+        const j = new Promise((G, L) => {
+          const S = L.bind(null, new R(v, T));
+          let C = w.get(s);
+          if (C)
+            C.push(S);
+          else {
+            const P = [
+              S
+            ];
+            w.set(s, P), s.addEventListener("abort", () => {
+              for (let A = 0; A < P.length; A++)
+                P[A]();
+            }, {
+              once: !0
+            });
+          }
+        });
+        return j.catch(p), j;
+      }
+    }
+    function p() {
+    }
+    function d(s, v, T) {
+      return v.stagedRendering ? v.stagedRendering.delayUntilStage(T, void 0, s) : new Promise((j) => {
+        setTimeout(() => {
+          j(s);
+        }, 0);
+      });
+    }
+  })(Fe)), Fe;
+}
+var ze = {}, Mt;
+function hr() {
+  return Mt || (Mt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(c, p) {
+      for (var d in p) Object.defineProperty(c, d, {
+        enumerable: !0,
+        get: p[d]
+      });
+    }
+    a(h, {
+      METADATA_BOUNDARY_NAME: function() {
+        return E;
+      },
+      OUTLET_BOUNDARY_NAME: function() {
+        return R;
+      },
+      ROOT_LAYOUT_BOUNDARY_NAME: function() {
+        return w;
+      },
+      VIEWPORT_BOUNDARY_NAME: function() {
+        return b;
+      }
+    });
+    const E = "__next_metadata_boundary__", b = "__next_viewport_boundary__", R = "__next_outlet_boundary__", w = "__next_root_layout_boundary__";
+  })(ze)), ze;
+}
+var Qe = {}, Ht;
+function yr() {
+  return Ht || (Ht = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(c, p) {
+      for (var d in p) Object.defineProperty(c, d, {
+        enumerable: !0,
+        get: p[d]
+      });
+    }
+    a(h, {
+      atLeastOneTask: function() {
+        return R;
+      },
+      scheduleImmediate: function() {
+        return b;
+      },
+      scheduleOnNextTick: function() {
+        return E;
+      },
+      waitAtLeastOneReactRenderTask: function() {
+        return w;
+      }
+    });
+    const E = (c) => {
+      Promise.resolve().then(() => {
+        process.env.NEXT_RUNTIME === "edge" ? setTimeout(c, 0) : process.nextTick(c);
+      });
+    }, b = (c) => {
+      process.env.NEXT_RUNTIME === "edge" ? setTimeout(c, 0) : setImmediate(c);
+    };
+    function R() {
+      return new Promise((c) => b(c));
+    }
+    function w() {
+      return process.env.NEXT_RUNTIME === "edge" ? new Promise((c) => setTimeout(c, 0)) : new Promise((c) => setImmediate(c));
+    }
+  })(Qe)), Qe;
+}
+var Ke = {}, xt;
+function mr() {
+  return xt || (xt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(w, c) {
+      for (var p in c) Object.defineProperty(w, p, {
+        enumerable: !0,
+        get: c[p]
+      });
+    }
+    a(h, {
+      BailoutToCSRError: function() {
+        return b;
+      },
+      isBailoutToCSRError: function() {
+        return R;
+      }
+    });
+    const E = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+    class b extends Error {
+      constructor(c) {
+        super(`Bail out to client-side rendering: ${c}`), this.reason = c, this.digest = E;
+      }
+    }
+    function R(w) {
+      return typeof w != "object" || w === null || !("digest" in w) ? !1 : w.digest === E;
+    }
+  })(Ke)), Ke;
+}
+var qt;
+function ct() {
+  return qt || (qt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(f, i) {
+      for (var _ in i) Object.defineProperty(f, _, {
+        enumerable: !0,
+        get: i[_]
+      });
+    }
+    a(h, {
+      Postpone: function() {
+        return o;
+      },
+      PreludeState: function() {
+        return we;
+      },
+      abortAndThrowOnSynchronousRequestDataAccess: function() {
+        return l;
+      },
+      abortOnSynchronousPlatformIOAccess: function() {
+        return t;
+      },
+      accessedDynamicData: function() {
+        return ae;
+      },
+      annotateDynamicAccess: function() {
+        return r;
+      },
+      consumeDynamicAccess: function() {
+        return re;
+      },
+      createDynamicTrackingState: function() {
+        return L;
+      },
+      createDynamicValidationState: function() {
+        return S;
+      },
+      createHangingInputAbortSignal: function() {
+        return fe;
+      },
+      createRenderInBrowserAbortSignal: function() {
+        return se;
+      },
+      delayUntilRuntimeStage: function() {
+        return Oe;
+      },
+      formatDynamicAPIAccesses: function() {
+        return oe;
+      },
+      getFirstDynamicReason: function() {
+        return C;
+      },
+      getStaticShellDisallowedDynamicReasons: function() {
+        return ne;
+      },
+      isDynamicPostpone: function() {
+        return M;
+      },
+      isPrerenderInterruptedError: function() {
+        return te;
+      },
+      logDisallowedDynamicError: function() {
+        return de;
+      },
+      markCurrentScopeAsDynamic: function() {
+        return P;
+      },
+      postponeWithTracking: function() {
+        return u;
+      },
+      throwIfDisallowedDynamic: function() {
+        return ye;
+      },
+      throwToInterruptStaticGeneration: function() {
+        return A;
+      },
+      trackAllowedDynamicAccess: function() {
+        return ce;
+      },
+      trackDynamicDataInDynamicRender: function() {
+        return N;
+      },
+      trackDynamicHoleInRuntimeShell: function() {
+        return be;
+      },
+      trackDynamicHoleInStaticShell: function() {
+        return ve;
+      },
+      useDynamicRouteParams: function() {
+        return y;
+      },
+      useDynamicSearchParams: function() {
+        return q;
+      }
+    });
+    const E = /* @__PURE__ */ j(Zt()), b = Vt(), R = Re(), w = je(), c = Ee(), p = ut(), d = hr(), s = yr(), v = mr(), T = he();
+    function j(f) {
+      return f && f.__esModule ? f : {
+        default: f
+      };
+    }
+    const G = typeof E.default.unstable_postpone == "function";
+    function L(f) {
+      return {
+        isDebugDynamicAccesses: f,
+        dynamicAccesses: [],
+        syncDynamicErrorWithStack: null
+      };
+    }
+    function S() {
+      return {
+        hasSuspenseAboveBody: !1,
+        hasDynamicMetadata: !1,
+        dynamicMetadata: null,
+        hasDynamicViewport: !1,
+        hasAllowedDynamic: !1,
+        dynamicErrors: []
+      };
+    }
+    function C(f) {
+      var i;
+      return (i = f.dynamicAccesses[0]) == null ? void 0 : i.expression;
+    }
+    function P(f, i, _) {
+      if (i)
+        switch (i.type) {
+          case "cache":
+          case "unstable-cache":
+            return;
+          case "private-cache":
+            return;
+        }
+      if (!(f.forceDynamic || f.forceStatic)) {
+        if (f.dynamicShouldError)
+          throw Object.defineProperty(new R.StaticGenBailoutError(`Route ${f.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${_}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+            value: "E553",
+            enumerable: !1,
+            configurable: !0
+          });
+        if (i)
+          switch (i.type) {
+            case "prerender-ppr":
+              return u(f.route, _, i.dynamicTracking);
+            case "prerender-legacy":
+              i.revalidate = 0;
+              const x = Object.defineProperty(new b.DynamicServerError(`Route ${f.route} couldn't be rendered statically because it used ${_}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+                value: "E550",
+                enumerable: !1,
+                configurable: !0
+              });
+              throw f.dynamicUsageDescription = _, f.dynamicUsageStack = x.stack, x;
+            case "request":
+              process.env.NODE_ENV !== "production" && (i.usedDynamic = !0);
+              break;
+          }
+      }
+    }
+    function A(f, i, _) {
+      const x = Object.defineProperty(new b.DynamicServerError(`Route ${i.route} couldn't be rendered statically because it used \`${f}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+        value: "E558",
+        enumerable: !1,
+        configurable: !0
+      });
+      throw _.revalidate = 0, i.dynamicUsageDescription = f, i.dynamicUsageStack = x.stack, x;
+    }
+    function N(f) {
+      switch (f.type) {
+        case "cache":
+        case "unstable-cache":
+          return;
+        case "private-cache":
+          return;
+        case "prerender":
+        case "prerender-runtime":
+        case "prerender-legacy":
+        case "prerender-ppr":
+        case "prerender-client":
+          break;
+        case "request":
+          process.env.NODE_ENV !== "production" && (f.usedDynamic = !0);
+          break;
+      }
+    }
+    function D(f, i, _) {
+      const x = `Route ${f} needs to bail out of prerendering at this point because it used ${i}.`, K = J(x);
+      _.controller.abort(K);
+      const Q = _.dynamicTracking;
+      Q && Q.dynamicAccesses.push({
+        // When we aren't debugging, we don't need to create another error for the
+        // stack trace.
+        stack: Q.isDebugDynamicAccesses ? new Error().stack : void 0,
+        expression: i
+      });
+    }
+    function t(f, i, _, x) {
+      const K = x.dynamicTracking;
+      D(f, i, x), K && K.syncDynamicErrorWithStack === null && (K.syncDynamicErrorWithStack = _);
+    }
+    function l(f, i, _, x) {
+      if (x.controller.signal.aborted === !1) {
+        D(f, i, x);
+        const Q = x.dynamicTracking;
+        Q && Q.syncDynamicErrorWithStack === null && (Q.syncDynamicErrorWithStack = _);
+      }
+      throw J(`Route ${f} needs to bail out of prerendering at this point because it used ${i}.`);
+    }
+    function o({ reason: f, route: i }) {
+      const _ = w.workUnitAsyncStorage.getStore(), x = _ && _.type === "prerender-ppr" ? _.dynamicTracking : null;
+      u(i, f, x);
+    }
+    function u(f, i, _) {
+      ue(), _ && _.dynamicAccesses.push({
+        // When we aren't debugging, we don't need to create another error for the
+        // stack trace.
+        stack: _.isDebugDynamicAccesses ? new Error().stack : void 0,
+        expression: i
+      }), E.default.unstable_postpone(g(f, i));
+    }
+    function g(f, i) {
+      return `Route ${f} needs to bail out of prerendering at this point because it used ${i}. React throws this special object to indicate where. It should not be caught by your own try/catch. Learn more: https://nextjs.org/docs/messages/ppr-caught-error`;
+    }
+    function M(f) {
+      return typeof f == "object" && f !== null && typeof f.message == "string" ? F(f.message) : !1;
+    }
+    function F(f) {
+      return f.includes("needs to bail out of prerendering at this point because it used") && f.includes("Learn more: https://nextjs.org/docs/messages/ppr-caught-error");
+    }
+    if (F(g("%%%", "^^^")) === !1)
+      throw Object.defineProperty(new Error("Invariant: isDynamicPostpone misidentified a postpone reason. This is a bug in Next.js"), "__NEXT_ERROR_CODE", {
+        value: "E296",
+        enumerable: !1,
+        configurable: !0
+      });
+    const H = "NEXT_PRERENDER_INTERRUPTED";
+    function J(f) {
+      const i = Object.defineProperty(new Error(f), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: !1,
+        configurable: !0
+      });
+      return i.digest = H, i;
+    }
+    function te(f) {
+      return typeof f == "object" && f !== null && f.digest === H && "name" in f && "message" in f && f instanceof Error;
+    }
+    function ae(f) {
+      return f.length > 0;
+    }
+    function re(f, i) {
+      return f.dynamicAccesses.push(...i.dynamicAccesses), f.dynamicAccesses;
+    }
+    function oe(f) {
+      return f.filter((i) => typeof i.stack == "string" && i.stack.length > 0).map(({ expression: i, stack: _ }) => (_ = _.split(`
+`).slice(4).filter((x) => !(x.includes("node_modules/next/") || x.includes(" (<anonymous>)") || x.includes(" (node:"))).join(`
+`), `Dynamic API Usage Debug - ${i}:
+${_}`));
+    }
+    function ue() {
+      if (!G)
+        throw Object.defineProperty(new Error("Invariant: React.unstable_postpone is not defined. This suggests the wrong version of React was loaded. This is a bug in Next.js"), "__NEXT_ERROR_CODE", {
+          value: "E224",
+          enumerable: !1,
+          configurable: !0
+        });
+    }
+    function se() {
+      const f = new AbortController();
+      return f.abort(Object.defineProperty(new v.BailoutToCSRError("Render in Browser"), "__NEXT_ERROR_CODE", {
+        value: "E721",
+        enumerable: !1,
+        configurable: !0
+      })), f.signal;
+    }
+    function fe(f) {
+      switch (f.type) {
+        case "prerender":
+        case "prerender-runtime":
+          const i = new AbortController();
+          if (f.cacheSignal)
+            f.cacheSignal.inputReady().then(() => {
+              i.abort();
+            });
+          else {
+            const _ = (0, w.getRuntimeStagePromise)(f);
+            _ ? _.then(() => (0, s.scheduleOnNextTick)(() => i.abort())) : (0, s.scheduleOnNextTick)(() => i.abort());
+          }
+          return i.signal;
+        case "prerender-client":
+        case "prerender-ppr":
+        case "prerender-legacy":
+        case "request":
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+          return;
+      }
+    }
+    function r(f, i) {
+      const _ = i.dynamicTracking;
+      _ && _.dynamicAccesses.push({
+        stack: _.isDebugDynamicAccesses ? new Error().stack : void 0,
+        expression: f
+      });
+    }
+    function y(f) {
+      const i = c.workAsyncStorage.getStore(), _ = w.workUnitAsyncStorage.getStore();
+      if (i && _)
+        switch (_.type) {
+          case "prerender-client":
+          case "prerender": {
+            const x = _.fallbackRouteParams;
+            x && x.size > 0 && E.default.use((0, p.makeHangingPromise)(_.renderSignal, i.route, f));
+            break;
+          }
+          case "prerender-ppr": {
+            const x = _.fallbackRouteParams;
+            if (x && x.size > 0)
+              return u(i.route, f, _.dynamicTracking);
+            break;
+          }
+          case "prerender-runtime":
+            throw Object.defineProperty(new T.InvariantError(`\`${f}\` was called during a runtime prerender. Next.js should be preventing ${f} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+              value: "E771",
+              enumerable: !1,
+              configurable: !0
+            });
+          case "cache":
+          case "private-cache":
+            throw Object.defineProperty(new T.InvariantError(`\`${f}\` was called inside a cache scope. Next.js should be preventing ${f} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+              value: "E745",
+              enumerable: !1,
+              configurable: !0
+            });
+        }
+    }
+    function q(f) {
+      const i = c.workAsyncStorage.getStore(), _ = w.workUnitAsyncStorage.getStore();
+      if (i)
+        switch (_ || (0, w.throwForMissingRequestStore)(f), _.type) {
+          case "prerender-client": {
+            E.default.use((0, p.makeHangingPromise)(_.renderSignal, i.route, f));
+            break;
+          }
+          case "prerender-legacy":
+          case "prerender-ppr": {
+            if (i.forceStatic)
+              return;
+            throw Object.defineProperty(new v.BailoutToCSRError(f), "__NEXT_ERROR_CODE", {
+              value: "E394",
+              enumerable: !1,
+              configurable: !0
+            });
+          }
+          case "prerender":
+          case "prerender-runtime":
+            throw Object.defineProperty(new T.InvariantError(`\`${f}\` was called from a Server Component. Next.js should be preventing ${f} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+              value: "E795",
+              enumerable: !1,
+              configurable: !0
+            });
+          case "cache":
+          case "unstable-cache":
+          case "private-cache":
+            throw Object.defineProperty(new T.InvariantError(`\`${f}\` was called inside a cache scope. Next.js should be preventing ${f} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+              value: "E745",
+              enumerable: !1,
+              configurable: !0
+            });
+          case "request":
+            return;
+        }
+    }
+    const I = /\n\s+at Suspense \(<anonymous>\)/, $ = "body|div|main|section|article|aside|header|footer|nav|form|p|span|h1|h2|h3|h4|h5|h6", Y = new RegExp(`\\n\\s+at Suspense \\(<anonymous>\\)(?:(?!\\n\\s+at (?:${$}) \\(<anonymous>\\))[\\s\\S])*?\\n\\s+at ${d.ROOT_LAYOUT_BOUNDARY_NAME} \\([^\\n]*\\)`), z = new RegExp(`\\n\\s+at ${d.METADATA_BOUNDARY_NAME}[\\n\\s]`), ee = new RegExp(`\\n\\s+at ${d.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`), V = new RegExp(`\\n\\s+at ${d.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
+    function ce(f, i, _, x) {
+      if (!V.test(i))
+        if (z.test(i)) {
+          _.hasDynamicMetadata = !0;
+          return;
+        } else if (ee.test(i)) {
+          _.hasDynamicViewport = !0;
+          return;
+        } else if (Y.test(i)) {
+          _.hasAllowedDynamic = !0, _.hasSuspenseAboveBody = !0;
+          return;
+        } else if (I.test(i)) {
+          _.hasAllowedDynamic = !0;
+          return;
+        } else if (x.syncDynamicErrorWithStack) {
+          _.dynamicErrors.push(x.syncDynamicErrorWithStack);
+          return;
+        } else {
+          const K = `Route "${f.route}": Uncached data was accessed outside of <Suspense>. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`, Q = ie(K, i);
+          _.dynamicErrors.push(Q);
+          return;
+        }
+    }
+    function be(f, i, _, x) {
+      if (!V.test(i))
+        if (z.test(i)) {
+          const K = `Route "${f.route}": Uncached data or \`connection()\` was accessed inside \`generateMetadata\`. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`, Q = ie(K, i);
+          _.dynamicMetadata = Q;
+          return;
+        } else if (ee.test(i)) {
+          const K = `Route "${f.route}": Uncached data or \`connection()\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`, Q = ie(K, i);
+          _.dynamicErrors.push(Q);
+          return;
+        } else if (Y.test(i)) {
+          _.hasAllowedDynamic = !0, _.hasSuspenseAboveBody = !0;
+          return;
+        } else if (I.test(i)) {
+          _.hasAllowedDynamic = !0;
+          return;
+        } else if (x.syncDynamicErrorWithStack) {
+          _.dynamicErrors.push(x.syncDynamicErrorWithStack);
+          return;
+        } else {
+          const K = `Route "${f.route}": Uncached data or \`connection()\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`, Q = ie(K, i);
+          _.dynamicErrors.push(Q);
+          return;
+        }
+    }
+    function ve(f, i, _, x) {
+      if (!V.test(i))
+        if (z.test(i)) {
+          const K = `Route "${f.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateMetadata\` or you have file-based metadata such as icons that depend on dynamic params segments. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`, Q = ie(K, i);
+          _.dynamicMetadata = Q;
+          return;
+        } else if (ee.test(i)) {
+          const K = `Route "${f.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`, Q = ie(K, i);
+          _.dynamicErrors.push(Q);
+          return;
+        } else if (Y.test(i)) {
+          _.hasAllowedDynamic = !0, _.hasSuspenseAboveBody = !0;
+          return;
+        } else if (I.test(i)) {
+          _.hasAllowedDynamic = !0;
+          return;
+        } else if (x.syncDynamicErrorWithStack) {
+          _.dynamicErrors.push(x.syncDynamicErrorWithStack);
+          return;
+        } else {
+          const K = `Route "${f.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`, Q = ie(K, i);
+          _.dynamicErrors.push(Q);
+          return;
+        }
+    }
+    function ie(f, i) {
+      const _ = process.env.NODE_ENV !== "production" && E.default.captureOwnerStack ? E.default.captureOwnerStack() : null, x = Object.defineProperty(new Error(f), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: !1,
+        configurable: !0
+      });
+      return x.stack = x.name + ": " + f + (_ || i), x;
+    }
+    var we = /* @__PURE__ */ (function(f) {
+      return f[f.Full = 0] = "Full", f[f.Empty = 1] = "Empty", f[f.Errored = 2] = "Errored", f;
+    })({});
+    function de(f, i) {
+      console.error(i), f.dev || (f.hasReadableErrorStacks ? console.error(`To get a more detailed stack trace and pinpoint the issue, start the app in development mode by running \`next dev\`, then open "${f.route}" in your browser to investigate the error.`) : console.error(`To get a more detailed stack trace and pinpoint the issue, try one of the following:
+  - Start the app in development mode by running \`next dev\`, then open "${f.route}" in your browser to investigate the error.
+  - Rerun the production build with \`next build --debug-prerender\` to generate better stack traces.`));
+    }
+    function ye(f, i, _, x) {
+      if (x.syncDynamicErrorWithStack)
+        throw de(f, x.syncDynamicErrorWithStack), new R.StaticGenBailoutError();
+      if (i !== 0) {
+        if (_.hasSuspenseAboveBody)
+          return;
+        const K = _.dynamicErrors;
+        if (K.length > 0) {
+          for (let Q = 0; Q < K.length; Q++)
+            de(f, K[Q]);
+          throw new R.StaticGenBailoutError();
+        }
+        if (_.hasDynamicViewport)
+          throw console.error(`Route "${f.route}" has a \`generateViewport\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) without explicitly allowing fully dynamic rendering. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`), new R.StaticGenBailoutError();
+        if (i === 1)
+          throw console.error(`Route "${f.route}" did not produce a static shell and Next.js was unable to determine a reason. This is a bug in Next.js.`), new R.StaticGenBailoutError();
+      } else if (_.hasAllowedDynamic === !1 && _.hasDynamicMetadata)
+        throw console.error(`Route "${f.route}" has a \`generateMetadata\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) when the rest of the route does not. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`), new R.StaticGenBailoutError();
+    }
+    function ne(f, i, _) {
+      if (_.hasSuspenseAboveBody)
+        return [];
+      if (i !== 0) {
+        const x = _.dynamicErrors;
+        if (x.length > 0)
+          return x;
+        if (i === 1)
+          return [
+            Object.defineProperty(new T.InvariantError(`Route "${f.route}" did not produce a static shell and Next.js was unable to determine a reason.`), "__NEXT_ERROR_CODE", {
+              value: "E936",
+              enumerable: !1,
+              configurable: !0
+            })
+          ];
+      } else if (_.hasAllowedDynamic === !1 && _.dynamicErrors.length === 0 && _.dynamicMetadata)
+        return [
+          _.dynamicMetadata
+        ];
+      return [];
+    }
+    function Oe(f, i) {
+      return f.runtimeStagePromise ? f.runtimeStagePromise.then(() => i) : i;
+    }
+  })(Ge)), Ge;
+}
+var Ze = {}, Lt;
+function ft() {
+  return Lt || (Lt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "createDedupedByCallsiteServerErrorLoggerDev", {
+      enumerable: !0,
+      get: function() {
+        return d;
+      }
+    });
+    const a = /* @__PURE__ */ b(Zt());
+    function E(s) {
+      if (typeof WeakMap != "function") return null;
+      var v = /* @__PURE__ */ new WeakMap(), T = /* @__PURE__ */ new WeakMap();
+      return (E = function(j) {
+        return j ? T : v;
+      })(s);
+    }
+    function b(s, v) {
+      if (s && s.__esModule)
+        return s;
+      if (s === null || typeof s != "object" && typeof s != "function")
+        return {
+          default: s
+        };
+      var T = E(v);
+      if (T && T.has(s))
+        return T.get(s);
+      var j = {
+        __proto__: null
+      }, G = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var L in s)
+        if (L !== "default" && Object.prototype.hasOwnProperty.call(s, L)) {
+          var S = G ? Object.getOwnPropertyDescriptor(s, L) : null;
+          S && (S.get || S.set) ? Object.defineProperty(j, L, S) : j[L] = s[L];
+        }
+      return j.default = s, T && T.set(s, j), j;
+    }
+    const R = {
+      current: null
+    }, w = typeof a.cache == "function" ? a.cache : (s) => s, c = process.env.__NEXT_CACHE_COMPONENTS ? console.error : console.warn, p = w(
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- cache key
+      (s) => {
+        try {
+          c(R.current);
+        } finally {
+          R.current = null;
+        }
+      }
+    );
+    function d(s) {
+      return function(...T) {
+        const j = s(...T);
+        if (process.env.NODE_ENV !== "production") {
+          var G;
+          const L = (G = new Error().stack) == null ? void 0 : G.split(`
+`);
+          if (L === void 0 || L.length < 4)
+            c(j);
+          else {
+            const S = L[4];
+            R.current = j, p(S);
+          }
+        } else
+          c(j);
+      };
+    }
+  })(Ze)), Ze;
+}
+var Ve = {}, Je = {}, et = {}, Ut;
+function gr() {
+  return Ut || (Ut = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "afterTaskAsyncStorageInstance", {
+      enumerable: !0,
+      get: function() {
+        return E;
+      }
+    });
+    const E = (0, it().createAsyncLocalStorage)();
+  })(et)), et;
+}
+var Wt;
+function _r() {
+  return Wt || (Wt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "afterTaskAsyncStorage", {
+      enumerable: !0,
+      get: function() {
+        return a.afterTaskAsyncStorageInstance;
+      }
+    });
+    const a = gr();
+  })(Je)), Je;
+}
+var Xt;
+function Jt() {
+  return Xt || (Xt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(p, d) {
+      for (var s in d) Object.defineProperty(p, s, {
+        enumerable: !0,
+        get: d[s]
+      });
+    }
+    a(h, {
+      isRequestAPICallableInsideAfter: function() {
+        return c;
+      },
+      throwForSearchParamsAccessInUseCache: function() {
+        return w;
+      },
+      throwWithStaticGenerationBailoutErrorWithDynamicError: function() {
+        return R;
+      }
+    });
+    const E = Re(), b = _r();
+    function R(p, d) {
+      throw Object.defineProperty(new E.StaticGenBailoutError(`Route ${p} with \`dynamic = "error"\` couldn't be rendered statically because it used ${d}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+        value: "E543",
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+    function w(p, d) {
+      const s = Object.defineProperty(new Error(`Route ${p.route} used \`searchParams\` inside "use cache". Accessing dynamic request data inside a cache scope is not supported. If you need some search params inside a cached function await \`searchParams\` outside of the cached function and pass only the required search params as arguments to the cached function. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+        value: "E842",
+        enumerable: !1,
+        configurable: !0
+      });
+      throw Error.captureStackTrace(s, d), p.invalidDynamicUsageError ?? (p.invalidDynamicUsageError = s), s;
+    }
+    function c() {
+      const p = b.afterTaskAsyncStorage.getStore();
+      return (p == null ? void 0 : p.rootTaskSpawnPhase) === "action";
+    }
+  })(Ve)), Ve;
+}
+var tt = {}, rt = {}, Bt;
+function Er() {
+  return Bt || (Bt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "createPromiseWithResolvers", {
+      enumerable: !0,
+      get: function() {
+        return a;
+      }
+    });
+    function a() {
+      let E, b;
+      const R = new Promise((w, c) => {
+        E = w, b = c;
+      });
+      return {
+        resolve: E,
+        reject: b,
+        promise: R
+      };
+    }
+  })(rt)), rt;
+}
+var $t;
+function er() {
+  return $t || ($t = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(d, s) {
+      for (var v in s) Object.defineProperty(d, v, {
+        enumerable: !0,
+        get: s[v]
+      });
+    }
+    a(h, {
+      RenderStage: function() {
+        return R;
+      },
+      StagedRenderingController: function() {
+        return w;
+      }
+    });
+    const E = he(), b = Er();
+    var R = /* @__PURE__ */ (function(d) {
+      return d[d.Before = 1] = "Before", d[d.Static = 2] = "Static", d[d.Runtime = 3] = "Runtime", d[d.Dynamic = 4] = "Dynamic", d[d.Abandoned = 5] = "Abandoned", d;
+    })({});
+    class w {
+      constructor(s = null, v) {
+        this.abortSignal = s, this.hasRuntimePrefetch = v, this.currentStage = 1, this.staticInterruptReason = null, this.runtimeInterruptReason = null, this.staticStageEndTime = 1 / 0, this.runtimeStageEndTime = 1 / 0, this.runtimeStageListeners = [], this.dynamicStageListeners = [], this.runtimeStagePromise = (0, b.createPromiseWithResolvers)(), this.dynamicStagePromise = (0, b.createPromiseWithResolvers)(), this.mayAbandon = !1, s && (s.addEventListener("abort", () => {
+          const { reason: T } = s;
+          this.currentStage < 3 && (this.runtimeStagePromise.promise.catch(c), this.runtimeStagePromise.reject(T)), (this.currentStage < 4 || this.currentStage === 5) && (this.dynamicStagePromise.promise.catch(c), this.dynamicStagePromise.reject(T));
+        }, {
+          once: !0
+        }), this.mayAbandon = !0);
+      }
+      onStage(s, v) {
+        if (this.currentStage >= s)
+          v();
+        else if (s === 3)
+          this.runtimeStageListeners.push(v);
+        else if (s === 4)
+          this.dynamicStageListeners.push(v);
+        else
+          throw Object.defineProperty(new E.InvariantError(`Invalid render stage: ${s}`), "__NEXT_ERROR_CODE", {
+            value: "E881",
+            enumerable: !1,
+            configurable: !0
+          });
+      }
+      canSyncInterrupt() {
+        if (this.currentStage === 1)
+          return !1;
+        const s = this.hasRuntimePrefetch ? 4 : 3;
+        return this.currentStage < s;
+      }
+      syncInterruptCurrentStageWithReason(s) {
+        if (this.currentStage !== 1) {
+          if (this.mayAbandon)
+            return this.abandonRenderImpl();
+          switch (this.currentStage) {
+            case 2: {
+              this.staticInterruptReason = s, this.advanceStage(4);
+              return;
+            }
+            case 3: {
+              this.hasRuntimePrefetch && (this.runtimeInterruptReason = s, this.advanceStage(4));
+              return;
+            }
+          }
+        }
+      }
+      getStaticInterruptReason() {
+        return this.staticInterruptReason;
+      }
+      getRuntimeInterruptReason() {
+        return this.runtimeInterruptReason;
+      }
+      getStaticStageEndTime() {
+        return this.staticStageEndTime;
+      }
+      getRuntimeStageEndTime() {
+        return this.runtimeStageEndTime;
+      }
+      abandonRender() {
+        if (!this.mayAbandon)
+          throw Object.defineProperty(new E.InvariantError("`abandonRender` called on a stage controller that cannot be abandoned."), "__NEXT_ERROR_CODE", {
+            value: "E938",
+            enumerable: !1,
+            configurable: !0
+          });
+        this.abandonRenderImpl();
+      }
+      abandonRenderImpl() {
+        const { currentStage: s } = this;
+        switch (s) {
+          case 2: {
+            this.currentStage = 5, this.resolveRuntimeStage();
+            return;
+          }
+          case 3: {
+            this.currentStage = 5;
+            return;
+          }
+        }
+      }
+      advanceStage(s) {
+        if (s <= this.currentStage)
+          return;
+        let v = this.currentStage;
+        if (this.currentStage = s, v < 3 && s >= 3 && (this.staticStageEndTime = performance.now() + performance.timeOrigin, this.resolveRuntimeStage()), v < 4 && s >= 4) {
+          this.runtimeStageEndTime = performance.now() + performance.timeOrigin, this.resolveDynamicStage();
+          return;
+        }
+      }
+      /** Fire the `onStage` listeners for the runtime stage and unblock any promises waiting for it. */
+      resolveRuntimeStage() {
+        const s = this.runtimeStageListeners;
+        for (let v = 0; v < s.length; v++)
+          s[v]();
+        s.length = 0, this.runtimeStagePromise.resolve();
+      }
+      /** Fire the `onStage` listeners for the dynamic stage and unblock any promises waiting for it. */
+      resolveDynamicStage() {
+        const s = this.dynamicStageListeners;
+        for (let v = 0; v < s.length; v++)
+          s[v]();
+        s.length = 0, this.dynamicStagePromise.resolve();
+      }
+      getStagePromise(s) {
+        switch (s) {
+          case 3:
+            return this.runtimeStagePromise.promise;
+          case 4:
+            return this.dynamicStagePromise.promise;
+          default:
+            throw Object.defineProperty(new E.InvariantError(`Invalid render stage: ${s}`), "__NEXT_ERROR_CODE", {
+              value: "E881",
+              enumerable: !1,
+              configurable: !0
+            });
+        }
+      }
+      waitForStage(s) {
+        return this.getStagePromise(s);
+      }
+      delayUntilStage(s, v, T) {
+        const j = this.getStagePromise(s), G = p(j, v, T);
+        return this.abortSignal && G.catch(c), G;
+      }
+    }
+    function c() {
+    }
+    function p(d, s, v) {
+      const T = new Promise((j, G) => {
+        d.then(j.bind(null, v), G);
+      });
+      return s !== void 0 && (T.displayName = s), T;
+    }
+  })(tt)), tt;
+}
+var Yt;
+function Rr() {
+  return Yt || (Yt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "cookies", {
+      enumerable: !0,
+      get: function() {
+        return j;
+      }
+    });
+    const a = cr(), E = Kt(), b = Ee(), R = je(), w = ct(), c = Re(), p = ut(), d = ft(), s = Jt(), v = he(), T = er();
+    function j() {
+      const o = "cookies", u = b.workAsyncStorage.getStore(), g = R.workUnitAsyncStorage.getStore();
+      if (u) {
+        if (g && g.phase === "after" && !(0, s.isRequestAPICallableInsideAfter)())
+          throw Object.defineProperty(new Error(
+            // TODO(after): clarify that this only applies to pages?
+            `Route ${u.route} used \`cookies()\` inside \`after()\`. This is not supported. If you need this data inside an \`after()\` callback, use \`cookies()\` outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`
+          ), "__NEXT_ERROR_CODE", {
+            value: "E843",
+            enumerable: !1,
+            configurable: !0
+          });
+        if (u.forceStatic) {
+          const M = G();
+          return C(M);
+        }
+        if (u.dynamicShouldError)
+          throw Object.defineProperty(new c.StaticGenBailoutError(`Route ${u.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`cookies()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+            value: "E849",
+            enumerable: !1,
+            configurable: !0
+          });
+        if (g)
+          switch (g.type) {
+            case "cache":
+              const M = Object.defineProperty(new Error(`Route ${u.route} used \`cookies()\` inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`cookies()\` outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+                value: "E831",
+                enumerable: !1,
+                configurable: !0
+              });
+              throw Error.captureStackTrace(M, j), u.invalidDynamicUsageError ?? (u.invalidDynamicUsageError = M), M;
+            case "unstable-cache":
+              throw Object.defineProperty(new Error(`Route ${u.route} used \`cookies()\` inside a function cached with \`unstable_cache()\`. Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`cookies()\` outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+                value: "E846",
+                enumerable: !1,
+                configurable: !0
+              });
+            case "prerender":
+              return S(u, g);
+            case "prerender-client":
+              const F = "`cookies`";
+              throw Object.defineProperty(new v.InvariantError(`${F} must not be used within a Client Component. Next.js should be preventing ${F} from being included in Client Components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                value: "E832",
+                enumerable: !1,
+                configurable: !0
+              });
+            case "prerender-ppr":
+              return (0, w.postponeWithTracking)(u.route, o, g.dynamicTracking);
+            case "prerender-legacy":
+              return (0, w.throwToInterruptStaticGeneration)(o, u, g);
+            case "prerender-runtime":
+              return (0, w.delayUntilRuntimeStage)(g, C(g.cookies));
+            case "private-cache":
+              return C(g.cookies);
+            case "request":
+              (0, w.trackDynamicDataInDynamicRender)(g);
+              let H;
+              return (0, a.areCookiesMutableInCurrentPhase)(g) ? H = g.userspaceMutableCookies : H = g.cookies, process.env.NODE_ENV === "development" ? P(g, H, u == null ? void 0 : u.route) : C(H);
+          }
+      }
+      (0, R.throwForMissingRequestStore)(o);
+    }
+    function G() {
+      return a.RequestCookiesAdapter.seal(new E.RequestCookies(new Headers({})));
+    }
+    const L = /* @__PURE__ */ new WeakMap();
+    function S(o, u) {
+      const g = L.get(u);
+      if (g)
+        return g;
+      const M = (0, p.makeHangingPromise)(u.renderSignal, o.route, "`cookies()`");
+      return L.set(u, M), M;
+    }
+    function C(o) {
+      const u = L.get(o);
+      if (u)
+        return u;
+      const g = Promise.resolve(o);
+      return L.set(o, g), g;
+    }
+    function P(o, u, g) {
+      if (o.asyncApiPromises) {
+        let J;
+        if (u === o.mutableCookies)
+          J = o.asyncApiPromises.mutableCookies;
+        else if (u === o.cookies)
+          J = o.asyncApiPromises.cookies;
+        else
+          throw Object.defineProperty(new v.InvariantError("Received an underlying cookies object that does not match either `cookies` or `mutableCookies`"), "__NEXT_ERROR_CODE", {
+            value: "E890",
+            enumerable: !1,
+            configurable: !0
+          });
+        return N(J, g);
+      }
+      const M = L.get(u);
+      if (M)
+        return M;
+      const F = (0, p.makeDevtoolsIOAwarePromise)(u, o, T.RenderStage.Runtime), H = N(F, g);
+      return L.set(u, H), H;
+    }
+    const A = (0, d.createDedupedByCallsiteServerErrorLoggerDev)(l);
+    function N(o, u) {
+      return Object.defineProperties(o, {
+        [Symbol.iterator]: t(o, u),
+        size: D(o, "size", u),
+        get: D(o, "get", u),
+        getAll: D(o, "getAll", u),
+        has: D(o, "has", u),
+        set: D(o, "set", u),
+        delete: D(o, "delete", u),
+        clear: D(o, "clear", u),
+        toString: D(o, "toString", u)
+      }), o;
+    }
+    function D(o, u, g) {
+      return {
+        enumerable: !1,
+        get() {
+          A(g, `\`cookies().${u}\``);
+        },
+        set(M) {
+          Object.defineProperty(o, u, {
+            value: M,
+            writable: !0,
+            configurable: !0
+          });
+        },
+        configurable: !0
+      };
+    }
+    function t(o, u) {
+      return {
+        enumerable: !1,
+        get() {
+          A(u, "`...cookies()` or similar iteration");
+        },
+        set(g) {
+          Object.defineProperty(o, Symbol.iterator, {
+            value: g,
+            writable: !0,
+            enumerable: !0,
+            configurable: !0
+          });
+        },
+        configurable: !0
+      };
+    }
+    function l(o, u) {
+      const g = o ? `Route "${o}" ` : "This route ";
+      return Object.defineProperty(new Error(`${g}used ${u}. \`cookies()\` returns a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E830",
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+  })(Ie)), Ie;
+}
+var nt = {}, ot = {}, Gt;
+function br() {
+  return Gt || (Gt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    });
+    function a(w, c) {
+      for (var p in c) Object.defineProperty(w, p, {
+        enumerable: !0,
+        get: c[p]
+      });
+    }
+    a(h, {
+      HeadersAdapter: function() {
+        return R;
+      },
+      ReadonlyHeadersError: function() {
+        return b;
+      }
+    });
+    const E = st();
+    class b extends Error {
+      constructor() {
+        super("Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers");
+      }
+      static callable() {
+        throw new b();
+      }
+    }
+    class R extends Headers {
+      constructor(c) {
+        super(), this.headers = new Proxy(c, {
+          get(p, d, s) {
+            if (typeof d == "symbol")
+              return E.ReflectAdapter.get(p, d, s);
+            const v = d.toLowerCase(), T = Object.keys(c).find((j) => j.toLowerCase() === v);
+            if (!(typeof T > "u"))
+              return E.ReflectAdapter.get(p, T, s);
+          },
+          set(p, d, s, v) {
+            if (typeof d == "symbol")
+              return E.ReflectAdapter.set(p, d, s, v);
+            const T = d.toLowerCase(), j = Object.keys(c).find((G) => G.toLowerCase() === T);
+            return E.ReflectAdapter.set(p, j ?? d, s, v);
+          },
+          has(p, d) {
+            if (typeof d == "symbol") return E.ReflectAdapter.has(p, d);
+            const s = d.toLowerCase(), v = Object.keys(c).find((T) => T.toLowerCase() === s);
+            return typeof v > "u" ? !1 : E.ReflectAdapter.has(p, v);
+          },
+          deleteProperty(p, d) {
+            if (typeof d == "symbol") return E.ReflectAdapter.deleteProperty(p, d);
+            const s = d.toLowerCase(), v = Object.keys(c).find((T) => T.toLowerCase() === s);
+            return typeof v > "u" ? !0 : E.ReflectAdapter.deleteProperty(p, v);
+          }
+        });
+      }
+      /**
+      * Seals a Headers instance to prevent modification by throwing an error when
+      * any mutating method is called.
+      */
+      static seal(c) {
+        return new Proxy(c, {
+          get(p, d, s) {
+            switch (d) {
+              case "append":
+              case "delete":
+              case "set":
+                return b.callable;
+              default:
+                return E.ReflectAdapter.get(p, d, s);
+            }
+          }
+        });
+      }
+      /**
+      * Merges a header value into a string. This stores multiple values as an
+      * array, so we need to merge them into a string.
+      *
+      * @param value a header value
+      * @returns a merged header value (a string)
+      */
+      merge(c) {
+        return Array.isArray(c) ? c.join(", ") : c;
+      }
+      /**
+      * Creates a Headers instance from a plain object or a Headers instance.
+      *
+      * @param headers a plain object or a Headers instance
+      * @returns a headers instance
+      */
+      static from(c) {
+        return c instanceof Headers ? c : new R(c);
+      }
+      append(c, p) {
+        const d = this.headers[c];
+        typeof d == "string" ? this.headers[c] = [
+          d,
+          p
+        ] : Array.isArray(d) ? d.push(p) : this.headers[c] = p;
+      }
+      delete(c) {
+        delete this.headers[c];
+      }
+      get(c) {
+        const p = this.headers[c];
+        return typeof p < "u" ? this.merge(p) : null;
+      }
+      has(c) {
+        return typeof this.headers[c] < "u";
+      }
+      set(c, p) {
+        this.headers[c] = p;
+      }
+      forEach(c, p) {
+        for (const [d, s] of this.entries())
+          c.call(p, s, d, this);
+      }
+      *entries() {
+        for (const c of Object.keys(this.headers)) {
+          const p = c.toLowerCase(), d = this.get(p);
+          yield [
+            p,
+            d
+          ];
+        }
+      }
+      *keys() {
+        for (const c of Object.keys(this.headers))
+          yield c.toLowerCase();
+      }
+      *values() {
+        for (const c of Object.keys(this.headers))
+          yield this.get(c);
+      }
+      [Symbol.iterator]() {
+        return this.entries();
+      }
+    }
+  })(ot)), ot;
+}
+var Ft;
+function vr() {
+  return Ft || (Ft = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "headers", {
+      enumerable: !0,
+      get: function() {
+        return T;
+      }
+    });
+    const a = br(), E = Ee(), b = je(), R = ct(), w = Re(), c = ut(), p = ft(), d = Jt(), s = he(), v = er();
+    function T() {
+      const t = "headers", l = E.workAsyncStorage.getStore(), o = b.workUnitAsyncStorage.getStore();
+      if (l) {
+        if (o && o.phase === "after" && !(0, d.isRequestAPICallableInsideAfter)())
+          throw Object.defineProperty(new Error(`Route ${l.route} used \`headers()\` inside \`after()\`. This is not supported. If you need this data inside an \`after()\` callback, use \`headers()\` outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
+            value: "E839",
+            enumerable: !1,
+            configurable: !0
+          });
+        if (l.forceStatic) {
+          const u = a.HeadersAdapter.seal(new Headers({}));
+          return L(u);
+        }
+        if (o)
+          switch (o.type) {
+            case "cache": {
+              const u = Object.defineProperty(new Error(`Route ${l.route} used \`headers()\` inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`headers()\` outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+                value: "E833",
+                enumerable: !1,
+                configurable: !0
+              });
+              throw Error.captureStackTrace(u, T), l.invalidDynamicUsageError ?? (l.invalidDynamicUsageError = u), u;
+            }
+            case "unstable-cache":
+              throw Object.defineProperty(new Error(`Route ${l.route} used \`headers()\` inside a function cached with \`unstable_cache()\`. Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`headers()\` outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+                value: "E838",
+                enumerable: !1,
+                configurable: !0
+              });
+          }
+        if (l.dynamicShouldError)
+          throw Object.defineProperty(new w.StaticGenBailoutError(`Route ${l.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`headers()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+            value: "E828",
+            enumerable: !1,
+            configurable: !0
+          });
+        if (o)
+          switch (o.type) {
+            case "prerender":
+              return G(l, o);
+            case "prerender-client":
+              const u = "`headers`";
+              throw Object.defineProperty(new s.InvariantError(`${u} must not be used within a client component. Next.js should be preventing ${u} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                value: "E693",
+                enumerable: !1,
+                configurable: !0
+              });
+            case "prerender-ppr":
+              return (0, R.postponeWithTracking)(l.route, t, o.dynamicTracking);
+            case "prerender-legacy":
+              return (0, R.throwToInterruptStaticGeneration)(t, l, o);
+            case "prerender-runtime":
+              return (0, R.delayUntilRuntimeStage)(o, L(o.headers));
+            case "private-cache":
+              return L(o.headers);
+            case "request":
+              return (0, R.trackDynamicDataInDynamicRender)(o), process.env.NODE_ENV === "development" ? S(o.headers, l == null ? void 0 : l.route, o) : L(o.headers);
+          }
+      }
+      (0, b.throwForMissingRequestStore)(t);
+    }
+    const j = /* @__PURE__ */ new WeakMap();
+    function G(t, l) {
+      const o = j.get(l);
+      if (o)
+        return o;
+      const u = (0, c.makeHangingPromise)(l.renderSignal, t.route, "`headers()`");
+      return j.set(l, u), u;
+    }
+    function L(t) {
+      const l = j.get(t);
+      if (l)
+        return l;
+      const o = Promise.resolve(t);
+      return j.set(t, o), o;
+    }
+    function S(t, l, o) {
+      if (o.asyncApiPromises) {
+        const F = o.asyncApiPromises.headers;
+        return P(F, l);
+      }
+      const u = j.get(t);
+      if (u)
+        return u;
+      const g = (0, c.makeDevtoolsIOAwarePromise)(t, o, v.RenderStage.Runtime), M = P(g, l);
+      return j.set(t, M), M;
+    }
+    const C = (0, p.createDedupedByCallsiteServerErrorLoggerDev)(D);
+    function P(t, l) {
+      return Object.defineProperties(t, {
+        [Symbol.iterator]: N(t, l),
+        append: A(t, "append", l),
+        delete: A(t, "delete", l),
+        get: A(t, "get", l),
+        has: A(t, "has", l),
+        set: A(t, "set", l),
+        getSetCookie: A(t, "getSetCookie", l),
+        forEach: A(t, "forEach", l),
+        keys: A(t, "keys", l),
+        values: A(t, "values", l),
+        entries: A(t, "entries", l)
+      }), t;
+    }
+    function A(t, l, o) {
+      return {
+        enumerable: !1,
+        get() {
+          C(o, `\`headers().${l}\``);
+        },
+        set(u) {
+          Object.defineProperty(t, l, {
+            value: u,
+            writable: !0,
+            configurable: !0
+          });
+        },
+        configurable: !0
+      };
+    }
+    function N(t, l) {
+      return {
+        enumerable: !1,
+        get() {
+          C(l, "`...headers()` or similar iteration");
+        },
+        set(o) {
+          Object.defineProperty(t, Symbol.iterator, {
+            value: o,
+            writable: !0,
+            enumerable: !0,
+            configurable: !0
+          });
+        },
+        configurable: !0
+      };
+    }
+    function D(t, l) {
+      const o = t ? `Route "${t}" ` : "This route ";
+      return Object.defineProperty(new Error(`${o}used ${l}. \`headers()\` returns a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E836",
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+  })(nt)), nt;
+}
+var at = {}, zt;
+function wr() {
+  return zt || (zt = 1, (function(h) {
+    Object.defineProperty(h, "__esModule", {
+      value: !0
+    }), Object.defineProperty(h, "draftMode", {
+      enumerable: !0,
+      get: function() {
+        return s;
+      }
+    });
+    const a = je(), E = Ee(), b = ct(), R = ft(), w = Re(), c = Vt(), p = he(), d = st();
+    function s() {
+      const A = "draftMode", N = E.workAsyncStorage.getStore(), D = a.workUnitAsyncStorage.getStore();
+      switch ((!N || !D) && (0, a.throwForMissingRequestStore)(A), D.type) {
+        case "prerender-runtime":
+          return (0, b.delayUntilRuntimeStage)(D, v(D.draftMode, N));
+        case "request":
+          return v(D.draftMode, N);
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+          const t = (0, a.getDraftModeProviderForCacheScope)(N, D);
+          if (t)
+            return v(t, N);
+        // Otherwise, we fall through to providing an empty draft mode.
+        // eslint-disable-next-line no-fallthrough
+        case "prerender":
+        case "prerender-client":
+        case "prerender-ppr":
+        case "prerender-legacy":
+          return v(null, N);
+        default:
+          return D;
+      }
+    }
+    function v(A, N) {
+      const D = A ?? T, t = j.get(D);
+      if (t)
+        return t;
+      if (process.env.NODE_ENV === "development" && !(N != null && N.isPrefetchRequest)) {
+        const l = N == null ? void 0 : N.route;
+        return G(A, l);
+      } else
+        return Promise.resolve(new L(A));
+    }
+    const T = {}, j = /* @__PURE__ */ new WeakMap();
+    function G(A, N) {
+      const D = new L(A), t = Promise.resolve(D);
+      return new Proxy(t, {
+        get(o, u, g) {
+          switch (u) {
+            case "isEnabled":
+              S(N, `\`draftMode().${u}\``);
+              break;
+            case "enable":
+            case "disable": {
+              S(N, `\`draftMode().${u}()\``);
+              break;
+            }
+          }
+          return d.ReflectAdapter.get(o, u, g);
+        }
+      });
+    }
+    class L {
+      constructor(N) {
+        this._provider = N;
+      }
+      get isEnabled() {
+        return this._provider !== null ? this._provider.isEnabled : !1;
+      }
+      enable() {
+        P("draftMode().enable()", this.enable), this._provider !== null && this._provider.enable();
+      }
+      disable() {
+        P("draftMode().disable()", this.disable), this._provider !== null && this._provider.disable();
+      }
+    }
+    const S = (0, R.createDedupedByCallsiteServerErrorLoggerDev)(C);
+    function C(A, N) {
+      const D = A ? `Route "${A}" ` : "This route ";
+      return Object.defineProperty(new Error(`${D}used ${N}. \`draftMode()\` returns a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E835",
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+    function P(A, N) {
+      const D = E.workAsyncStorage.getStore(), t = a.workUnitAsyncStorage.getStore();
+      if (D) {
+        if ((t == null ? void 0 : t.phase) === "after")
+          throw Object.defineProperty(new Error(`Route ${D.route} used "${A}" inside \`after()\`. The enabled status of \`draftMode()\` can be read inside \`after()\` but you cannot enable or disable \`draftMode()\`. See more info here: https://nextjs.org/docs/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
+            value: "E845",
+            enumerable: !1,
+            configurable: !0
+          });
+        if (D.dynamicShouldError)
+          throw Object.defineProperty(new w.StaticGenBailoutError(`Route ${D.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${A}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+            value: "E553",
+            enumerable: !1,
+            configurable: !0
+          });
+        if (t)
+          switch (t.type) {
+            case "cache":
+            case "private-cache": {
+              const u = Object.defineProperty(new Error(`Route ${D.route} used "${A}" inside "use cache". The enabled status of \`draftMode()\` can be read in caches but you must not enable or disable \`draftMode()\` inside a cache. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+                value: "E829",
+                enumerable: !1,
+                configurable: !0
+              });
+              throw Error.captureStackTrace(u, N), D.invalidDynamicUsageError ?? (D.invalidDynamicUsageError = u), u;
+            }
+            case "unstable-cache":
+              throw Object.defineProperty(new Error(`Route ${D.route} used "${A}" inside a function cached with \`unstable_cache()\`. The enabled status of \`draftMode()\` can be read in caches but you must not enable or disable \`draftMode()\` inside a cache. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+                value: "E844",
+                enumerable: !1,
+                configurable: !0
+              });
+            case "prerender":
+            case "prerender-runtime": {
+              const u = Object.defineProperty(new Error(`Route ${D.route} used ${A} without first calling \`await connection()\`. See more info here: https://nextjs.org/docs/messages/next-prerender-sync-headers`), "__NEXT_ERROR_CODE", {
+                value: "E126",
+                enumerable: !1,
+                configurable: !0
+              });
+              return (0, b.abortAndThrowOnSynchronousRequestDataAccess)(D.route, A, u, t);
+            }
+            case "prerender-client":
+              const l = "`draftMode`";
+              throw Object.defineProperty(new p.InvariantError(`${l} must not be used within a Client Component. Next.js should be preventing ${l} from being included in Client Components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                value: "E832",
+                enumerable: !1,
+                configurable: !0
+              });
+            case "prerender-ppr":
+              return (0, b.postponeWithTracking)(D.route, A, t.dynamicTracking);
+            case "prerender-legacy":
+              t.revalidate = 0;
+              const o = Object.defineProperty(new c.DynamicServerError(`Route ${D.route} couldn't be rendered statically because it used \`${A}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+                value: "E558",
+                enumerable: !1,
+                configurable: !0
+              });
+              throw D.dynamicUsageDescription = A, D.dynamicUsageStack = o.stack, o;
+            case "request":
+              (0, b.trackDynamicDataInDynamicRender)(t);
+              break;
+          }
+      }
+    }
+  })(at)), at;
+}
+var Qt;
+function Or() {
+  return Qt || (Qt = 1, ge.cookies = Rr().cookies, ge.headers = vr().headers, ge.draftMode = wr().draftMode), ge;
+}
+var Ar = Or();
+const Tr = /* @__PURE__ */ ar({
+  __proto__: null
+}, [Ar]);
+export {
+  Tr as h
+};