@ichaingo/header 1.3.87 → 1.3.89

package/dist/index-CeUO6r-I.js

@@ -0,0 +1,2095 @@
+import { jsxs as Q, jsx as Se } from "react/jsx-runtime";
+import { twMerge as lt } from "tailwind-merge";
+import dt from "@ichaingo/request";
+import Ke from "react";
+import Re from "next/dynamic";
+var L = {}, H = {}, ee = {}, te = {}, re, Ee;
+function ft() {
+  if (Ee) return re;
+  Ee = 1;
+  var f = Object.defineProperty, y = Object.getOwnPropertyDescriptor, g = Object.getOwnPropertyNames, _ = Object.prototype.hasOwnProperty, d = (e, s) => {
+    for (var a in s)
+      f(e, a, { get: s[a], enumerable: !0 });
+  }, k = (e, s, a, t) => {
+    if (s && typeof s == "object" || typeof s == "function")
+      for (let r of g(s))
+        !_.call(e, r) && r !== a && f(e, r, { get: () => s[r], enumerable: !(t = y(s, r)) || t.enumerable });
+    return e;
+  }, o = (e) => k(f({}, "__esModule", { value: !0 }), e), i = {};
+  d(i, {
+    RequestCookies: () => v,
+    ResponseCookies: () => m,
+    parseCookie: () => b,
+    parseSetCookie: () => x,
+    stringifyCookie: () => p
+  }), re = o(i);
+  function p(e) {
+    var s;
+    const a = [
+      "path" in e && e.path && `Path=${e.path}`,
+      "expires" in e && (e.expires || e.expires === 0) && `Expires=${(typeof e.expires == "number" ? new Date(e.expires) : e.expires).toUTCString()}`,
+      "maxAge" in e && typeof e.maxAge == "number" && `Max-Age=${e.maxAge}`,
+      "domain" in e && e.domain && `Domain=${e.domain}`,
+      "secure" in e && e.secure && "Secure",
+      "httpOnly" in e && e.httpOnly && "HttpOnly",
+      "sameSite" in e && e.sameSite && `SameSite=${e.sameSite}`,
+      "partitioned" in e && e.partitioned && "Partitioned",
+      "priority" in e && e.priority && `Priority=${e.priority}`
+    ].filter(Boolean), t = `${e.name}=${encodeURIComponent((s = e.value) != null ? s : "")}`;
+    return a.length === 0 ? t : `${t}; ${a.join("; ")}`;
+  }
+  function b(e) {
+    const s = /* @__PURE__ */ new Map();
+    for (const a of e.split(/; */)) {
+      if (!a)
+        continue;
+      const t = a.indexOf("=");
+      if (t === -1) {
+        s.set(a, "true");
+        continue;
+      }
+      const [r, l] = [a.slice(0, t), a.slice(t + 1)];
+      try {
+        s.set(r, decodeURIComponent(l ?? "true"));
+      } catch {
+      }
+    }
+    return s;
+  }
+  function x(e) {
+    if (!e)
+      return;
+    const [[s, a], ...t] = b(e), {
+      domain: r,
+      expires: l,
+      httponly: O,
+      maxage: R,
+      path: w,
+      samesite: C,
+      secure: M,
+      partitioned: F,
+      priority: G
+    } = Object.fromEntries(
+      t.map(([X, J]) => [
+        X.toLowerCase().replace(/-/g, ""),
+        J
+      ])
+    ), Y = {
+      name: s,
+      value: decodeURIComponent(a),
+      domain: r,
+      ...l && { expires: new Date(l) },
+      ...O && { httpOnly: !0 },
+      ...typeof R == "string" && { maxAge: Number(R) },
+      path: w,
+      ...C && { sameSite: P(C) },
+      ...M && { secure: !0 },
+      ...G && { priority: q(G) },
+      ...F && { partitioned: !0 }
+    };
+    return S(Y);
+  }
+  function S(e) {
+    const s = {};
+    for (const a in e)
+      e[a] && (s[a] = e[a]);
+    return s;
+  }
+  var E = ["strict", "lax", "none"];
+  function P(e) {
+    return e = e.toLowerCase(), E.includes(e) ? e : void 0;
+  }
+  var I = ["low", "medium", "high"];
+  function q(e) {
+    return e = e.toLowerCase(), I.includes(e) ? e : void 0;
+  }
+  function D(e) {
+    if (!e)
+      return [];
+    var s = [], a = 0, t, r, l, O, R;
+    function w() {
+      for (; a < e.length && /\s/.test(e.charAt(a)); )
+        a += 1;
+      return a < e.length;
+    }
+    function C() {
+      return r = e.charAt(a), r !== "=" && r !== ";" && r !== ",";
+    }
+    for (; a < e.length; ) {
+      for (t = a, R = !1; w(); )
+        if (r = e.charAt(a), r === ",") {
+          for (l = a, a += 1, w(), O = a; a < e.length && C(); )
+            a += 1;
+          a < e.length && e.charAt(a) === "=" ? (R = !0, a = O, s.push(e.substring(t, l)), t = a) : a = l + 1;
+        } else
+          a += 1;
+      (!R || a >= e.length) && s.push(e.substring(t, e.length));
+    }
+    return s;
+  }
+  var v = class {
+    constructor(e) {
+      this._parsed = /* @__PURE__ */ new Map(), this._headers = e;
+      const s = e.get("cookie");
+      if (s) {
+        const a = b(s);
+        for (const [t, r] of a)
+          this._parsed.set(t, { name: t, value: r });
+      }
+    }
+    [Symbol.iterator]() {
+      return this._parsed[Symbol.iterator]();
+    }
+    /**
+     * The amount of cookies received from the client
+     */
+    get size() {
+      return this._parsed.size;
+    }
+    get(...e) {
+      const s = typeof e[0] == "string" ? e[0] : e[0].name;
+      return this._parsed.get(s);
+    }
+    getAll(...e) {
+      var s;
+      const a = Array.from(this._parsed);
+      if (!e.length)
+        return a.map(([r, l]) => l);
+      const t = typeof e[0] == "string" ? e[0] : (s = e[0]) == null ? void 0 : s.name;
+      return a.filter(([r]) => r === t).map(([r, l]) => l);
+    }
+    has(e) {
+      return this._parsed.has(e);
+    }
+    set(...e) {
+      const [s, a] = e.length === 1 ? [e[0].name, e[0].value] : e, t = this._parsed;
+      return t.set(s, { name: s, value: a }), this._headers.set(
+        "cookie",
+        Array.from(t).map(([r, l]) => p(l)).join("; ")
+      ), this;
+    }
+    /**
+     * Delete the cookies matching the passed name or names in the request.
+     */
+    delete(e) {
+      const s = this._parsed, a = Array.isArray(e) ? e.map((t) => s.delete(t)) : s.delete(e);
+      return this._headers.set(
+        "cookie",
+        Array.from(s).map(([t, r]) => p(r)).join("; ")
+      ), a;
+    }
+    /**
+     * 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((e) => `${e.name}=${encodeURIComponent(e.value)}`).join("; ");
+    }
+  }, m = class {
+    constructor(e) {
+      this._parsed = /* @__PURE__ */ new Map();
+      var s, a, t;
+      this._headers = e;
+      const r = (t = (a = (s = e.getSetCookie) == null ? void 0 : s.call(e)) != null ? a : e.get("set-cookie")) != null ? t : [], l = Array.isArray(r) ? r : D(r);
+      for (const O of l) {
+        const R = x(O);
+        R && this._parsed.set(R.name, R);
+      }
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
+     */
+    get(...e) {
+      const s = typeof e[0] == "string" ? e[0] : e[0].name;
+      return this._parsed.get(s);
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
+     */
+    getAll(...e) {
+      var s;
+      const a = Array.from(this._parsed.values());
+      if (!e.length)
+        return a;
+      const t = typeof e[0] == "string" ? e[0] : (s = e[0]) == null ? void 0 : s.name;
+      return a.filter((r) => r.name === t);
+    }
+    has(e) {
+      return this._parsed.has(e);
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
+     */
+    set(...e) {
+      const [s, a, t] = e.length === 1 ? [e[0].name, e[0].value, e[0]] : e, r = this._parsed;
+      return r.set(s, n({ name: s, value: a, ...t })), h(r, this._headers), this;
+    }
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
+     */
+    delete(...e) {
+      const [s, a] = typeof e[0] == "string" ? [e[0]] : [e[0].name, e[0]];
+      return this.set({ ...a, name: s, 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(p).join("; ");
+    }
+  };
+  function h(e, s) {
+    s.delete("set-cookie");
+    for (const [, a] of e) {
+      const t = p(a);
+      s.append("set-cookie", t);
+    }
+  }
+  function n(e = { name: "", value: "" }) {
+    return typeof e.expires == "number" && (e.expires = new Date(e.expires)), e.maxAge && (e.expires = new Date(Date.now() + e.maxAge * 1e3)), (e.path === null || e.path === void 0) && (e.path = "/"), e;
+  }
+  return re;
+}
+var De;
+function Ze() {
+  return De || (De = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    });
+    function y(_, d) {
+      for (var k in d) Object.defineProperty(_, k, {
+        enumerable: !0,
+        get: d[k]
+      });
+    }
+    y(f, {
+      RequestCookies: function() {
+        return g.RequestCookies;
+      },
+      ResponseCookies: function() {
+        return g.ResponseCookies;
+      },
+      stringifyCookie: function() {
+        return g.stringifyCookie;
+      }
+    });
+    const g = ft();
+  })(te)), te;
+}
+var ne = {}, xe;
+function Qe() {
+  return xe || (xe = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "ReflectAdapter", {
+      enumerable: !0,
+      get: function() {
+        return y;
+      }
+    });
+    class y {
+      static get(_, d, k) {
+        const o = Reflect.get(_, d, k);
+        return typeof o == "function" ? o.bind(_) : o;
+      }
+      static set(_, d, k, o) {
+        return Reflect.set(_, d, k, o);
+      }
+      static has(_, d) {
+        return Reflect.has(_, d);
+      }
+      static deleteProperty(_, d) {
+        return Reflect.deleteProperty(_, d);
+      }
+    }
+  })(ne)), ne;
+}
+var oe = {}, se = {}, ae = {}, Oe;
+function we() {
+  return Oe || (Oe = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    });
+    function y(p, b) {
+      for (var x in b) Object.defineProperty(p, x, {
+        enumerable: !0,
+        get: b[x]
+      });
+    }
+    y(f, {
+      bindSnapshot: function() {
+        return o;
+      },
+      createAsyncLocalStorage: function() {
+        return k;
+      },
+      createSnapshot: function() {
+        return i;
+      }
+    });
+    const g = new Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available");
+    class _ {
+      disable() {
+        throw g;
+      }
+      getStore() {
+      }
+      run() {
+        throw g;
+      }
+      exit() {
+        throw g;
+      }
+      enterWith() {
+        throw g;
+      }
+      static bind(b) {
+        return b;
+      }
+    }
+    const d = typeof globalThis < "u" && globalThis.AsyncLocalStorage;
+    function k() {
+      return d ? new d() : new _();
+    }
+    function o(p) {
+      return d ? d.bind(p) : _.bind(p);
+    }
+    function i() {
+      return d ? d.snapshot() : function(p, ...b) {
+        return p(...b);
+      };
+    }
+  })(ae)), ae;
+}
+var Pe;
+function pt() {
+  return Pe || (Pe = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "workAsyncStorageInstance", {
+      enumerable: !0,
+      get: function() {
+        return g;
+      }
+    });
+    const g = (0, we().createAsyncLocalStorage)();
+  })(se)), se;
+}
+var qe;
+function U() {
+  return qe || (qe = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "workAsyncStorage", {
+      enumerable: !0,
+      get: function() {
+        return y.workAsyncStorageInstance;
+      }
+    });
+    const y = pt();
+  })(oe)), oe;
+}
+var ie = {}, ce = {}, Te;
+function ht() {
+  return Te || (Te = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "workUnitAsyncStorageInstance", {
+      enumerable: !0,
+      get: function() {
+        return g;
+      }
+    });
+    const g = (0, we().createAsyncLocalStorage)();
+  })(ce)), ce;
+}
+var $e;
+function W() {
+  return $e || ($e = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    });
+    function y(o, i) {
+      for (var p in i) Object.defineProperty(o, p, {
+        enumerable: !0,
+        get: i[p]
+      });
+    }
+    y(f, {
+      getExpectedRequestStore: function() {
+        return _;
+      },
+      getPrerenderResumeDataCache: function() {
+        return d;
+      },
+      getRenderResumeDataCache: function() {
+        return k;
+      },
+      workUnitAsyncStorage: function() {
+        return g.workUnitAsyncStorageInstance;
+      }
+    });
+    const g = ht();
+    function _(o) {
+      const i = g.workUnitAsyncStorageInstance.getStore();
+      if (i) {
+        if (i.type === "request")
+          return i;
+        if (i.type === "prerender" || i.type === "prerender-ppr" || i.type === "prerender-legacy")
+          throw new Error(`\`${o}\` cannot be called inside a prerender. This is a bug in Next.js.`);
+        if (i.type === "cache")
+          throw new Error(`\`${o}\` cannot be called inside "use cache". Call it outside and pass an argument instead. Read more: https://nextjs.org/docs/messages/next-request-in-use-cache`);
+        if (i.type === "unstable-cache")
+          throw new Error(`\`${o}\` cannot be called inside unstable_cache. Call it outside and pass an argument instead. Read more: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`);
+      }
+      throw new Error(`\`${o}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`);
+    }
+    function d(o) {
+      return o.type === "prerender" || o.type === "prerender-ppr" ? o.prerenderResumeDataCache : null;
+    }
+    function k(o) {
+      return o.type !== "prerender-legacy" && o.type !== "cache" && o.type !== "unstable-cache" ? o.type === "request" ? o.renderResumeDataCache : o.prerenderResumeDataCache : null;
+    }
+  })(ie)), ie;
+}
+var Ie;
+function yt() {
+  return Ie || (Ie = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    });
+    function y(D, v) {
+      for (var m in v) Object.defineProperty(D, m, {
+        enumerable: !0,
+        get: v[m]
+      });
+    }
+    y(f, {
+      MutableRequestCookiesAdapter: function() {
+        return S;
+      },
+      ReadonlyRequestCookiesError: function() {
+        return o;
+      },
+      RequestCookiesAdapter: function() {
+        return i;
+      },
+      appendMutableCookies: function() {
+        return x;
+      },
+      areCookiesMutableInCurrentPhase: function() {
+        return P;
+      },
+      getModifiedCookieValues: function() {
+        return b;
+      },
+      responseCookiesToRequestCookies: function() {
+        return q;
+      },
+      wrapWithMutableAccessCheck: function() {
+        return E;
+      }
+    });
+    const g = Ze(), _ = Qe(), d = U(), k = W();
+    class o 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 o();
+      }
+    }
+    class i {
+      static seal(v) {
+        return new Proxy(v, {
+          get(m, h, n) {
+            switch (h) {
+              case "clear":
+              case "delete":
+              case "set":
+                return o.callable;
+              default:
+                return _.ReflectAdapter.get(m, h, n);
+            }
+          }
+        });
+      }
+    }
+    const p = Symbol.for("next.mutated.cookies");
+    function b(D) {
+      const v = D[p];
+      return !v || !Array.isArray(v) || v.length === 0 ? [] : v;
+    }
+    function x(D, v) {
+      const m = b(v);
+      if (m.length === 0)
+        return !1;
+      const h = new g.ResponseCookies(D), n = h.getAll();
+      for (const e of m)
+        h.set(e);
+      for (const e of n)
+        h.set(e);
+      return !0;
+    }
+    class S {
+      static wrap(v, m) {
+        const h = new g.ResponseCookies(new Headers());
+        for (const t of v.getAll())
+          h.set(t);
+        let n = [];
+        const e = /* @__PURE__ */ new Set(), s = () => {
+          const t = d.workAsyncStorage.getStore();
+          if (t && (t.pathWasRevalidated = !0), n = h.getAll().filter((l) => e.has(l.name)), m) {
+            const l = [];
+            for (const O of n) {
+              const R = new g.ResponseCookies(new Headers());
+              R.set(O), l.push(R.toString());
+            }
+            m(l);
+          }
+        }, a = new Proxy(h, {
+          get(t, r, l) {
+            switch (r) {
+              // A special symbol to get the modified cookie values
+              case p:
+                return n;
+              // TODO: Throw error if trying to set a cookie after the response
+              // headers have been set.
+              case "delete":
+                return function(...O) {
+                  e.add(typeof O[0] == "string" ? O[0] : O[0].name);
+                  try {
+                    return t.delete(...O), a;
+                  } finally {
+                    s();
+                  }
+                };
+              case "set":
+                return function(...O) {
+                  e.add(typeof O[0] == "string" ? O[0] : O[0].name);
+                  try {
+                    return t.set(...O), a;
+                  } finally {
+                    s();
+                  }
+                };
+              default:
+                return _.ReflectAdapter.get(t, r, l);
+            }
+          }
+        });
+        return a;
+      }
+    }
+    function E(D) {
+      const v = new Proxy(D, {
+        get(m, h, n) {
+          switch (h) {
+            case "delete":
+              return function(...e) {
+                return I("cookies().delete"), m.delete(...e), v;
+              };
+            case "set":
+              return function(...e) {
+                return I("cookies().set"), m.set(...e), v;
+              };
+            default:
+              return _.ReflectAdapter.get(m, h, n);
+          }
+        }
+      });
+      return v;
+    }
+    function P(D) {
+      return D.phase === "action";
+    }
+    function I(D) {
+      const v = (0, k.getExpectedRequestStore)(D);
+      if (!P(v))
+        throw new o();
+    }
+    function q(D) {
+      const v = new g.RequestCookies(new Headers());
+      for (const m of D.getAll())
+        v.set(m);
+      return v;
+    }
+  })(ee)), ee;
+}
+var ue = {}, V = { exports: {} }, Ce;
+function He() {
+  return Ce || (Ce = 1, (function(f, y) {
+    Object.defineProperty(y, "__esModule", {
+      value: !0
+    });
+    function g(o, i) {
+      for (var p in i) Object.defineProperty(o, p, {
+        enumerable: !0,
+        get: i[p]
+      });
+    }
+    g(y, {
+      DynamicServerError: function() {
+        return d;
+      },
+      isDynamicServerError: function() {
+        return k;
+      }
+    });
+    const _ = "DYNAMIC_SERVER_USAGE";
+    class d extends Error {
+      constructor(i) {
+        super("Dynamic server usage: " + i), this.description = i, this.digest = _;
+      }
+    }
+    function k(o) {
+      return typeof o != "object" || o === null || !("digest" in o) || typeof o.digest != "string" ? !1 : o.digest === _;
+    }
+    (typeof y.default == "function" || typeof y.default == "object" && y.default !== null) && typeof y.default.__esModule > "u" && (Object.defineProperty(y.default, "__esModule", { value: !0 }), Object.assign(y.default, y), f.exports = y.default);
+  })(V, V.exports)), V.exports;
+}
+var z = { exports: {} }, je;
+function B() {
+  return je || (je = 1, (function(f, y) {
+    Object.defineProperty(y, "__esModule", {
+      value: !0
+    });
+    function g(o, i) {
+      for (var p in i) Object.defineProperty(o, p, {
+        enumerable: !0,
+        get: i[p]
+      });
+    }
+    g(y, {
+      StaticGenBailoutError: function() {
+        return d;
+      },
+      isStaticGenBailoutError: function() {
+        return k;
+      }
+    });
+    const _ = "NEXT_STATIC_GEN_BAILOUT";
+    class d extends Error {
+      constructor(...i) {
+        super(...i), this.code = _;
+      }
+    }
+    function k(o) {
+      return typeof o != "object" || o === null || !("code" in o) ? !1 : o.code === _;
+    }
+    (typeof y.default == "function" || typeof y.default == "object" && y.default !== null) && typeof y.default.__esModule > "u" && (Object.defineProperty(y.default, "__esModule", { value: !0 }), Object.assign(y.default, y), f.exports = y.default);
+  })(z, z.exports)), z.exports;
+}
+var le = {}, Me;
+function _e() {
+  return Me || (Me = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "makeHangingPromise", {
+      enumerable: !0,
+      get: function() {
+        return y;
+      }
+    });
+    function y(_, d) {
+      const k = new Promise((o, i) => {
+        _.addEventListener("abort", () => {
+          i(new Error(`During prerendering, ${d} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${d} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context.`));
+        }, {
+          once: !0
+        });
+      });
+      return k.catch(g), k;
+    }
+    function g() {
+    }
+  })(le)), le;
+}
+var de = {}, Ne;
+function mt() {
+  return Ne || (Ne = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    });
+    function y(k, o) {
+      for (var i in o) Object.defineProperty(k, i, {
+        enumerable: !0,
+        get: o[i]
+      });
+    }
+    y(f, {
+      METADATA_BOUNDARY_NAME: function() {
+        return g;
+      },
+      OUTLET_BOUNDARY_NAME: function() {
+        return d;
+      },
+      VIEWPORT_BOUNDARY_NAME: function() {
+        return _;
+      }
+    });
+    const g = "__next_metadata_boundary__", _ = "__next_viewport_boundary__", d = "__next_outlet_boundary__";
+  })(de)), de;
+}
+var Le;
+function Ae() {
+  return Le || (Le = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    });
+    function y(u, c) {
+      for (var A in c) Object.defineProperty(u, A, {
+        enumerable: !0,
+        get: c[A]
+      });
+    }
+    y(f, {
+      Postpone: function() {
+        return a;
+      },
+      abortAndThrowOnSynchronousRequestDataAccess: function() {
+        return e;
+      },
+      abortOnSynchronousPlatformIOAccess: function() {
+        return h;
+      },
+      accessedDynamicData: function() {
+        return M;
+      },
+      annotateDynamicAccess: function() {
+        return J;
+      },
+      consumeDynamicAccess: function() {
+        return F;
+      },
+      createDynamicTrackingState: function() {
+        return S;
+      },
+      createDynamicValidationState: function() {
+        return E;
+      },
+      createPostponedAbortSignal: function() {
+        return X;
+      },
+      formatDynamicAPIAccesses: function() {
+        return G;
+      },
+      getFirstDynamicReason: function() {
+        return P;
+      },
+      isDynamicPostpone: function() {
+        return l;
+      },
+      isPrerenderInterruptedError: function() {
+        return C;
+      },
+      markCurrentScopeAsDynamic: function() {
+        return I;
+      },
+      postponeWithTracking: function() {
+        return t;
+      },
+      throwIfDisallowedDynamic: function() {
+        return ut;
+      },
+      throwToInterruptStaticGeneration: function() {
+        return D;
+      },
+      trackAllowedDynamicAccess: function() {
+        return it;
+      },
+      trackDynamicDataInDynamicRender: function() {
+        return v;
+      },
+      trackFallbackParamAccessed: function() {
+        return q;
+      },
+      trackSynchronousPlatformIOAccessInDev: function() {
+        return n;
+      },
+      trackSynchronousRequestDataAccessInDev: function() {
+        return s;
+      },
+      useDynamicRouteParams: function() {
+        return rt;
+      }
+    });
+    const g = /* @__PURE__ */ b(Ke), _ = He(), d = B(), k = W(), o = U(), i = _e(), p = mt();
+    function b(u) {
+      return u && u.__esModule ? u : {
+        default: u
+      };
+    }
+    const x = typeof g.default.unstable_postpone == "function";
+    function S(u) {
+      return {
+        isDebugDynamicAccesses: u,
+        dynamicAccesses: [],
+        syncDynamicExpression: void 0,
+        syncDynamicErrorWithStack: null
+      };
+    }
+    function E() {
+      return {
+        hasSuspendedDynamic: !1,
+        hasDynamicMetadata: !1,
+        hasDynamicViewport: !1,
+        hasSyncDynamicErrors: !1,
+        dynamicErrors: []
+      };
+    }
+    function P(u) {
+      var c;
+      return (c = u.dynamicAccesses[0]) == null ? void 0 : c.expression;
+    }
+    function I(u, c, A) {
+      if (!(c && (c.type === "cache" || c.type === "unstable-cache")) && !(u.forceDynamic || u.forceStatic)) {
+        if (u.dynamicShouldError)
+          throw new d.StaticGenBailoutError(`Route ${u.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`);
+        if (c)
+          if (c.type === "prerender-ppr")
+            t(u.route, A, c.dynamicTracking);
+          else if (c.type === "prerender-legacy") {
+            c.revalidate = 0;
+            const T = new _.DynamicServerError(`Route ${u.route} couldn't be rendered statically because it used ${A}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
+            throw u.dynamicUsageDescription = A, u.dynamicUsageStack = T.stack, T;
+          } else process.env.NODE_ENV === "development" && c && c.type === "request" && (c.usedDynamic = !0);
+      }
+    }
+    function q(u, c) {
+      const A = k.workUnitAsyncStorage.getStore();
+      !A || A.type !== "prerender-ppr" || t(u.route, c, A.dynamicTracking);
+    }
+    function D(u, c, A) {
+      const T = new _.DynamicServerError(`Route ${c.route} couldn't be rendered statically because it used \`${u}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
+      throw A.revalidate = 0, c.dynamicUsageDescription = u, c.dynamicUsageStack = T.stack, T;
+    }
+    function v(u, c) {
+      if (c) {
+        if (c.type === "cache" || c.type === "unstable-cache")
+          return;
+        (c.type === "prerender" || c.type === "prerender-legacy") && (c.revalidate = 0), process.env.NODE_ENV === "development" && c.type === "request" && (c.usedDynamic = !0);
+      }
+    }
+    function m(u, c, A) {
+      const T = `Route ${u} needs to bail out of prerendering at this point because it used ${c}.`, $ = w(T);
+      A.controller.abort($);
+      const j = A.dynamicTracking;
+      j && j.dynamicAccesses.push({
+        // When we aren't debugging, we don't need to create another error for the
+        // stack trace.
+        stack: j.isDebugDynamicAccesses ? new Error().stack : void 0,
+        expression: c
+      });
+    }
+    function h(u, c, A, T) {
+      const $ = T.dynamicTracking;
+      return $ && $.syncDynamicErrorWithStack === null && ($.syncDynamicExpression = c, $.syncDynamicErrorWithStack = A), m(u, c, T);
+    }
+    function n(u) {
+      u.prerenderPhase = !1;
+    }
+    function e(u, c, A, T) {
+      const $ = T.dynamicTracking;
+      throw $ && $.syncDynamicErrorWithStack === null && ($.syncDynamicExpression = c, $.syncDynamicErrorWithStack = A, T.validating === !0 && ($.syncDynamicLogged = !0)), m(u, c, T), w(`Route ${u} needs to bail out of prerendering at this point because it used ${c}.`);
+    }
+    const s = n;
+    function a({ reason: u, route: c }) {
+      const A = k.workUnitAsyncStorage.getStore(), T = A && A.type === "prerender-ppr" ? A.dynamicTracking : null;
+      t(c, u, T);
+    }
+    function t(u, c, A) {
+      Y(), A && A.dynamicAccesses.push({
+        // When we aren't debugging, we don't need to create another error for the
+        // stack trace.
+        stack: A.isDebugDynamicAccesses ? new Error().stack : void 0,
+        expression: c
+      }), g.default.unstable_postpone(r(u, c));
+    }
+    function r(u, c) {
+      return `Route ${u} needs to bail out of prerendering at this point because it used ${c}. 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 l(u) {
+      return typeof u == "object" && u !== null && typeof u.message == "string" ? O(u.message) : !1;
+    }
+    function O(u) {
+      return u.includes("needs to bail out of prerendering at this point because it used") && u.includes("Learn more: https://nextjs.org/docs/messages/ppr-caught-error");
+    }
+    if (O(r("%%%", "^^^")) === !1)
+      throw new Error("Invariant: isDynamicPostpone misidentified a postpone reason. This is a bug in Next.js");
+    const R = "NEXT_PRERENDER_INTERRUPTED";
+    function w(u) {
+      const c = new Error(u);
+      return c.digest = R, c;
+    }
+    function C(u) {
+      return typeof u == "object" && u !== null && u.digest === R && "name" in u && "message" in u && u instanceof Error;
+    }
+    function M(u) {
+      return u.length > 0;
+    }
+    function F(u, c) {
+      return u.dynamicAccesses.push(...c.dynamicAccesses), u.dynamicAccesses;
+    }
+    function G(u) {
+      return u.filter((c) => typeof c.stack == "string" && c.stack.length > 0).map(({ expression: c, stack: A }) => (A = A.split(`
+`).slice(4).filter((T) => !(T.includes("node_modules/next/") || T.includes(" (<anonymous>)") || T.includes(" (node:"))).join(`
+`), `Dynamic API Usage Debug - ${c}:
+${A}`));
+    }
+    function Y() {
+      if (!x)
+        throw 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");
+    }
+    function X(u) {
+      Y();
+      const c = new AbortController();
+      try {
+        g.default.unstable_postpone(u);
+      } catch (A) {
+        c.abort(A);
+      }
+      return c.signal;
+    }
+    function J(u, c) {
+      const A = c.dynamicTracking;
+      A && A.dynamicAccesses.push({
+        stack: A.isDebugDynamicAccesses ? new Error().stack : void 0,
+        expression: u
+      });
+    }
+    function rt(u) {
+      if (typeof window > "u") {
+        const c = o.workAsyncStorage.getStore();
+        if (c && c.isStaticGeneration && c.fallbackRouteParams && c.fallbackRouteParams.size > 0) {
+          const A = k.workUnitAsyncStorage.getStore();
+          A && (A.type === "prerender" ? g.default.use((0, i.makeHangingPromise)(A.renderSignal, u)) : A.type === "prerender-ppr" ? t(c.route, u, A.dynamicTracking) : A.type === "prerender-legacy" && D(u, c, A));
+        }
+      }
+    }
+    const nt = /\n\s+at Suspense \(<anonymous>\)/, ot = new RegExp(`\\n\\s+at ${p.METADATA_BOUNDARY_NAME}[\\n\\s]`), st = new RegExp(`\\n\\s+at ${p.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`), at = new RegExp(`\\n\\s+at ${p.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
+    function it(u, c, A, T, $) {
+      if (!at.test(c))
+        if (ot.test(c)) {
+          A.hasDynamicMetadata = !0;
+          return;
+        } else if (st.test(c)) {
+          A.hasDynamicViewport = !0;
+          return;
+        } else if (nt.test(c)) {
+          A.hasSuspendedDynamic = !0;
+          return;
+        } else if (T.syncDynamicErrorWithStack || $.syncDynamicErrorWithStack) {
+          A.hasSyncDynamicErrors = !0;
+          return;
+        } else {
+          const j = `Route "${u}": A component accessed data, headers, params, searchParams, or a short-lived cache without a Suspense boundary nor a "use cache" above it. We don't have the exact line number added to error messages yet but you can see which component in the stack below. See more info: https://nextjs.org/docs/messages/next-prerender-missing-suspense`, N = ct(j, c);
+          A.dynamicErrors.push(N);
+          return;
+        }
+    }
+    function ct(u, c) {
+      const A = new Error(u);
+      return A.stack = "Error: " + u + c, A;
+    }
+    function ut(u, c, A, T) {
+      let $, j, N;
+      if (A.syncDynamicErrorWithStack ? ($ = A.syncDynamicErrorWithStack, j = A.syncDynamicExpression, N = A.syncDynamicLogged === !0) : T.syncDynamicErrorWithStack ? ($ = T.syncDynamicErrorWithStack, j = T.syncDynamicExpression, N = T.syncDynamicLogged === !0) : ($ = null, j = void 0, N = !1), c.hasSyncDynamicErrors && $)
+        throw N || console.error($), new d.StaticGenBailoutError();
+      const K = c.dynamicErrors;
+      if (K.length) {
+        for (let Z = 0; Z < K.length; Z++)
+          console.error(K[Z]);
+        throw new d.StaticGenBailoutError();
+      }
+      if (!c.hasSuspendedDynamic) {
+        if (c.hasDynamicMetadata)
+          throw $ ? (console.error($), new d.StaticGenBailoutError(`Route "${u}" has a \`generateMetadata\` that could not finish rendering before ${j} was used. Follow the instructions in the error for this expression to resolve.`)) : new d.StaticGenBailoutError(`Route "${u}" has a \`generateMetadata\` that depends on Request data (\`cookies()\`, etc...) or external data (\`fetch(...)\`, etc...) but the rest of the route was static or only used cached data (\`"use cache"\`). If you expected this route to be prerenderable update your \`generateMetadata\` to not use Request data and only use cached external data. Otherwise, add \`await connection()\` somewhere within this route to indicate explicitly it should not be prerendered.`);
+        if (c.hasDynamicViewport)
+          throw $ ? (console.error($), new d.StaticGenBailoutError(`Route "${u}" has a \`generateViewport\` that could not finish rendering before ${j} was used. Follow the instructions in the error for this expression to resolve.`)) : new d.StaticGenBailoutError(`Route "${u}" has a \`generateViewport\` that depends on Request data (\`cookies()\`, etc...) or external data (\`fetch(...)\`, etc...) but the rest of the route was static or only used cached data (\`"use cache"\`). If you expected this route to be prerenderable update your \`generateViewport\` to not use Request data and only use cached external data. Otherwise, add \`await connection()\` somewhere within this route to indicate explicitly it should not be prerendered.`);
+      }
+    }
+  })(ue)), ue;
+}
+var fe = {}, Ue;
+function ke() {
+  return Ue || (Ue = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "createDedupedByCallsiteServerErrorLoggerDev", {
+      enumerable: !0,
+      get: function() {
+        return p;
+      }
+    });
+    const y = /* @__PURE__ */ _(Ke);
+    function g(b) {
+      if (typeof WeakMap != "function") return null;
+      var x = /* @__PURE__ */ new WeakMap(), S = /* @__PURE__ */ new WeakMap();
+      return (g = function(E) {
+        return E ? S : x;
+      })(b);
+    }
+    function _(b, x) {
+      if (b && b.__esModule)
+        return b;
+      if (b === null || typeof b != "object" && typeof b != "function")
+        return {
+          default: b
+        };
+      var S = g(x);
+      if (S && S.has(b))
+        return S.get(b);
+      var E = {
+        __proto__: null
+      }, P = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var I in b)
+        if (I !== "default" && Object.prototype.hasOwnProperty.call(b, I)) {
+          var q = P ? Object.getOwnPropertyDescriptor(b, I) : null;
+          q && (q.get || q.set) ? Object.defineProperty(E, I, q) : E[I] = b[I];
+        }
+      return E.default = b, S && S.set(b, E), E;
+    }
+    const d = {
+      current: null
+    }, k = typeof y.cache == "function" ? y.cache : (b) => b, o = process.env.__NEXT_DYNAMIC_IO ? console.error : console.warn, i = k(
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- cache key
+      (b) => {
+        try {
+          o(d.current);
+        } finally {
+          d.current = null;
+        }
+      }
+    );
+    function p(b) {
+      return function(...S) {
+        const E = b(...S);
+        if (process.env.NODE_ENV !== "production") {
+          var P;
+          const I = (P = new Error().stack) == null ? void 0 : P.split(`
+`);
+          if (I === void 0 || I.length < 4)
+            o(E);
+          else {
+            const q = I[4];
+            d.current = E, i(q);
+          }
+        } else
+          o(E);
+      };
+    }
+  })(fe)), fe;
+}
+var pe = {}, We;
+function et() {
+  return We || (We = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    });
+    function y(o, i) {
+      for (var p in i) Object.defineProperty(o, p, {
+        enumerable: !0,
+        get: i[p]
+      });
+    }
+    y(f, {
+      atLeastOneTask: function() {
+        return d;
+      },
+      scheduleImmediate: function() {
+        return _;
+      },
+      scheduleOnNextTick: function() {
+        return g;
+      },
+      waitAtLeastOneReactRenderTask: function() {
+        return k;
+      }
+    });
+    const g = (o) => {
+      Promise.resolve().then(() => {
+        process.env.NEXT_RUNTIME === "edge" ? setTimeout(o, 0) : process.nextTick(o);
+      });
+    }, _ = (o) => {
+      process.env.NEXT_RUNTIME === "edge" ? setTimeout(o, 0) : setImmediate(o);
+    };
+    function d() {
+      return new Promise((o) => _(o));
+    }
+    function k() {
+      return process.env.NEXT_RUNTIME === "edge" ? new Promise((o) => setTimeout(o, 0)) : new Promise((o) => setImmediate(o));
+    }
+  })(pe)), pe;
+}
+var he = {}, ye = {}, me = {}, Be;
+function gt() {
+  return Be || (Be = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "afterTaskAsyncStorageInstance", {
+      enumerable: !0,
+      get: function() {
+        return g;
+      }
+    });
+    const g = (0, we().createAsyncLocalStorage)();
+  })(me)), me;
+}
+var Ge;
+function bt() {
+  return Ge || (Ge = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "afterTaskAsyncStorage", {
+      enumerable: !0,
+      get: function() {
+        return y.afterTaskAsyncStorageInstance;
+      }
+    });
+    const y = gt();
+  })(ye)), ye;
+}
+var Ye;
+function tt() {
+  return Ye || (Ye = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    });
+    function y(S, E) {
+      for (var P in E) Object.defineProperty(S, P, {
+        enumerable: !0,
+        get: E[P]
+      });
+    }
+    y(f, {
+      describeHasCheckingStringProperty: function() {
+        return o;
+      },
+      describeStringPropertyAccess: function() {
+        return k;
+      },
+      isRequestAPICallableInsideAfter: function() {
+        return b;
+      },
+      throwWithStaticGenerationBailoutError: function() {
+        return i;
+      },
+      throwWithStaticGenerationBailoutErrorWithDynamicError: function() {
+        return p;
+      },
+      wellKnownProperties: function() {
+        return x;
+      }
+    });
+    const g = B(), _ = bt(), d = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+    function k(S, E) {
+      return d.test(E) ? `\`${S}.${E}\`` : `\`${S}[${JSON.stringify(E)}]\``;
+    }
+    function o(S, E) {
+      const P = JSON.stringify(E);
+      return `\`Reflect.has(${S}, ${P})\`, \`${P} in ${S}\`, or similar`;
+    }
+    function i(S, E) {
+      throw new g.StaticGenBailoutError(`Route ${S} couldn't be rendered statically because it used ${E}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`);
+    }
+    function p(S, E) {
+      throw new g.StaticGenBailoutError(`Route ${S} with \`dynamic = "error"\` couldn't be rendered statically because it used ${E}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`);
+    }
+    function b() {
+      const S = _.afterTaskAsyncStorage.getStore();
+      return (S == null ? void 0 : S.rootTaskSpawnPhase) === "action";
+    }
+    const x = /* @__PURE__ */ new Set([
+      "hasOwnProperty",
+      "isPrototypeOf",
+      "propertyIsEnumerable",
+      "toString",
+      "valueOf",
+      "toLocaleString",
+      // Promise prototype
+      // fallthrough
+      "then",
+      "catch",
+      "finally",
+      // React Promise extension
+      // fallthrough
+      "status",
+      // React introspection
+      "displayName",
+      // Common tested properties
+      // fallthrough
+      "toJSON",
+      "$$typeof",
+      "__esModule"
+    ]);
+  })(he)), he;
+}
+var Ve;
+function vt() {
+  return Ve || (Ve = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "cookies", {
+      enumerable: !0,
+      get: function() {
+        return S;
+      }
+    });
+    const y = yt(), g = Ze(), _ = U(), d = W(), k = Ae(), o = B(), i = _e(), p = ke(), b = et(), x = tt();
+    function S() {
+      const t = "cookies", r = _.workAsyncStorage.getStore(), l = d.workUnitAsyncStorage.getStore();
+      if (r) {
+        if (l && l.phase === "after" && !(0, x.isRequestAPICallableInsideAfter)())
+          throw new Error(
+            // TODO(after): clarify that this only applies to pages?
+            `Route ${r.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`
+          );
+        if (r.forceStatic) {
+          const w = E();
+          return q(w);
+        }
+        if (l) {
+          if (l.type === "cache")
+            throw new Error(`Route ${r.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`);
+          if (l.type === "unstable-cache")
+            throw new Error(`Route ${r.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`);
+        }
+        if (r.dynamicShouldError)
+          throw new o.StaticGenBailoutError(`Route ${r.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`);
+        if (l) {
+          if (l.type === "prerender")
+            return I(r.route, l);
+          l.type === "prerender-ppr" ? (0, k.postponeWithTracking)(r.route, t, l.dynamicTracking) : l.type === "prerender-legacy" && (0, k.throwToInterruptStaticGeneration)(t, r, l);
+        }
+        (0, k.trackDynamicDataInDynamicRender)(r, l);
+      }
+      const O = (0, d.getExpectedRequestStore)(t);
+      let R;
+      return (0, y.areCookiesMutableInCurrentPhase)(O) ? R = O.userspaceMutableCookies : R = O.cookies, process.env.NODE_ENV === "development" && !(r != null && r.isPrefetchRequest) ? D(R, r == null ? void 0 : r.route) : q(R);
+    }
+    function E() {
+      return y.RequestCookiesAdapter.seal(new g.RequestCookies(new Headers({})));
+    }
+    const P = /* @__PURE__ */ new WeakMap();
+    function I(t, r) {
+      const l = P.get(r);
+      if (l)
+        return l;
+      const O = (0, i.makeHangingPromise)(r.renderSignal, "`cookies()`");
+      return P.set(r, O), Object.defineProperties(O, {
+        [Symbol.iterator]: {
+          value: function() {
+            const R = "`cookies()[Symbol.iterator]()`", w = e(t, R);
+            (0, k.abortAndThrowOnSynchronousRequestDataAccess)(t, R, w, r);
+          }
+        },
+        size: {
+          get() {
+            const R = "`cookies().size`", w = e(t, R);
+            (0, k.abortAndThrowOnSynchronousRequestDataAccess)(t, R, w, r);
+          }
+        },
+        get: {
+          value: function() {
+            let w;
+            arguments.length === 0 ? w = "`cookies().get()`" : w = `\`cookies().get(${v(arguments[0])})\``;
+            const C = e(t, w);
+            (0, k.abortAndThrowOnSynchronousRequestDataAccess)(t, w, C, r);
+          }
+        },
+        getAll: {
+          value: function() {
+            let w;
+            arguments.length === 0 ? w = "`cookies().getAll()`" : w = `\`cookies().getAll(${v(arguments[0])})\``;
+            const C = e(t, w);
+            (0, k.abortAndThrowOnSynchronousRequestDataAccess)(t, w, C, r);
+          }
+        },
+        has: {
+          value: function() {
+            let w;
+            arguments.length === 0 ? w = "`cookies().has()`" : w = `\`cookies().has(${v(arguments[0])})\``;
+            const C = e(t, w);
+            (0, k.abortAndThrowOnSynchronousRequestDataAccess)(t, w, C, r);
+          }
+        },
+        set: {
+          value: function() {
+            let w;
+            if (arguments.length === 0)
+              w = "`cookies().set()`";
+            else {
+              const M = arguments[0];
+              M ? w = `\`cookies().set(${v(M)}, ...)\`` : w = "`cookies().set(...)`";
+            }
+            const C = e(t, w);
+            (0, k.abortAndThrowOnSynchronousRequestDataAccess)(t, w, C, r);
+          }
+        },
+        delete: {
+          value: function() {
+            let R;
+            arguments.length === 0 ? R = "`cookies().delete()`" : arguments.length === 1 ? R = `\`cookies().delete(${v(arguments[0])})\`` : R = `\`cookies().delete(${v(arguments[0])}, ...)\``;
+            const w = e(t, R);
+            (0, k.abortAndThrowOnSynchronousRequestDataAccess)(t, R, w, r);
+          }
+        },
+        clear: {
+          value: function() {
+            const w = "`cookies().clear()`", C = e(t, w);
+            (0, k.abortAndThrowOnSynchronousRequestDataAccess)(t, w, C, r);
+          }
+        },
+        toString: {
+          value: function() {
+            const w = "`cookies().toString()`", C = e(t, w);
+            (0, k.abortAndThrowOnSynchronousRequestDataAccess)(t, w, C, r);
+          }
+        }
+      }), O;
+    }
+    function q(t) {
+      const r = P.get(t);
+      if (r)
+        return r;
+      const l = Promise.resolve(t);
+      return P.set(t, l), Object.defineProperties(l, {
+        [Symbol.iterator]: {
+          value: t[Symbol.iterator] ? t[Symbol.iterator].bind(t) : (
+            // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+            // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+            // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+            // has extra properties not available on RequestCookie instances.
+            s.bind(t)
+          )
+        },
+        size: {
+          get() {
+            return t.size;
+          }
+        },
+        get: {
+          value: t.get.bind(t)
+        },
+        getAll: {
+          value: t.getAll.bind(t)
+        },
+        has: {
+          value: t.has.bind(t)
+        },
+        set: {
+          value: t.set.bind(t)
+        },
+        delete: {
+          value: t.delete.bind(t)
+        },
+        clear: {
+          value: (
+            // @ts-expect-error clear is defined in RequestCookies implementation but not in the type
+            typeof t.clear == "function" ? t.clear.bind(t) : (
+              // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+              // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+              // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+              // has extra properties not available on RequestCookie instances.
+              a.bind(t, l)
+            )
+          )
+        },
+        toString: {
+          value: t.toString.bind(t)
+        }
+      }), l;
+    }
+    function D(t, r) {
+      const l = P.get(t);
+      if (l)
+        return l;
+      const O = new Promise((R) => (0, b.scheduleImmediate)(() => R(t)));
+      return P.set(t, O), Object.defineProperties(O, {
+        [Symbol.iterator]: {
+          value: function() {
+            return m(r, "`...cookies()` or similar iteration"), t[Symbol.iterator] ? t[Symbol.iterator].apply(t, arguments) : (
+              // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+              // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+              // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+              // has extra properties not available on RequestCookie instances.
+              s.call(t)
+            );
+          },
+          writable: !1
+        },
+        size: {
+          get() {
+            return m(r, "`cookies().size`"), t.size;
+          }
+        },
+        get: {
+          value: function() {
+            let w;
+            return arguments.length === 0 ? w = "`cookies().get()`" : w = `\`cookies().get(${v(arguments[0])})\``, m(r, w), t.get.apply(t, arguments);
+          },
+          writable: !1
+        },
+        getAll: {
+          value: function() {
+            let w;
+            return arguments.length === 0 ? w = "`cookies().getAll()`" : w = `\`cookies().getAll(${v(arguments[0])})\``, m(r, w), t.getAll.apply(t, arguments);
+          },
+          writable: !1
+        },
+        has: {
+          value: function() {
+            let w;
+            return arguments.length === 0 ? w = "`cookies().has()`" : w = `\`cookies().has(${v(arguments[0])})\``, m(r, w), t.has.apply(t, arguments);
+          },
+          writable: !1
+        },
+        set: {
+          value: function() {
+            let w;
+            if (arguments.length === 0)
+              w = "`cookies().set()`";
+            else {
+              const C = arguments[0];
+              C ? w = `\`cookies().set(${v(C)}, ...)\`` : w = "`cookies().set(...)`";
+            }
+            return m(r, w), t.set.apply(t, arguments);
+          },
+          writable: !1
+        },
+        delete: {
+          value: function() {
+            let R;
+            return arguments.length === 0 ? R = "`cookies().delete()`" : arguments.length === 1 ? R = `\`cookies().delete(${v(arguments[0])})\`` : R = `\`cookies().delete(${v(arguments[0])}, ...)\``, m(r, R), t.delete.apply(t, arguments);
+          },
+          writable: !1
+        },
+        clear: {
+          value: function() {
+            return m(r, "`cookies().clear()`"), typeof t.clear == "function" ? t.clear.apply(t, arguments) : (
+              // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+              // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+              // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+              // has extra properties not available on RequestCookie instances.
+              a.call(t, O)
+            );
+          },
+          writable: !1
+        },
+        toString: {
+          value: function() {
+            return m(r, "`cookies().toString()` or implicit casting"), t.toString.apply(t, arguments);
+          },
+          writable: !1
+        }
+      }), O;
+    }
+    function v(t) {
+      return typeof t == "object" && t !== null && typeof t.name == "string" ? `'${t.name}'` : typeof t == "string" ? `'${t}'` : "...";
+    }
+    function m(t, r) {
+      const l = d.workUnitAsyncStorage.getStore();
+      if (l && l.type === "request" && l.prerenderPhase === !0) {
+        const O = l;
+        (0, k.trackSynchronousRequestDataAccessInDev)(O);
+      }
+      n(t, r);
+    }
+    const h = () => {
+    }, n = process.env.__NEXT_DISABLE_SYNC_DYNAMIC_API_WARNINGS ? h : (0, p.createDedupedByCallsiteServerErrorLoggerDev)(e);
+    function e(t, r) {
+      const l = t ? `Route "${t}" ` : "This route ";
+      return new Error(`${l}used ${r}. \`cookies()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
+    }
+    function s() {
+      return this.getAll().map((t) => [
+        t.name,
+        t
+      ]).values();
+    }
+    function a(t) {
+      for (const r of this.getAll())
+        this.delete(r.name);
+      return t;
+    }
+  })(H)), H;
+}
+var ge = {}, be = {}, ze;
+function wt() {
+  return ze || (ze = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    });
+    function y(k, o) {
+      for (var i in o) Object.defineProperty(k, i, {
+        enumerable: !0,
+        get: o[i]
+      });
+    }
+    y(f, {
+      HeadersAdapter: function() {
+        return d;
+      },
+      ReadonlyHeadersError: function() {
+        return _;
+      }
+    });
+    const g = Qe();
+    class _ extends Error {
+      constructor() {
+        super("Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers");
+      }
+      static callable() {
+        throw new _();
+      }
+    }
+    class d extends Headers {
+      constructor(o) {
+        super(), this.headers = new Proxy(o, {
+          get(i, p, b) {
+            if (typeof p == "symbol")
+              return g.ReflectAdapter.get(i, p, b);
+            const x = p.toLowerCase(), S = Object.keys(o).find((E) => E.toLowerCase() === x);
+            if (!(typeof S > "u"))
+              return g.ReflectAdapter.get(i, S, b);
+          },
+          set(i, p, b, x) {
+            if (typeof p == "symbol")
+              return g.ReflectAdapter.set(i, p, b, x);
+            const S = p.toLowerCase(), E = Object.keys(o).find((P) => P.toLowerCase() === S);
+            return g.ReflectAdapter.set(i, E ?? p, b, x);
+          },
+          has(i, p) {
+            if (typeof p == "symbol") return g.ReflectAdapter.has(i, p);
+            const b = p.toLowerCase(), x = Object.keys(o).find((S) => S.toLowerCase() === b);
+            return typeof x > "u" ? !1 : g.ReflectAdapter.has(i, x);
+          },
+          deleteProperty(i, p) {
+            if (typeof p == "symbol") return g.ReflectAdapter.deleteProperty(i, p);
+            const b = p.toLowerCase(), x = Object.keys(o).find((S) => S.toLowerCase() === b);
+            return typeof x > "u" ? !0 : g.ReflectAdapter.deleteProperty(i, x);
+          }
+        });
+      }
+      /**
+      * Seals a Headers instance to prevent modification by throwing an error when
+      * any mutating method is called.
+      */
+      static seal(o) {
+        return new Proxy(o, {
+          get(i, p, b) {
+            switch (p) {
+              case "append":
+              case "delete":
+              case "set":
+                return _.callable;
+              default:
+                return g.ReflectAdapter.get(i, p, b);
+            }
+          }
+        });
+      }
+      /**
+      * 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(o) {
+        return Array.isArray(o) ? o.join(", ") : o;
+      }
+      /**
+      * 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(o) {
+        return o instanceof Headers ? o : new d(o);
+      }
+      append(o, i) {
+        const p = this.headers[o];
+        typeof p == "string" ? this.headers[o] = [
+          p,
+          i
+        ] : Array.isArray(p) ? p.push(i) : this.headers[o] = i;
+      }
+      delete(o) {
+        delete this.headers[o];
+      }
+      get(o) {
+        const i = this.headers[o];
+        return typeof i < "u" ? this.merge(i) : null;
+      }
+      has(o) {
+        return typeof this.headers[o] < "u";
+      }
+      set(o, i) {
+        this.headers[o] = i;
+      }
+      forEach(o, i) {
+        for (const [p, b] of this.entries())
+          o.call(i, b, p, this);
+      }
+      *entries() {
+        for (const o of Object.keys(this.headers)) {
+          const i = o.toLowerCase(), p = this.get(i);
+          yield [
+            i,
+            p
+          ];
+        }
+      }
+      *keys() {
+        for (const o of Object.keys(this.headers))
+          yield o.toLowerCase();
+      }
+      *values() {
+        for (const o of Object.keys(this.headers))
+          yield this.get(o);
+      }
+      [Symbol.iterator]() {
+        return this.entries();
+      }
+    }
+  })(be)), be;
+}
+var Fe;
+function _t() {
+  return Fe || (Fe = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "headers", {
+      enumerable: !0,
+      get: function() {
+        return x;
+      }
+    });
+    const y = wt(), g = U(), _ = W(), d = Ae(), k = B(), o = _e(), i = ke(), p = et(), b = tt();
+    function x() {
+      const n = g.workAsyncStorage.getStore(), e = _.workUnitAsyncStorage.getStore();
+      if (n) {
+        if (e && e.phase === "after" && !(0, b.isRequestAPICallableInsideAfter)())
+          throw new Error(`Route ${n.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`);
+        if (n.forceStatic) {
+          const a = y.HeadersAdapter.seal(new Headers({}));
+          return P(a);
+        }
+        if (e) {
+          if (e.type === "cache")
+            throw new Error(`Route ${n.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`);
+          if (e.type === "unstable-cache")
+            throw new Error(`Route ${n.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`);
+        }
+        if (n.dynamicShouldError)
+          throw new k.StaticGenBailoutError(`Route ${n.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`);
+        if (e) {
+          if (e.type === "prerender")
+            return E(n.route, e);
+          e.type === "prerender-ppr" ? (0, d.postponeWithTracking)(n.route, "headers", e.dynamicTracking) : e.type === "prerender-legacy" && (0, d.throwToInterruptStaticGeneration)("headers", n, e);
+        }
+        (0, d.trackDynamicDataInDynamicRender)(n, e);
+      }
+      const s = (0, _.getExpectedRequestStore)("headers");
+      return process.env.NODE_ENV === "development" && !(n != null && n.isPrefetchRequest) ? I(s.headers, n == null ? void 0 : n.route) : P(s.headers);
+    }
+    const S = /* @__PURE__ */ new WeakMap();
+    function E(n, e) {
+      const s = S.get(e);
+      if (s)
+        return s;
+      const a = (0, o.makeHangingPromise)(e.renderSignal, "`headers()`");
+      return S.set(e, a), Object.defineProperties(a, {
+        append: {
+          value: function() {
+            const r = `\`headers().append(${q(arguments[0])}, ...)\``, l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        delete: {
+          value: function() {
+            const r = `\`headers().delete(${q(arguments[0])})\``, l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        get: {
+          value: function() {
+            const r = `\`headers().get(${q(arguments[0])})\``, l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        has: {
+          value: function() {
+            const r = `\`headers().has(${q(arguments[0])})\``, l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        set: {
+          value: function() {
+            const r = `\`headers().set(${q(arguments[0])}, ...)\``, l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        getSetCookie: {
+          value: function() {
+            const r = "`headers().getSetCookie()`", l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        forEach: {
+          value: function() {
+            const r = "`headers().forEach(...)`", l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        keys: {
+          value: function() {
+            const r = "`headers().keys()`", l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        values: {
+          value: function() {
+            const r = "`headers().values()`", l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        entries: {
+          value: function() {
+            const r = "`headers().entries()`", l = h(n, r);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, r, l, e);
+          }
+        },
+        [Symbol.iterator]: {
+          value: function() {
+            const t = "`headers()[Symbol.iterator]()`", r = h(n, t);
+            (0, d.abortAndThrowOnSynchronousRequestDataAccess)(n, t, r, e);
+          }
+        }
+      }), a;
+    }
+    function P(n) {
+      const e = S.get(n);
+      if (e)
+        return e;
+      const s = Promise.resolve(n);
+      return S.set(n, s), Object.defineProperties(s, {
+        append: {
+          value: n.append.bind(n)
+        },
+        delete: {
+          value: n.delete.bind(n)
+        },
+        get: {
+          value: n.get.bind(n)
+        },
+        has: {
+          value: n.has.bind(n)
+        },
+        set: {
+          value: n.set.bind(n)
+        },
+        getSetCookie: {
+          value: n.getSetCookie.bind(n)
+        },
+        forEach: {
+          value: n.forEach.bind(n)
+        },
+        keys: {
+          value: n.keys.bind(n)
+        },
+        values: {
+          value: n.values.bind(n)
+        },
+        entries: {
+          value: n.entries.bind(n)
+        },
+        [Symbol.iterator]: {
+          value: n[Symbol.iterator].bind(n)
+        }
+      }), s;
+    }
+    function I(n, e) {
+      const s = S.get(n);
+      if (s)
+        return s;
+      const a = new Promise((t) => (0, p.scheduleImmediate)(() => t(n)));
+      return S.set(n, a), Object.defineProperties(a, {
+        append: {
+          value: function() {
+            const r = `\`headers().append(${q(arguments[0])}, ...)\``;
+            return D(e, r), n.append.apply(n, arguments);
+          }
+        },
+        delete: {
+          value: function() {
+            const r = `\`headers().delete(${q(arguments[0])})\``;
+            return D(e, r), n.delete.apply(n, arguments);
+          }
+        },
+        get: {
+          value: function() {
+            const r = `\`headers().get(${q(arguments[0])})\``;
+            return D(e, r), n.get.apply(n, arguments);
+          }
+        },
+        has: {
+          value: function() {
+            const r = `\`headers().has(${q(arguments[0])})\``;
+            return D(e, r), n.has.apply(n, arguments);
+          }
+        },
+        set: {
+          value: function() {
+            const r = `\`headers().set(${q(arguments[0])}, ...)\``;
+            return D(e, r), n.set.apply(n, arguments);
+          }
+        },
+        getSetCookie: {
+          value: function() {
+            return D(e, "`headers().getSetCookie()`"), n.getSetCookie.apply(n, arguments);
+          }
+        },
+        forEach: {
+          value: function() {
+            return D(e, "`headers().forEach(...)`"), n.forEach.apply(n, arguments);
+          }
+        },
+        keys: {
+          value: function() {
+            return D(e, "`headers().keys()`"), n.keys.apply(n, arguments);
+          }
+        },
+        values: {
+          value: function() {
+            return D(e, "`headers().values()`"), n.values.apply(n, arguments);
+          }
+        },
+        entries: {
+          value: function() {
+            return D(e, "`headers().entries()`"), n.entries.apply(n, arguments);
+          }
+        },
+        [Symbol.iterator]: {
+          value: function() {
+            return D(e, "`...headers()` or similar iteration"), n[Symbol.iterator].apply(n, arguments);
+          }
+        }
+      }), a;
+    }
+    function q(n) {
+      return typeof n == "string" ? `'${n}'` : "...";
+    }
+    function D(n, e) {
+      const s = _.workUnitAsyncStorage.getStore();
+      if (s && s.type === "request" && s.prerenderPhase === !0) {
+        const a = s;
+        (0, d.trackSynchronousRequestDataAccessInDev)(a);
+      }
+      m(n, e);
+    }
+    const v = () => {
+    }, m = process.env.__NEXT_DISABLE_SYNC_DYNAMIC_API_WARNINGS ? v : (0, i.createDedupedByCallsiteServerErrorLoggerDev)(h);
+    function h(n, e) {
+      const s = n ? `Route "${n}" ` : "This route ";
+      return new Error(`${s}used ${e}. \`headers()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
+    }
+  })(ge)), ge;
+}
+var ve = {}, Xe;
+function At() {
+  return Xe || (Xe = 1, (function(f) {
+    Object.defineProperty(f, "__esModule", {
+      value: !0
+    }), Object.defineProperty(f, "draftMode", {
+      enumerable: !0,
+      get: function() {
+        return i;
+      }
+    });
+    const y = W(), g = U(), _ = Ae(), d = ke(), k = B(), o = He();
+    function i() {
+      const v = "draftMode", m = g.workAsyncStorage.getStore(), h = y.workUnitAsyncStorage.getStore();
+      if (h && (h.type === "cache" || h.type === "unstable-cache" || h.type === "prerender" || h.type === "prerender-ppr" || h.type === "prerender-legacy"))
+        if (process.env.NODE_ENV === "development" && !(m != null && m.isPrefetchRequest)) {
+          const a = m == null ? void 0 : m.route;
+          return x(null, a);
+        } else
+          return b(null);
+      const n = (0, y.getExpectedRequestStore)(v), e = p.get(n.draftMode);
+      if (e)
+        return e;
+      let s;
+      if (process.env.NODE_ENV === "development" && !(m != null && m.isPrefetchRequest)) {
+        const a = m == null ? void 0 : m.route;
+        s = x(n.draftMode, a);
+      } else
+        s = b(n.draftMode);
+      return p.set(n.draftMode, s), s;
+    }
+    const p = /* @__PURE__ */ new WeakMap();
+    function b(v) {
+      const m = new S(v), h = Promise.resolve(m);
+      return Object.defineProperty(h, "isEnabled", {
+        get() {
+          return m.isEnabled;
+        },
+        set(n) {
+          Object.defineProperty(h, "isEnabled", {
+            value: n,
+            writable: !0,
+            enumerable: !0
+          });
+        },
+        enumerable: !0,
+        configurable: !0
+      }), h.enable = m.enable.bind(m), h.disable = m.disable.bind(m), h;
+    }
+    function x(v, m) {
+      const h = new S(v), n = Promise.resolve(h);
+      return Object.defineProperty(n, "isEnabled", {
+        get() {
+          return E(m, "`draftMode().isEnabled`"), h.isEnabled;
+        },
+        set(e) {
+          Object.defineProperty(n, "isEnabled", {
+            value: e,
+            writable: !0,
+            enumerable: !0
+          });
+        },
+        enumerable: !0,
+        configurable: !0
+      }), Object.defineProperty(n, "enable", {
+        value: function() {
+          return E(m, "`draftMode().enable()`"), h.enable.apply(h, arguments);
+        }
+      }), Object.defineProperty(n, "disable", {
+        value: function() {
+          return E(m, "`draftMode().disable()`"), h.disable.apply(h, arguments);
+        }
+      }), n;
+    }
+    class S {
+      constructor(m) {
+        this._provider = m;
+      }
+      get isEnabled() {
+        return this._provider !== null ? this._provider.isEnabled : !1;
+      }
+      enable() {
+        D("draftMode().enable()"), this._provider !== null && this._provider.enable();
+      }
+      disable() {
+        D("draftMode().disable()"), this._provider !== null && this._provider.disable();
+      }
+    }
+    function E(v, m) {
+      const h = y.workUnitAsyncStorage.getStore();
+      if (h && h.type === "request" && h.prerenderPhase === !0) {
+        const n = h;
+        (0, _.trackSynchronousRequestDataAccessInDev)(n);
+      }
+      I(v, m);
+    }
+    const P = () => {
+    }, I = process.env.__NEXT_DISABLE_SYNC_DYNAMIC_API_WARNINGS ? P : (0, d.createDedupedByCallsiteServerErrorLoggerDev)(q);
+    function q(v, m) {
+      const h = v ? `Route "${v}" ` : "This route ";
+      return new Error(`${h}used ${m}. \`draftMode()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
+    }
+    function D(v) {
+      const m = g.workAsyncStorage.getStore(), h = y.workUnitAsyncStorage.getStore();
+      if (m) {
+        if (h) {
+          if (h.type === "cache")
+            throw new Error(`Route ${m.route} used "${v}" 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`);
+          if (h.type === "unstable-cache")
+            throw new Error(`Route ${m.route} used "${v}" 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`);
+          if (h.phase === "after")
+            throw new Error(`Route ${m.route} used "${v}" 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`);
+        }
+        if (m.dynamicShouldError)
+          throw new k.StaticGenBailoutError(`Route ${m.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${v}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`);
+        if (h)
+          if (h.type === "prerender") {
+            const n = new Error(`Route ${m.route} used ${v} without first calling \`await connection()\`. See more info here: https://nextjs.org/docs/messages/next-prerender-sync-headers`);
+            (0, _.abortAndThrowOnSynchronousRequestDataAccess)(m.route, v, n, h);
+          } else if (h.type === "prerender-ppr")
+            (0, _.postponeWithTracking)(m.route, v, h.dynamicTracking);
+          else if (h.type === "prerender-legacy") {
+            h.revalidate = 0;
+            const n = new o.DynamicServerError(`Route ${m.route} couldn't be rendered statically because it used \`${v}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
+            throw m.dynamicUsageDescription = v, m.dynamicUsageStack = n.stack, n;
+          } else process.env.NODE_ENV === "development" && h && h.type === "request" && (h.usedDynamic = !0);
+      }
+    }
+  })(ve)), ve;
+}
+var Je;
+function kt() {
+  return Je || (Je = 1, L.cookies = vt().cookies, L.headers = _t().headers, L.draftMode = At().draftMode), L;
+}
+var St = kt();
+const Pt = {
+  PROFILE_UPDATED: "user-profile-updated",
+  LOGGED_IN: "user-logged-in",
+  LOGGED_OUT: "user-logged-out"
+};
+function qt(f, y) {
+  const g = new CustomEvent(f, { detail: y });
+  window.dispatchEvent(g);
+}
+function Tt(f, y) {
+  const g = (_) => {
+    y(_.detail);
+  };
+  return window.addEventListener(f, g), () => window.removeEventListener(f, g);
+}
+function $t(f, y) {
+  window.removeEventListener(f, y);
+}
+async function It({ extra: f, children: y, className: g, hideNews: _, hideLogin: d }) {
+  var S;
+  let k = {
+    data: {}
+  };
+  const i = (S = (await St.cookies()).get("refresh_token")) == null ? void 0 : S.value, p = typeof i < "u" && i !== "";
+  try {
+    p && (k = await dt.get("/v2/users/profile", {
+      baseURL: process.env.ICHAINGO_AUTH_INNER_API_URL
+    }));
+  } catch (E) {
+    console.error(E), k = {
+      data: {}
+    };
+  }
+  const b = Re(() => import("./Right-Duk1k2Xj.js"), { ssr: !0 }), x = Re(() => import("./Logo-BxSWGm8n.js"), { ssr: !0 });
+  return /* @__PURE__ */ Q("div", { className: lt("sticky left-0 right-0 top-0 bg-background h-16 z-999", g), children: [
+    /* @__PURE__ */ Q("div", { className: "md:bg-module h-13 text-center flex flex-wrap justify-between items-center gap-2 px-4", children: [
+      /* @__PURE__ */ Q("div", { className: "flex items-center flex-1 gap-6", children: [
+        /* @__PURE__ */ Se(x, {}),
+        y
+      ] }),
+      /* @__PURE__ */ Se(b, { hideNews: _, hideLogin: d, user: (k == null ? void 0 : k.data) || {} })
+    ] }),
+    f
+  ] });
+}
+export {
+  It as H,
+  Pt as U,
+  $t as c,
+  qt as e,
+  Tt as o
+};