@moontra/moonui-pro 2.36.7 → 2.37.1

package/dist/server.mjs

@@ -0,0 +1,3158 @@
+import crypto from 'crypto';
+
+/**
+ * @moontra/moonui-pro v2.0.9
+ * Premium UI components for MoonUI
+ * (c) 2025 MoonUI. All rights reserved.
+ * @license Commercial - https://moonui.dev/license
+ */
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/next/dist/compiled/@edge-runtime/cookies/index.js
+var require_cookies = __commonJS({
+  "../../node_modules/next/dist/compiled/@edge-runtime/cookies/index.js"(exports, module) {
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports = {};
+    __export(src_exports, {
+      RequestCookies: () => RequestCookies,
+      ResponseCookies: () => ResponseCookies,
+      parseCookie: () => parseCookie,
+      parseSetCookie: () => parseSetCookie,
+      stringifyCookie: () => stringifyCookie
+    });
+    module.exports = __toCommonJS(src_exports);
+    function stringifyCookie(c) {
+      var _a;
+      const attrs = [
+        "path" in c && c.path && `Path=${c.path}`,
+        "expires" in c && (c.expires || c.expires === 0) && `Expires=${(typeof c.expires === "number" ? new Date(c.expires) : c.expires).toUTCString()}`,
+        "maxAge" in c && typeof c.maxAge === "number" && `Max-Age=${c.maxAge}`,
+        "domain" in c && c.domain && `Domain=${c.domain}`,
+        "secure" in c && c.secure && "Secure",
+        "httpOnly" in c && c.httpOnly && "HttpOnly",
+        "sameSite" in c && c.sameSite && `SameSite=${c.sameSite}`,
+        "partitioned" in c && c.partitioned && "Partitioned",
+        "priority" in c && c.priority && `Priority=${c.priority}`
+      ].filter(Boolean);
+      const stringified = `${c.name}=${encodeURIComponent((_a = c.value) != null ? _a : "")}`;
+      return attrs.length === 0 ? stringified : `${stringified}; ${attrs.join("; ")}`;
+    }
+    function parseCookie(cookie) {
+      const map = /* @__PURE__ */ new Map();
+      for (const pair of cookie.split(/; */)) {
+        if (!pair)
+          continue;
+        const splitAt = pair.indexOf("=");
+        if (splitAt === -1) {
+          map.set(pair, "true");
+          continue;
+        }
+        const [key, value] = [pair.slice(0, splitAt), pair.slice(splitAt + 1)];
+        try {
+          map.set(key, decodeURIComponent(value != null ? value : "true"));
+        } catch {
+        }
+      }
+      return map;
+    }
+    function parseSetCookie(setCookie) {
+      if (!setCookie) {
+        return void 0;
+      }
+      const [[name, value], ...attributes] = parseCookie(setCookie);
+      const {
+        domain,
+        expires,
+        httponly,
+        maxage,
+        path,
+        samesite,
+        secure,
+        partitioned,
+        priority
+      } = Object.fromEntries(
+        attributes.map(([key, value2]) => [
+          key.toLowerCase().replace(/-/g, ""),
+          value2
+        ])
+      );
+      const cookie = {
+        name,
+        value: decodeURIComponent(value),
+        domain,
+        ...expires && { expires: new Date(expires) },
+        ...httponly && { httpOnly: true },
+        ...typeof maxage === "string" && { maxAge: Number(maxage) },
+        path,
+        ...samesite && { sameSite: parseSameSite(samesite) },
+        ...secure && { secure: true },
+        ...priority && { priority: parsePriority(priority) },
+        ...partitioned && { partitioned: true }
+      };
+      return compact(cookie);
+    }
+    function compact(t) {
+      const newT = {};
+      for (const key in t) {
+        if (t[key]) {
+          newT[key] = t[key];
+        }
+      }
+      return newT;
+    }
+    var SAME_SITE = ["strict", "lax", "none"];
+    function parseSameSite(string) {
+      string = string.toLowerCase();
+      return SAME_SITE.includes(string) ? string : void 0;
+    }
+    var PRIORITY = ["low", "medium", "high"];
+    function parsePriority(string) {
+      string = string.toLowerCase();
+      return PRIORITY.includes(string) ? string : void 0;
+    }
+    function splitCookiesString(cookiesString) {
+      if (!cookiesString)
+        return [];
+      var cookiesStrings = [];
+      var pos = 0;
+      var start;
+      var ch;
+      var lastComma;
+      var nextStart;
+      var cookiesSeparatorFound;
+      function skipWhitespace() {
+        while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+          pos += 1;
+        }
+        return pos < cookiesString.length;
+      }
+      function notSpecialChar() {
+        ch = cookiesString.charAt(pos);
+        return ch !== "=" && ch !== ";" && ch !== ",";
+      }
+      while (pos < cookiesString.length) {
+        start = pos;
+        cookiesSeparatorFound = false;
+        while (skipWhitespace()) {
+          ch = cookiesString.charAt(pos);
+          if (ch === ",") {
+            lastComma = pos;
+            pos += 1;
+            skipWhitespace();
+            nextStart = pos;
+            while (pos < cookiesString.length && notSpecialChar()) {
+              pos += 1;
+            }
+            if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+              cookiesSeparatorFound = true;
+              pos = nextStart;
+              cookiesStrings.push(cookiesString.substring(start, lastComma));
+              start = pos;
+            } else {
+              pos = lastComma + 1;
+            }
+          } else {
+            pos += 1;
+          }
+        }
+        if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+          cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+        }
+      }
+      return cookiesStrings;
+    }
+    var RequestCookies = class {
+      constructor(requestHeaders) {
+        this._parsed = /* @__PURE__ */ new Map();
+        this._headers = requestHeaders;
+        const header = requestHeaders.get("cookie");
+        if (header) {
+          const parsed = parseCookie(header);
+          for (const [name, value] of parsed) {
+            this._parsed.set(name, { name, value });
+          }
+        }
+      }
+      [Symbol.iterator]() {
+        return this._parsed[Symbol.iterator]();
+      }
+      /**
+       * The amount of cookies received from the client
+       */
+      get size() {
+        return this._parsed.size;
+      }
+      get(...args) {
+        const name = typeof args[0] === "string" ? args[0] : args[0].name;
+        return this._parsed.get(name);
+      }
+      getAll(...args) {
+        var _a;
+        const all = Array.from(this._parsed);
+        if (!args.length) {
+          return all.map(([_, value]) => value);
+        }
+        const name = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+        return all.filter(([n]) => n === name).map(([_, value]) => value);
+      }
+      has(name) {
+        return this._parsed.has(name);
+      }
+      set(...args) {
+        const [name, value] = args.length === 1 ? [args[0].name, args[0].value] : args;
+        const map = this._parsed;
+        map.set(name, { name, value });
+        this._headers.set(
+          "cookie",
+          Array.from(map).map(([_, value2]) => stringifyCookie(value2)).join("; ")
+        );
+        return this;
+      }
+      /**
+       * Delete the cookies matching the passed name or names in the request.
+       */
+      delete(names) {
+        const map = this._parsed;
+        const result = !Array.isArray(names) ? map.delete(names) : names.map((name) => map.delete(name));
+        this._headers.set(
+          "cookie",
+          Array.from(map).map(([_, value]) => stringifyCookie(value)).join("; ")
+        );
+        return result;
+      }
+      /**
+       * Delete all the cookies in the cookies in the request.
+       */
+      clear() {
+        this.delete(Array.from(this._parsed.keys()));
+        return 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((v) => `${v.name}=${encodeURIComponent(v.value)}`).join("; ");
+      }
+    };
+    var ResponseCookies = class {
+      constructor(responseHeaders) {
+        this._parsed = /* @__PURE__ */ new Map();
+        var _a, _b, _c;
+        this._headers = responseHeaders;
+        const setCookie = (_c = (_b = (_a = responseHeaders.getSetCookie) == null ? void 0 : _a.call(responseHeaders)) != null ? _b : responseHeaders.get("set-cookie")) != null ? _c : [];
+        const cookieStrings = Array.isArray(setCookie) ? setCookie : splitCookiesString(setCookie);
+        for (const cookieString of cookieStrings) {
+          const parsed = parseSetCookie(cookieString);
+          if (parsed)
+            this._parsed.set(parsed.name, parsed);
+        }
+      }
+      /**
+       * {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
+       */
+      get(...args) {
+        const key = typeof args[0] === "string" ? args[0] : args[0].name;
+        return this._parsed.get(key);
+      }
+      /**
+       * {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
+       */
+      getAll(...args) {
+        var _a;
+        const all = Array.from(this._parsed.values());
+        if (!args.length) {
+          return all;
+        }
+        const key = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
+        return all.filter((c) => c.name === key);
+      }
+      has(name) {
+        return this._parsed.has(name);
+      }
+      /**
+       * {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
+       */
+      set(...args) {
+        const [name, value, cookie] = args.length === 1 ? [args[0].name, args[0].value, args[0]] : args;
+        const map = this._parsed;
+        map.set(name, normalizeCookie({ name, value, ...cookie }));
+        replace(map, this._headers);
+        return this;
+      }
+      /**
+       * {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
+       */
+      delete(...args) {
+        const [name, options] = typeof args[0] === "string" ? [args[0]] : [args[0].name, args[0]];
+        return this.set({ ...options, name, 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(stringifyCookie).join("; ");
+      }
+    };
+    function replace(bag, headers2) {
+      headers2.delete("set-cookie");
+      for (const [, value] of bag) {
+        const serialized = stringifyCookie(value);
+        headers2.append("set-cookie", serialized);
+      }
+    }
+    function normalizeCookie(cookie = { name: "", value: "" }) {
+      if (typeof cookie.expires === "number") {
+        cookie.expires = new Date(cookie.expires);
+      }
+      if (cookie.maxAge) {
+        cookie.expires = new Date(Date.now() + cookie.maxAge * 1e3);
+      }
+      if (cookie.path === null || cookie.path === void 0) {
+        cookie.path = "/";
+      }
+      return cookie;
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/web/spec-extension/cookies.js
+var require_cookies2 = __commonJS({
+  "../../node_modules/next/dist/server/web/spec-extension/cookies.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      RequestCookies: function() {
+        return _cookies.RequestCookies;
+      },
+      ResponseCookies: function() {
+        return _cookies.ResponseCookies;
+      },
+      stringifyCookie: function() {
+        return _cookies.stringifyCookie;
+      }
+    });
+    var _cookies = require_cookies();
+  }
+});
+
+// ../../node_modules/next/dist/server/web/spec-extension/adapters/reflect.js
+var require_reflect = __commonJS({
+  "../../node_modules/next/dist/server/web/spec-extension/adapters/reflect.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "ReflectAdapter", {
+      enumerable: true,
+      get: function() {
+        return ReflectAdapter;
+      }
+    });
+    var ReflectAdapter = class {
+      static get(target, prop, receiver) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      static set(target, prop, value, receiver) {
+        return Reflect.set(target, prop, value, receiver);
+      }
+      static has(target, prop) {
+        return Reflect.has(target, prop);
+      }
+      static deleteProperty(target, prop) {
+        return Reflect.deleteProperty(target, prop);
+      }
+    };
+  }
+});
+
+// ../../node_modules/next/dist/server/app-render/async-local-storage.js
+var require_async_local_storage = __commonJS({
+  "../../node_modules/next/dist/server/app-render/async-local-storage.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      bindSnapshot: function() {
+        return bindSnapshot;
+      },
+      createAsyncLocalStorage: function() {
+        return createAsyncLocalStorage;
+      },
+      createSnapshot: function() {
+        return createSnapshot;
+      }
+    });
+    var sharedAsyncLocalStorageNotAvailableError = Object.defineProperty(new Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available"), "__NEXT_ERROR_CODE", {
+      value: "E504",
+      enumerable: false,
+      configurable: true
+    });
+    var FakeAsyncLocalStorage = class {
+      disable() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      getStore() {
+        return void 0;
+      }
+      run() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      exit() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      enterWith() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      static bind(fn) {
+        return fn;
+      }
+    };
+    var maybeGlobalAsyncLocalStorage = typeof globalThis !== "undefined" && globalThis.AsyncLocalStorage;
+    function createAsyncLocalStorage() {
+      if (maybeGlobalAsyncLocalStorage) {
+        return new maybeGlobalAsyncLocalStorage();
+      }
+      return new FakeAsyncLocalStorage();
+    }
+    function bindSnapshot(fn) {
+      if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.bind(fn);
+      }
+      return FakeAsyncLocalStorage.bind(fn);
+    }
+    function createSnapshot() {
+      if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.snapshot();
+      }
+      return function(fn, ...args) {
+        return fn(...args);
+      };
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/app-render/work-async-storage-instance.js
+var require_work_async_storage_instance = __commonJS({
+  "../../node_modules/next/dist/server/app-render/work-async-storage-instance.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "workAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return workAsyncStorageInstance;
+      }
+    });
+    var _asynclocalstorage = require_async_local_storage();
+    var workAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  }
+});
+
+// ../../node_modules/next/dist/server/app-render/work-async-storage.external.js
+var require_work_async_storage_external = __commonJS({
+  "../../node_modules/next/dist/server/app-render/work-async-storage.external.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "workAsyncStorage", {
+      enumerable: true,
+      get: function() {
+        return _workasyncstorageinstance.workAsyncStorageInstance;
+      }
+    });
+    var _workasyncstorageinstance = require_work_async_storage_instance();
+  }
+});
+
+// ../../node_modules/next/dist/server/app-render/work-unit-async-storage-instance.js
+var require_work_unit_async_storage_instance = __commonJS({
+  "../../node_modules/next/dist/server/app-render/work-unit-async-storage-instance.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "workUnitAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return workUnitAsyncStorageInstance;
+      }
+    });
+    var _asynclocalstorage = require_async_local_storage();
+    var workUnitAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  }
+});
+
+// ../../node_modules/next/dist/client/components/app-router-headers.js
+var require_app_router_headers = __commonJS({
+  "../../node_modules/next/dist/client/components/app-router-headers.js"(exports, module) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      ACTION_HEADER: function() {
+        return ACTION_HEADER;
+      },
+      FLIGHT_HEADERS: function() {
+        return FLIGHT_HEADERS;
+      },
+      NEXT_DID_POSTPONE_HEADER: function() {
+        return NEXT_DID_POSTPONE_HEADER;
+      },
+      NEXT_HMR_REFRESH_HASH_COOKIE: function() {
+        return NEXT_HMR_REFRESH_HASH_COOKIE;
+      },
+      NEXT_HMR_REFRESH_HEADER: function() {
+        return NEXT_HMR_REFRESH_HEADER;
+      },
+      NEXT_IS_PRERENDER_HEADER: function() {
+        return NEXT_IS_PRERENDER_HEADER;
+      },
+      NEXT_REWRITTEN_PATH_HEADER: function() {
+        return NEXT_REWRITTEN_PATH_HEADER;
+      },
+      NEXT_REWRITTEN_QUERY_HEADER: function() {
+        return NEXT_REWRITTEN_QUERY_HEADER;
+      },
+      NEXT_ROUTER_PREFETCH_HEADER: function() {
+        return NEXT_ROUTER_PREFETCH_HEADER;
+      },
+      NEXT_ROUTER_SEGMENT_PREFETCH_HEADER: function() {
+        return NEXT_ROUTER_SEGMENT_PREFETCH_HEADER;
+      },
+      NEXT_ROUTER_STALE_TIME_HEADER: function() {
+        return NEXT_ROUTER_STALE_TIME_HEADER;
+      },
+      NEXT_ROUTER_STATE_TREE_HEADER: function() {
+        return NEXT_ROUTER_STATE_TREE_HEADER;
+      },
+      NEXT_RSC_UNION_QUERY: function() {
+        return NEXT_RSC_UNION_QUERY;
+      },
+      NEXT_URL: function() {
+        return NEXT_URL;
+      },
+      RSC_CONTENT_TYPE_HEADER: function() {
+        return RSC_CONTENT_TYPE_HEADER;
+      },
+      RSC_HEADER: function() {
+        return RSC_HEADER;
+      }
+    });
+    var RSC_HEADER = "RSC";
+    var ACTION_HEADER = "Next-Action";
+    var NEXT_ROUTER_STATE_TREE_HEADER = "Next-Router-State-Tree";
+    var NEXT_ROUTER_PREFETCH_HEADER = "Next-Router-Prefetch";
+    var NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = "Next-Router-Segment-Prefetch";
+    var NEXT_HMR_REFRESH_HEADER = "Next-HMR-Refresh";
+    var NEXT_HMR_REFRESH_HASH_COOKIE = "__next_hmr_refresh_hash__";
+    var NEXT_URL = "Next-Url";
+    var RSC_CONTENT_TYPE_HEADER = "text/x-component";
+    var FLIGHT_HEADERS = [
+      RSC_HEADER,
+      NEXT_ROUTER_STATE_TREE_HEADER,
+      NEXT_ROUTER_PREFETCH_HEADER,
+      NEXT_HMR_REFRESH_HEADER,
+      NEXT_ROUTER_SEGMENT_PREFETCH_HEADER
+    ];
+    var NEXT_RSC_UNION_QUERY = "_rsc";
+    var NEXT_ROUTER_STALE_TIME_HEADER = "x-nextjs-stale-time";
+    var NEXT_DID_POSTPONE_HEADER = "x-nextjs-postponed";
+    var NEXT_REWRITTEN_PATH_HEADER = "x-nextjs-rewritten-path";
+    var NEXT_REWRITTEN_QUERY_HEADER = "x-nextjs-rewritten-query";
+    var NEXT_IS_PRERENDER_HEADER = "x-nextjs-prerender";
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/app-render/work-unit-async-storage.external.js
+var require_work_unit_async_storage_external = __commonJS({
+  "../../node_modules/next/dist/server/app-render/work-unit-async-storage.external.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      getDraftModeProviderForCacheScope: function() {
+        return getDraftModeProviderForCacheScope;
+      },
+      getExpectedRequestStore: function() {
+        return getExpectedRequestStore;
+      },
+      getHmrRefreshHash: function() {
+        return getHmrRefreshHash;
+      },
+      getPrerenderResumeDataCache: function() {
+        return getPrerenderResumeDataCache;
+      },
+      getRenderResumeDataCache: function() {
+        return getRenderResumeDataCache;
+      },
+      throwForMissingRequestStore: function() {
+        return throwForMissingRequestStore;
+      },
+      workUnitAsyncStorage: function() {
+        return _workunitasyncstorageinstance.workUnitAsyncStorageInstance;
+      }
+    });
+    var _workunitasyncstorageinstance = require_work_unit_async_storage_instance();
+    var _approuterheaders = require_app_router_headers();
+    function getExpectedRequestStore(callingExpression) {
+      const workUnitStore = _workunitasyncstorageinstance.workUnitAsyncStorageInstance.getStore();
+      if (!workUnitStore) {
+        throwForMissingRequestStore(callingExpression);
+      }
+      switch (workUnitStore.type) {
+        case "request":
+          return workUnitStore;
+        case "prerender":
+        case "prerender-ppr":
+        case "prerender-legacy":
+          throw Object.defineProperty(new Error(`\`${callingExpression}\` cannot be called inside a prerender. This is a bug in Next.js.`), "__NEXT_ERROR_CODE", {
+            value: "E401",
+            enumerable: false,
+            configurable: true
+          });
+        case "cache":
+          throw Object.defineProperty(new Error(`\`${callingExpression}\` 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`), "__NEXT_ERROR_CODE", {
+            value: "E37",
+            enumerable: false,
+            configurable: true
+          });
+        case "unstable-cache":
+          throw Object.defineProperty(new Error(`\`${callingExpression}\` 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`), "__NEXT_ERROR_CODE", {
+            value: "E69",
+            enumerable: false,
+            configurable: true
+          });
+        default:
+          const _exhaustiveCheck = workUnitStore;
+          return _exhaustiveCheck;
+      }
+    }
+    function throwForMissingRequestStore(callingExpression) {
+      throw Object.defineProperty(new Error(`\`${callingExpression}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
+        value: "E251",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function getPrerenderResumeDataCache(workUnitStore) {
+      if (workUnitStore.type === "prerender" || workUnitStore.type === "prerender-ppr") {
+        return workUnitStore.prerenderResumeDataCache;
+      }
+      return null;
+    }
+    function getRenderResumeDataCache(workUnitStore) {
+      if (workUnitStore.type !== "prerender-legacy" && workUnitStore.type !== "cache" && workUnitStore.type !== "unstable-cache") {
+        if (workUnitStore.type === "request") {
+          return workUnitStore.renderResumeDataCache;
+        }
+        return workUnitStore.prerenderResumeDataCache;
+      }
+      return null;
+    }
+    function getHmrRefreshHash(workStore, workUnitStore) {
+      var _workUnitStore_cookies_get;
+      if (!workStore.dev) {
+        return void 0;
+      }
+      return workUnitStore.type === "cache" || workUnitStore.type === "prerender" ? workUnitStore.hmrRefreshHash : workUnitStore.type === "request" ? (_workUnitStore_cookies_get = workUnitStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _workUnitStore_cookies_get.value : void 0;
+    }
+    function getDraftModeProviderForCacheScope(workStore, workUnitStore) {
+      if (workStore.isDraftMode) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "unstable-cache":
+          case "request":
+            return workUnitStore.draftMode;
+          default:
+            return void 0;
+        }
+      }
+      return void 0;
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js
+var require_request_cookies = __commonJS({
+  "../../node_modules/next/dist/server/web/spec-extension/adapters/request-cookies.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      MutableRequestCookiesAdapter: function() {
+        return MutableRequestCookiesAdapter;
+      },
+      ReadonlyRequestCookiesError: function() {
+        return ReadonlyRequestCookiesError;
+      },
+      RequestCookiesAdapter: function() {
+        return RequestCookiesAdapter;
+      },
+      appendMutableCookies: function() {
+        return appendMutableCookies;
+      },
+      areCookiesMutableInCurrentPhase: function() {
+        return areCookiesMutableInCurrentPhase;
+      },
+      getModifiedCookieValues: function() {
+        return getModifiedCookieValues;
+      },
+      responseCookiesToRequestCookies: function() {
+        return responseCookiesToRequestCookies;
+      },
+      wrapWithMutableAccessCheck: function() {
+        return wrapWithMutableAccessCheck;
+      }
+    });
+    var _cookies = require_cookies2();
+    var _reflect = require_reflect();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var ReadonlyRequestCookiesError = class 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 ReadonlyRequestCookiesError();
+      }
+    };
+    var RequestCookiesAdapter = class {
+      static seal(cookies2) {
+        return new Proxy(cookies2, {
+          get(target, prop, receiver) {
+            switch (prop) {
+              case "clear":
+              case "delete":
+              case "set":
+                return ReadonlyRequestCookiesError.callable;
+              default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+          }
+        });
+      }
+    };
+    var SYMBOL_MODIFY_COOKIE_VALUES = Symbol.for("next.mutated.cookies");
+    function getModifiedCookieValues(cookies2) {
+      const modified = cookies2[SYMBOL_MODIFY_COOKIE_VALUES];
+      if (!modified || !Array.isArray(modified) || modified.length === 0) {
+        return [];
+      }
+      return modified;
+    }
+    function appendMutableCookies(headers2, mutableCookies) {
+      const modifiedCookieValues = getModifiedCookieValues(mutableCookies);
+      if (modifiedCookieValues.length === 0) {
+        return false;
+      }
+      const resCookies = new _cookies.ResponseCookies(headers2);
+      const returnedCookies = resCookies.getAll();
+      for (const cookie of modifiedCookieValues) {
+        resCookies.set(cookie);
+      }
+      for (const cookie of returnedCookies) {
+        resCookies.set(cookie);
+      }
+      return true;
+    }
+    var MutableRequestCookiesAdapter = class {
+      static wrap(cookies2, onUpdateCookies) {
+        const responseCookies = new _cookies.ResponseCookies(new Headers());
+        for (const cookie of cookies2.getAll()) {
+          responseCookies.set(cookie);
+        }
+        let modifiedValues = [];
+        const modifiedCookies = /* @__PURE__ */ new Set();
+        const updateResponseCookies = () => {
+          const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+          if (workStore) {
+            workStore.pathWasRevalidated = true;
+          }
+          const allCookies = responseCookies.getAll();
+          modifiedValues = allCookies.filter((c) => modifiedCookies.has(c.name));
+          if (onUpdateCookies) {
+            const serializedCookies = [];
+            for (const cookie of modifiedValues) {
+              const tempCookies = new _cookies.ResponseCookies(new Headers());
+              tempCookies.set(cookie);
+              serializedCookies.push(tempCookies.toString());
+            }
+            onUpdateCookies(serializedCookies);
+          }
+        };
+        const wrappedCookies = new Proxy(responseCookies, {
+          get(target, prop, receiver) {
+            switch (prop) {
+              case SYMBOL_MODIFY_COOKIE_VALUES:
+                return modifiedValues;
+              case "delete":
+                return function(...args) {
+                  modifiedCookies.add(typeof args[0] === "string" ? args[0] : args[0].name);
+                  try {
+                    target.delete(...args);
+                    return wrappedCookies;
+                  } finally {
+                    updateResponseCookies();
+                  }
+                };
+              case "set":
+                return function(...args) {
+                  modifiedCookies.add(typeof args[0] === "string" ? args[0] : args[0].name);
+                  try {
+                    target.set(...args);
+                    return wrappedCookies;
+                  } finally {
+                    updateResponseCookies();
+                  }
+                };
+              default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+          }
+        });
+        return wrappedCookies;
+      }
+    };
+    function wrapWithMutableAccessCheck(responseCookies) {
+      const wrappedCookies = new Proxy(responseCookies, {
+        get(target, prop, receiver) {
+          switch (prop) {
+            case "delete":
+              return function(...args) {
+                ensureCookiesAreStillMutable("cookies().delete");
+                target.delete(...args);
+                return wrappedCookies;
+              };
+            case "set":
+              return function(...args) {
+                ensureCookiesAreStillMutable("cookies().set");
+                target.set(...args);
+                return wrappedCookies;
+              };
+            default:
+              return _reflect.ReflectAdapter.get(target, prop, receiver);
+          }
+        }
+      });
+      return wrappedCookies;
+    }
+    function areCookiesMutableInCurrentPhase(requestStore) {
+      return requestStore.phase === "action";
+    }
+    function ensureCookiesAreStillMutable(callingExpression) {
+      const requestStore = (0, _workunitasyncstorageexternal.getExpectedRequestStore)(callingExpression);
+      if (!areCookiesMutableInCurrentPhase(requestStore)) {
+        throw new ReadonlyRequestCookiesError();
+      }
+    }
+    function responseCookiesToRequestCookies(responseCookies) {
+      const requestCookies = new _cookies.RequestCookies(new Headers());
+      for (const cookie of responseCookies.getAll()) {
+        requestCookies.set(cookie);
+      }
+      return requestCookies;
+    }
+  }
+});
+
+// ../../node_modules/next/dist/client/components/hooks-server-context.js
+var require_hooks_server_context = __commonJS({
+  "../../node_modules/next/dist/client/components/hooks-server-context.js"(exports, module) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      DynamicServerError: function() {
+        return DynamicServerError;
+      },
+      isDynamicServerError: function() {
+        return isDynamicServerError;
+      }
+    });
+    var DYNAMIC_ERROR_CODE = "DYNAMIC_SERVER_USAGE";
+    var DynamicServerError = class extends Error {
+      constructor(description) {
+        super("Dynamic server usage: " + description), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
+      }
+    };
+    function isDynamicServerError(err) {
+      if (typeof err !== "object" || err === null || !("digest" in err) || typeof err.digest !== "string") {
+        return false;
+      }
+      return err.digest === DYNAMIC_ERROR_CODE;
+    }
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// ../../node_modules/next/dist/client/components/static-generation-bailout.js
+var require_static_generation_bailout = __commonJS({
+  "../../node_modules/next/dist/client/components/static-generation-bailout.js"(exports, module) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      StaticGenBailoutError: function() {
+        return StaticGenBailoutError;
+      },
+      isStaticGenBailoutError: function() {
+        return isStaticGenBailoutError;
+      }
+    });
+    var NEXT_STATIC_GEN_BAILOUT = "NEXT_STATIC_GEN_BAILOUT";
+    var StaticGenBailoutError = class extends Error {
+      constructor(...args) {
+        super(...args), this.code = NEXT_STATIC_GEN_BAILOUT;
+      }
+    };
+    function isStaticGenBailoutError(error) {
+      if (typeof error !== "object" || error === null || !("code" in error)) {
+        return false;
+      }
+      return error.code === NEXT_STATIC_GEN_BAILOUT;
+    }
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/dynamic-rendering-utils.js
+var require_dynamic_rendering_utils = __commonJS({
+  "../../node_modules/next/dist/server/dynamic-rendering-utils.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      isHangingPromiseRejectionError: function() {
+        return isHangingPromiseRejectionError;
+      },
+      makeHangingPromise: function() {
+        return makeHangingPromise;
+      }
+    });
+    function isHangingPromiseRejectionError(err) {
+      if (typeof err !== "object" || err === null || !("digest" in err)) {
+        return false;
+      }
+      return err.digest === HANGING_PROMISE_REJECTION;
+    }
+    var HANGING_PROMISE_REJECTION = "HANGING_PROMISE_REJECTION";
+    var HangingPromiseRejectionError = class extends Error {
+      constructor(expression) {
+        super(`During prerendering, ${expression} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${expression} 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.expression = expression, this.digest = HANGING_PROMISE_REJECTION;
+      }
+    };
+    var abortListenersBySignal = /* @__PURE__ */ new WeakMap();
+    function makeHangingPromise(signal, expression) {
+      if (signal.aborted) {
+        return Promise.reject(new HangingPromiseRejectionError(expression));
+      } else {
+        const hangingPromise = new Promise((_, reject) => {
+          const boundRejection = reject.bind(null, new HangingPromiseRejectionError(expression));
+          let currentListeners = abortListenersBySignal.get(signal);
+          if (currentListeners) {
+            currentListeners.push(boundRejection);
+          } else {
+            const listeners = [
+              boundRejection
+            ];
+            abortListenersBySignal.set(signal, listeners);
+            signal.addEventListener("abort", () => {
+              for (let i = 0; i < listeners.length; i++) {
+                listeners[i]();
+              }
+            }, {
+              once: true
+            });
+          }
+        });
+        hangingPromise.catch(ignoreReject);
+        return hangingPromise;
+      }
+    }
+    function ignoreReject() {
+    }
+  }
+});
+
+// ../../node_modules/next/dist/lib/metadata/metadata-constants.js
+var require_metadata_constants = __commonJS({
+  "../../node_modules/next/dist/lib/metadata/metadata-constants.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      METADATA_BOUNDARY_NAME: function() {
+        return METADATA_BOUNDARY_NAME;
+      },
+      OUTLET_BOUNDARY_NAME: function() {
+        return OUTLET_BOUNDARY_NAME;
+      },
+      VIEWPORT_BOUNDARY_NAME: function() {
+        return VIEWPORT_BOUNDARY_NAME;
+      }
+    });
+    var METADATA_BOUNDARY_NAME = "__next_metadata_boundary__";
+    var VIEWPORT_BOUNDARY_NAME = "__next_viewport_boundary__";
+    var OUTLET_BOUNDARY_NAME = "__next_outlet_boundary__";
+  }
+});
+
+// ../../node_modules/next/dist/lib/scheduler.js
+var require_scheduler = __commonJS({
+  "../../node_modules/next/dist/lib/scheduler.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      atLeastOneTask: function() {
+        return atLeastOneTask;
+      },
+      scheduleImmediate: function() {
+        return scheduleImmediate;
+      },
+      scheduleOnNextTick: function() {
+        return scheduleOnNextTick;
+      },
+      waitAtLeastOneReactRenderTask: function() {
+        return waitAtLeastOneReactRenderTask;
+      }
+    });
+    var scheduleOnNextTick = (cb) => {
+      Promise.resolve().then(() => {
+        if (process.env.NEXT_RUNTIME === "edge") {
+          setTimeout(cb, 0);
+        } else {
+          process.nextTick(cb);
+        }
+      });
+    };
+    var scheduleImmediate = (cb) => {
+      if (process.env.NEXT_RUNTIME === "edge") {
+        setTimeout(cb, 0);
+      } else {
+        setImmediate(cb);
+      }
+    };
+    function atLeastOneTask() {
+      return new Promise((resolve) => scheduleImmediate(resolve));
+    }
+    function waitAtLeastOneReactRenderTask() {
+      if (process.env.NEXT_RUNTIME === "edge") {
+        return new Promise((r) => setTimeout(r, 0));
+      } else {
+        return new Promise((r) => setImmediate(r));
+      }
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/app-render/dynamic-rendering.js
+var require_dynamic_rendering = __commonJS({
+  "../../node_modules/next/dist/server/app-render/dynamic-rendering.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      Postpone: function() {
+        return Postpone;
+      },
+      abortAndThrowOnSynchronousRequestDataAccess: function() {
+        return abortAndThrowOnSynchronousRequestDataAccess;
+      },
+      abortOnSynchronousPlatformIOAccess: function() {
+        return abortOnSynchronousPlatformIOAccess;
+      },
+      accessedDynamicData: function() {
+        return accessedDynamicData;
+      },
+      annotateDynamicAccess: function() {
+        return annotateDynamicAccess;
+      },
+      consumeDynamicAccess: function() {
+        return consumeDynamicAccess;
+      },
+      createDynamicTrackingState: function() {
+        return createDynamicTrackingState;
+      },
+      createDynamicValidationState: function() {
+        return createDynamicValidationState;
+      },
+      createHangingInputAbortSignal: function() {
+        return createHangingInputAbortSignal;
+      },
+      createPostponedAbortSignal: function() {
+        return createPostponedAbortSignal;
+      },
+      formatDynamicAPIAccesses: function() {
+        return formatDynamicAPIAccesses;
+      },
+      getFirstDynamicReason: function() {
+        return getFirstDynamicReason;
+      },
+      isDynamicPostpone: function() {
+        return isDynamicPostpone;
+      },
+      isPrerenderInterruptedError: function() {
+        return isPrerenderInterruptedError;
+      },
+      markCurrentScopeAsDynamic: function() {
+        return markCurrentScopeAsDynamic;
+      },
+      postponeWithTracking: function() {
+        return postponeWithTracking;
+      },
+      throwIfDisallowedDynamic: function() {
+        return throwIfDisallowedDynamic;
+      },
+      throwToInterruptStaticGeneration: function() {
+        return throwToInterruptStaticGeneration;
+      },
+      trackAllowedDynamicAccess: function() {
+        return trackAllowedDynamicAccess;
+      },
+      trackDynamicDataInDynamicRender: function() {
+        return trackDynamicDataInDynamicRender;
+      },
+      trackFallbackParamAccessed: function() {
+        return trackFallbackParamAccessed;
+      },
+      trackSynchronousPlatformIOAccessInDev: function() {
+        return trackSynchronousPlatformIOAccessInDev;
+      },
+      trackSynchronousRequestDataAccessInDev: function() {
+        return trackSynchronousRequestDataAccessInDev;
+      },
+      useDynamicRouteParams: function() {
+        return useDynamicRouteParams;
+      }
+    });
+    var _react = /* @__PURE__ */ _interop_require_default(__require("react"));
+    var _hooksservercontext = require_hooks_server_context();
+    var _staticgenerationbailout = require_static_generation_bailout();
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _dynamicrenderingutils = require_dynamic_rendering_utils();
+    var _metadataconstants = require_metadata_constants();
+    var _scheduler = require_scheduler();
+    function _interop_require_default(obj) {
+      return obj && obj.__esModule ? obj : {
+        default: obj
+      };
+    }
+    var hasPostpone = typeof _react.default.unstable_postpone === "function";
+    function createDynamicTrackingState(isDebugDynamicAccesses) {
+      return {
+        isDebugDynamicAccesses,
+        dynamicAccesses: [],
+        syncDynamicExpression: void 0,
+        syncDynamicErrorWithStack: null
+      };
+    }
+    function createDynamicValidationState() {
+      return {
+        hasSuspendedDynamic: false,
+        hasDynamicMetadata: false,
+        hasDynamicViewport: false,
+        hasSyncDynamicErrors: false,
+        dynamicErrors: []
+      };
+    }
+    function getFirstDynamicReason(trackingState) {
+      var _trackingState_dynamicAccesses_;
+      return (_trackingState_dynamicAccesses_ = trackingState.dynamicAccesses[0]) == null ? void 0 : _trackingState_dynamicAccesses_.expression;
+    }
+    function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
+      if (workUnitStore) {
+        if (workUnitStore.type === "cache" || workUnitStore.type === "unstable-cache") {
+          return;
+        }
+      }
+      if (store.forceDynamic || store.forceStatic)
+        return;
+      if (store.dynamicShouldError) {
+        throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${store.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+          value: "E553",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      if (workUnitStore) {
+        if (workUnitStore.type === "prerender-ppr") {
+          postponeWithTracking(store.route, expression, workUnitStore.dynamicTracking);
+        } else if (workUnitStore.type === "prerender-legacy") {
+          workUnitStore.revalidate = 0;
+          const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+            value: "E550",
+            enumerable: false,
+            configurable: true
+          });
+          store.dynamicUsageDescription = expression;
+          store.dynamicUsageStack = err.stack;
+          throw err;
+        } else if (workUnitStore && workUnitStore.type === "request") {
+          workUnitStore.usedDynamic = true;
+        }
+      }
+    }
+    function trackFallbackParamAccessed(store, expression) {
+      const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (!prerenderStore || prerenderStore.type !== "prerender-ppr")
+        return;
+      postponeWithTracking(store.route, expression, prerenderStore.dynamicTracking);
+    }
+    function throwToInterruptStaticGeneration(expression, store, prerenderStore) {
+      const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+        value: "E558",
+        enumerable: false,
+        configurable: true
+      });
+      prerenderStore.revalidate = 0;
+      store.dynamicUsageDescription = expression;
+      store.dynamicUsageStack = err.stack;
+      throw err;
+    }
+    function trackDynamicDataInDynamicRender(_store, workUnitStore) {
+      if (workUnitStore) {
+        if (workUnitStore.type === "cache" || workUnitStore.type === "unstable-cache") {
+          return;
+        }
+        if (workUnitStore.type === "prerender" || workUnitStore.type === "prerender-legacy") {
+          workUnitStore.revalidate = 0;
+        }
+        if (workUnitStore.type === "request") {
+          workUnitStore.usedDynamic = true;
+        }
+      }
+    }
+    function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore) {
+      const reason = `Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`;
+      const error = createPrerenderInterruptedError(reason);
+      prerenderStore.controller.abort(error);
+      const dynamicTracking = prerenderStore.dynamicTracking;
+      if (dynamicTracking) {
+        dynamicTracking.dynamicAccesses.push({
+          // When we aren't debugging, we don't need to create another error for the
+          // stack trace.
+          stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : void 0,
+          expression
+        });
+      }
+    }
+    function abortOnSynchronousPlatformIOAccess(route, expression, errorWithStack, prerenderStore) {
+      const dynamicTracking = prerenderStore.dynamicTracking;
+      if (dynamicTracking) {
+        if (dynamicTracking.syncDynamicErrorWithStack === null) {
+          dynamicTracking.syncDynamicExpression = expression;
+          dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
+        }
+      }
+      abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
+    }
+    function trackSynchronousPlatformIOAccessInDev(requestStore) {
+      requestStore.prerenderPhase = false;
+    }
+    function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWithStack, prerenderStore) {
+      const prerenderSignal = prerenderStore.controller.signal;
+      if (prerenderSignal.aborted === false) {
+        const dynamicTracking = prerenderStore.dynamicTracking;
+        if (dynamicTracking) {
+          if (dynamicTracking.syncDynamicErrorWithStack === null) {
+            dynamicTracking.syncDynamicExpression = expression;
+            dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
+            if (prerenderStore.validating === true) {
+              dynamicTracking.syncDynamicLogged = true;
+            }
+          }
+        }
+        abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
+      }
+      throw createPrerenderInterruptedError(`Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`);
+    }
+    var trackSynchronousRequestDataAccessInDev = trackSynchronousPlatformIOAccessInDev;
+    function Postpone({ reason, route }) {
+      const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      const dynamicTracking = prerenderStore && prerenderStore.type === "prerender-ppr" ? prerenderStore.dynamicTracking : null;
+      postponeWithTracking(route, reason, dynamicTracking);
+    }
+    function postponeWithTracking(route, expression, dynamicTracking) {
+      assertPostpone();
+      if (dynamicTracking) {
+        dynamicTracking.dynamicAccesses.push({
+          // When we aren't debugging, we don't need to create another error for the
+          // stack trace.
+          stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : void 0,
+          expression
+        });
+      }
+      _react.default.unstable_postpone(createPostponeReason(route, expression));
+    }
+    function createPostponeReason(route, expression) {
+      return `Route ${route} needs to bail out of prerendering at this point because it used ${expression}. 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 isDynamicPostpone(err) {
+      if (typeof err === "object" && err !== null && typeof err.message === "string") {
+        return isDynamicPostponeReason(err.message);
+      }
+      return false;
+    }
+    function isDynamicPostponeReason(reason) {
+      return reason.includes("needs to bail out of prerendering at this point because it used") && reason.includes("Learn more: https://nextjs.org/docs/messages/ppr-caught-error");
+    }
+    if (isDynamicPostponeReason(createPostponeReason("%%%", "^^^")) === false) {
+      throw Object.defineProperty(new Error("Invariant: isDynamicPostpone misidentified a postpone reason. This is a bug in Next.js"), "__NEXT_ERROR_CODE", {
+        value: "E296",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    var NEXT_PRERENDER_INTERRUPTED = "NEXT_PRERENDER_INTERRUPTED";
+    function createPrerenderInterruptedError(message) {
+      const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+      });
+      error.digest = NEXT_PRERENDER_INTERRUPTED;
+      return error;
+    }
+    function isPrerenderInterruptedError(error) {
+      return typeof error === "object" && error !== null && error.digest === NEXT_PRERENDER_INTERRUPTED && "name" in error && "message" in error && error instanceof Error;
+    }
+    function accessedDynamicData(dynamicAccesses) {
+      return dynamicAccesses.length > 0;
+    }
+    function consumeDynamicAccess(serverDynamic, clientDynamic) {
+      serverDynamic.dynamicAccesses.push(...clientDynamic.dynamicAccesses);
+      return serverDynamic.dynamicAccesses;
+    }
+    function formatDynamicAPIAccesses(dynamicAccesses) {
+      return dynamicAccesses.filter((access) => typeof access.stack === "string" && access.stack.length > 0).map(({ expression, stack }) => {
+        stack = stack.split("\n").slice(4).filter((line) => {
+          if (line.includes("node_modules/next/")) {
+            return false;
+          }
+          if (line.includes(" (<anonymous>)")) {
+            return false;
+          }
+          if (line.includes(" (node:")) {
+            return false;
+          }
+          return true;
+        }).join("\n");
+        return `Dynamic API Usage Debug - ${expression}:
+${stack}`;
+      });
+    }
+    function assertPostpone() {
+      if (!hasPostpone) {
+        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: false,
+          configurable: true
+        });
+      }
+    }
+    function createPostponedAbortSignal(reason) {
+      assertPostpone();
+      const controller = new AbortController();
+      try {
+        _react.default.unstable_postpone(reason);
+      } catch (x) {
+        controller.abort(x);
+      }
+      return controller.signal;
+    }
+    function createHangingInputAbortSignal(workUnitStore) {
+      const controller = new AbortController();
+      if (workUnitStore.cacheSignal) {
+        workUnitStore.cacheSignal.inputReady().then(() => {
+          controller.abort();
+        });
+      } else {
+        (0, _scheduler.scheduleOnNextTick)(() => controller.abort());
+      }
+      return controller.signal;
+    }
+    function annotateDynamicAccess(expression, prerenderStore) {
+      const dynamicTracking = prerenderStore.dynamicTracking;
+      if (dynamicTracking) {
+        dynamicTracking.dynamicAccesses.push({
+          stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : void 0,
+          expression
+        });
+      }
+    }
+    function useDynamicRouteParams(expression) {
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      if (workStore && workStore.isStaticGeneration && workStore.fallbackRouteParams && workStore.fallbackRouteParams.size > 0) {
+        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+        if (workUnitStore) {
+          if (workUnitStore.type === "prerender") {
+            _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, expression));
+          } else if (workUnitStore.type === "prerender-ppr") {
+            postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
+          } else if (workUnitStore.type === "prerender-legacy") {
+            throwToInterruptStaticGeneration(expression, workStore, workUnitStore);
+          }
+        }
+      }
+    }
+    var hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
+    var hasMetadataRegex = new RegExp(`\\n\\s+at ${_metadataconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
+    var hasViewportRegex = new RegExp(`\\n\\s+at ${_metadataconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
+    var hasOutletRegex = new RegExp(`\\n\\s+at ${_metadataconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
+    function trackAllowedDynamicAccess(route, componentStack, dynamicValidation, serverDynamic, clientDynamic) {
+      if (hasOutletRegex.test(componentStack)) {
+        return;
+      } else if (hasMetadataRegex.test(componentStack)) {
+        dynamicValidation.hasDynamicMetadata = true;
+        return;
+      } else if (hasViewportRegex.test(componentStack)) {
+        dynamicValidation.hasDynamicViewport = true;
+        return;
+      } else if (hasSuspenseRegex.test(componentStack)) {
+        dynamicValidation.hasSuspendedDynamic = true;
+        return;
+      } else if (serverDynamic.syncDynamicErrorWithStack || clientDynamic.syncDynamicErrorWithStack) {
+        dynamicValidation.hasSyncDynamicErrors = true;
+        return;
+      } else {
+        const message = `Route "${route}": 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`;
+        const error = createErrorWithComponentStack(message, componentStack);
+        dynamicValidation.dynamicErrors.push(error);
+        return;
+      }
+    }
+    function createErrorWithComponentStack(message, componentStack) {
+      const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+      });
+      error.stack = "Error: " + message + componentStack;
+      return error;
+    }
+    function throwIfDisallowedDynamic(route, dynamicValidation, serverDynamic, clientDynamic) {
+      let syncError;
+      let syncExpression;
+      let syncLogged;
+      if (serverDynamic.syncDynamicErrorWithStack) {
+        syncError = serverDynamic.syncDynamicErrorWithStack;
+        syncExpression = serverDynamic.syncDynamicExpression;
+        syncLogged = serverDynamic.syncDynamicLogged === true;
+      } else if (clientDynamic.syncDynamicErrorWithStack) {
+        syncError = clientDynamic.syncDynamicErrorWithStack;
+        syncExpression = clientDynamic.syncDynamicExpression;
+        syncLogged = clientDynamic.syncDynamicLogged === true;
+      } else {
+        syncError = null;
+        syncExpression = void 0;
+        syncLogged = false;
+      }
+      if (dynamicValidation.hasSyncDynamicErrors && syncError) {
+        if (!syncLogged) {
+          console.error(syncError);
+        }
+        throw new _staticgenerationbailout.StaticGenBailoutError();
+      }
+      const dynamicErrors = dynamicValidation.dynamicErrors;
+      if (dynamicErrors.length) {
+        for (let i = 0; i < dynamicErrors.length; i++) {
+          console.error(dynamicErrors[i]);
+        }
+        throw new _staticgenerationbailout.StaticGenBailoutError();
+      }
+      if (!dynamicValidation.hasSuspendedDynamic) {
+        if (dynamicValidation.hasDynamicMetadata) {
+          if (syncError) {
+            console.error(syncError);
+            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route "${route}" has a \`generateMetadata\` that could not finish rendering before ${syncExpression} was used. Follow the instructions in the error for this expression to resolve.`), "__NEXT_ERROR_CODE", {
+              value: "E608",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route "${route}" 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.`), "__NEXT_ERROR_CODE", {
+            value: "E534",
+            enumerable: false,
+            configurable: true
+          });
+        } else if (dynamicValidation.hasDynamicViewport) {
+          if (syncError) {
+            console.error(syncError);
+            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route "${route}" has a \`generateViewport\` that could not finish rendering before ${syncExpression} was used. Follow the instructions in the error for this expression to resolve.`), "__NEXT_ERROR_CODE", {
+              value: "E573",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route "${route}" 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.`), "__NEXT_ERROR_CODE", {
+            value: "E590",
+            enumerable: false,
+            configurable: true
+          });
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js
+var require_create_deduped_by_callsite_server_error_logger = __commonJS({
+  "../../node_modules/next/dist/server/create-deduped-by-callsite-server-error-logger.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "createDedupedByCallsiteServerErrorLoggerDev", {
+      enumerable: true,
+      get: function() {
+        return createDedupedByCallsiteServerErrorLoggerDev;
+      }
+    });
+    var _react = /* @__PURE__ */ _interop_require_wildcard(__require("react"));
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function")
+        return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interop_require_wildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+      }
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+          default: obj
+        };
+      }
+      var cache2 = _getRequireWildcardCache(nodeInterop);
+      if (cache2 && cache2.has(obj)) {
+        return cache2.get(obj);
+      }
+      var newObj = {
+        __proto__: null
+      };
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) {
+            Object.defineProperty(newObj, key, desc);
+          } else {
+            newObj[key] = obj[key];
+          }
+        }
+      }
+      newObj.default = obj;
+      if (cache2) {
+        cache2.set(obj, newObj);
+      }
+      return newObj;
+    }
+    var errorRef = {
+      current: null
+    };
+    var cache = typeof _react.cache === "function" ? _react.cache : (fn) => fn;
+    var logErrorOrWarn = process.env.__NEXT_DYNAMIC_IO ? console.error : console.warn;
+    var flushCurrentErrorIfNew = cache(
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- cache key
+      (key) => {
+        try {
+          logErrorOrWarn(errorRef.current);
+        } finally {
+          errorRef.current = null;
+        }
+      }
+    );
+    function createDedupedByCallsiteServerErrorLoggerDev(getMessage) {
+      return function logDedupedError(...args) {
+        const message = getMessage(...args);
+        {
+          var _stack;
+          const callStackFrames = (_stack = new Error().stack) == null ? void 0 : _stack.split("\n");
+          if (callStackFrames === void 0 || callStackFrames.length < 4) {
+            logErrorOrWarn(message);
+          } else {
+            const key = callStackFrames[4];
+            errorRef.current = message;
+            flushCurrentErrorIfNew(key);
+          }
+        }
+      };
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/app-render/after-task-async-storage-instance.js
+var require_after_task_async_storage_instance = __commonJS({
+  "../../node_modules/next/dist/server/app-render/after-task-async-storage-instance.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "afterTaskAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return afterTaskAsyncStorageInstance;
+      }
+    });
+    var _asynclocalstorage = require_async_local_storage();
+    var afterTaskAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  }
+});
+
+// ../../node_modules/next/dist/server/app-render/after-task-async-storage.external.js
+var require_after_task_async_storage_external = __commonJS({
+  "../../node_modules/next/dist/server/app-render/after-task-async-storage.external.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "afterTaskAsyncStorage", {
+      enumerable: true,
+      get: function() {
+        return _aftertaskasyncstorageinstance.afterTaskAsyncStorageInstance;
+      }
+    });
+    var _aftertaskasyncstorageinstance = require_after_task_async_storage_instance();
+  }
+});
+
+// ../../node_modules/next/dist/server/request/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/next/dist/server/request/utils.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      isRequestAPICallableInsideAfter: function() {
+        return isRequestAPICallableInsideAfter;
+      },
+      throwForSearchParamsAccessInUseCache: function() {
+        return throwForSearchParamsAccessInUseCache;
+      },
+      throwWithStaticGenerationBailoutError: function() {
+        return throwWithStaticGenerationBailoutError;
+      },
+      throwWithStaticGenerationBailoutErrorWithDynamicError: function() {
+        return throwWithStaticGenerationBailoutErrorWithDynamicError;
+      }
+    });
+    var _staticgenerationbailout = require_static_generation_bailout();
+    var _aftertaskasyncstorageexternal = require_after_task_async_storage_external();
+    function throwWithStaticGenerationBailoutError(route, expression) {
+      throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+        value: "E576",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function throwWithStaticGenerationBailoutErrorWithDynamicError(route, expression) {
+      throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} with \`dynamic = "error"\` couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+        value: "E543",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function throwForSearchParamsAccessInUseCache(workStore) {
+      const error = Object.defineProperty(new Error(`Route ${workStore.route} used "searchParams" inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use "searchParams" 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: "E634",
+        enumerable: false,
+        configurable: true
+      });
+      workStore.invalidUsageError ?? (workStore.invalidUsageError = error);
+      throw error;
+    }
+    function isRequestAPICallableInsideAfter() {
+      const afterTaskStore = _aftertaskasyncstorageexternal.afterTaskAsyncStorage.getStore();
+      return (afterTaskStore == null ? void 0 : afterTaskStore.rootTaskSpawnPhase) === "action";
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/request/cookies.js
+var require_cookies3 = __commonJS({
+  "../../node_modules/next/dist/server/request/cookies.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "cookies", {
+      enumerable: true,
+      get: function() {
+        return cookies2;
+      }
+    });
+    var _requestcookies = require_request_cookies();
+    var _cookies = require_cookies2();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var _dynamicrendering = require_dynamic_rendering();
+    var _staticgenerationbailout = require_static_generation_bailout();
+    var _dynamicrenderingutils = require_dynamic_rendering_utils();
+    var _creatededupedbycallsiteservererrorlogger = require_create_deduped_by_callsite_server_error_logger();
+    var _scheduler = require_scheduler();
+    var _utils = require_utils();
+    function cookies2() {
+      const callingExpression = "cookies";
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workStore) {
+        if (workUnitStore && workUnitStore.phase === "after" && !(0, _utils.isRequestAPICallableInsideAfter)()) {
+          throw Object.defineProperty(new Error(
+            // TODO(after): clarify that this only applies to pages?
+            `Route ${workStore.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: "E88",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workStore.forceStatic) {
+          const underlyingCookies2 = createEmptyCookies();
+          return makeUntrackedExoticCookies(underlyingCookies2);
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "cache") {
+            throw Object.defineProperty(new Error(`Route ${workStore.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: "E398",
+              enumerable: false,
+              configurable: true
+            });
+          } else if (workUnitStore.type === "unstable-cache") {
+            throw Object.defineProperty(new Error(`Route ${workStore.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: "E157",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        }
+        if (workStore.dynamicShouldError) {
+          throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.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: "E549",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "prerender") {
+            return makeDynamicallyTrackedExoticCookies(workStore.route, workUnitStore);
+          } else if (workUnitStore.type === "prerender-ppr") {
+            (0, _dynamicrendering.postponeWithTracking)(workStore.route, callingExpression, workUnitStore.dynamicTracking);
+          } else if (workUnitStore.type === "prerender-legacy") {
+            (0, _dynamicrendering.throwToInterruptStaticGeneration)(callingExpression, workStore, workUnitStore);
+          }
+        }
+        (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workStore, workUnitStore);
+      }
+      const requestStore = (0, _workunitasyncstorageexternal.getExpectedRequestStore)(callingExpression);
+      let underlyingCookies;
+      if ((0, _requestcookies.areCookiesMutableInCurrentPhase)(requestStore)) {
+        underlyingCookies = requestStore.userspaceMutableCookies;
+      } else {
+        underlyingCookies = requestStore.cookies;
+      }
+      if (!(workStore == null ? void 0 : workStore.isPrefetchRequest)) {
+        return makeUntrackedExoticCookiesWithDevWarnings(underlyingCookies, workStore == null ? void 0 : workStore.route);
+      } else {
+        return makeUntrackedExoticCookies(underlyingCookies);
+      }
+    }
+    function createEmptyCookies() {
+      return _requestcookies.RequestCookiesAdapter.seal(new _cookies.RequestCookies(new Headers({})));
+    }
+    var CachedCookies = /* @__PURE__ */ new WeakMap();
+    function makeDynamicallyTrackedExoticCookies(route, prerenderStore) {
+      const cachedPromise = CachedCookies.get(prerenderStore);
+      if (cachedPromise) {
+        return cachedPromise;
+      }
+      const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, "`cookies()`");
+      CachedCookies.set(prerenderStore, promise);
+      Object.defineProperties(promise, {
+        [Symbol.iterator]: {
+          value: function() {
+            const expression = "`cookies()[Symbol.iterator]()`";
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        size: {
+          get() {
+            const expression = "`cookies().size`";
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        get: {
+          value: function get() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().get()`";
+            } else {
+              expression = `\`cookies().get(${describeNameArg(arguments[0])})\``;
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        getAll: {
+          value: function getAll() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().getAll()`";
+            } else {
+              expression = `\`cookies().getAll(${describeNameArg(arguments[0])})\``;
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        has: {
+          value: function has() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().has()`";
+            } else {
+              expression = `\`cookies().has(${describeNameArg(arguments[0])})\``;
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        set: {
+          value: function set() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().set()`";
+            } else {
+              const arg = arguments[0];
+              if (arg) {
+                expression = `\`cookies().set(${describeNameArg(arg)}, ...)\``;
+              } else {
+                expression = "`cookies().set(...)`";
+              }
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        delete: {
+          value: function() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().delete()`";
+            } else if (arguments.length === 1) {
+              expression = `\`cookies().delete(${describeNameArg(arguments[0])})\``;
+            } else {
+              expression = `\`cookies().delete(${describeNameArg(arguments[0])}, ...)\``;
+            }
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        clear: {
+          value: function clear() {
+            const expression = "`cookies().clear()`";
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        toString: {
+          value: function toString() {
+            const expression = "`cookies().toString()`";
+            const error = createCookiesAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        }
+      });
+      return promise;
+    }
+    function makeUntrackedExoticCookies(underlyingCookies) {
+      const cachedCookies = CachedCookies.get(underlyingCookies);
+      if (cachedCookies) {
+        return cachedCookies;
+      }
+      const promise = Promise.resolve(underlyingCookies);
+      CachedCookies.set(underlyingCookies, promise);
+      Object.defineProperties(promise, {
+        [Symbol.iterator]: {
+          value: underlyingCookies[Symbol.iterator] ? underlyingCookies[Symbol.iterator].bind(underlyingCookies) : (
+            // 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.
+            polyfilledResponseCookiesIterator.bind(underlyingCookies)
+          )
+        },
+        size: {
+          get() {
+            return underlyingCookies.size;
+          }
+        },
+        get: {
+          value: underlyingCookies.get.bind(underlyingCookies)
+        },
+        getAll: {
+          value: underlyingCookies.getAll.bind(underlyingCookies)
+        },
+        has: {
+          value: underlyingCookies.has.bind(underlyingCookies)
+        },
+        set: {
+          value: underlyingCookies.set.bind(underlyingCookies)
+        },
+        delete: {
+          value: underlyingCookies.delete.bind(underlyingCookies)
+        },
+        clear: {
+          value: (
+            // @ts-expect-error clear is defined in RequestCookies implementation but not in the type
+            typeof underlyingCookies.clear === "function" ? underlyingCookies.clear.bind(underlyingCookies) : (
+              // 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.
+              polyfilledResponseCookiesClear.bind(underlyingCookies, promise)
+            )
+          )
+        },
+        toString: {
+          value: underlyingCookies.toString.bind(underlyingCookies)
+        }
+      });
+      return promise;
+    }
+    function makeUntrackedExoticCookiesWithDevWarnings(underlyingCookies, route) {
+      const cachedCookies = CachedCookies.get(underlyingCookies);
+      if (cachedCookies) {
+        return cachedCookies;
+      }
+      const promise = new Promise((resolve) => (0, _scheduler.scheduleImmediate)(() => resolve(underlyingCookies)));
+      CachedCookies.set(underlyingCookies, promise);
+      Object.defineProperties(promise, {
+        [Symbol.iterator]: {
+          value: function() {
+            const expression = "`...cookies()` or similar iteration";
+            syncIODev(route, expression);
+            return underlyingCookies[Symbol.iterator] ? underlyingCookies[Symbol.iterator].apply(underlyingCookies, 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.
+              polyfilledResponseCookiesIterator.call(underlyingCookies)
+            );
+          },
+          writable: false
+        },
+        size: {
+          get() {
+            const expression = "`cookies().size`";
+            syncIODev(route, expression);
+            return underlyingCookies.size;
+          }
+        },
+        get: {
+          value: function get() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().get()`";
+            } else {
+              expression = `\`cookies().get(${describeNameArg(arguments[0])})\``;
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.get.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        getAll: {
+          value: function getAll() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().getAll()`";
+            } else {
+              expression = `\`cookies().getAll(${describeNameArg(arguments[0])})\``;
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.getAll.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        has: {
+          value: function get() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().has()`";
+            } else {
+              expression = `\`cookies().has(${describeNameArg(arguments[0])})\``;
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.has.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        set: {
+          value: function set() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().set()`";
+            } else {
+              const arg = arguments[0];
+              if (arg) {
+                expression = `\`cookies().set(${describeNameArg(arg)}, ...)\``;
+              } else {
+                expression = "`cookies().set(...)`";
+              }
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.set.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        delete: {
+          value: function() {
+            let expression;
+            if (arguments.length === 0) {
+              expression = "`cookies().delete()`";
+            } else if (arguments.length === 1) {
+              expression = `\`cookies().delete(${describeNameArg(arguments[0])})\``;
+            } else {
+              expression = `\`cookies().delete(${describeNameArg(arguments[0])}, ...)\``;
+            }
+            syncIODev(route, expression);
+            return underlyingCookies.delete.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        },
+        clear: {
+          value: function clear() {
+            const expression = "`cookies().clear()`";
+            syncIODev(route, expression);
+            return typeof underlyingCookies.clear === "function" ? underlyingCookies.clear.apply(underlyingCookies, 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.
+              polyfilledResponseCookiesClear.call(underlyingCookies, promise)
+            );
+          },
+          writable: false
+        },
+        toString: {
+          value: function toString() {
+            const expression = "`cookies().toString()` or implicit casting";
+            syncIODev(route, expression);
+            return underlyingCookies.toString.apply(underlyingCookies, arguments);
+          },
+          writable: false
+        }
+      });
+      return promise;
+    }
+    function describeNameArg(arg) {
+      return typeof arg === "object" && arg !== null && typeof arg.name === "string" ? `'${arg.name}'` : typeof arg === "string" ? `'${arg}'` : "...";
+    }
+    function syncIODev(route, expression) {
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workUnitStore && workUnitStore.type === "request" && workUnitStore.prerenderPhase === true) {
+        const requestStore = workUnitStore;
+        (0, _dynamicrendering.trackSynchronousRequestDataAccessInDev)(requestStore);
+      }
+      warnForSyncAccess(route, expression);
+    }
+    var warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createCookiesAccessError);
+    function createCookiesAccessError(route, expression) {
+      const prefix = route ? `Route "${route}" ` : "This route ";
+      return Object.defineProperty(new Error(`${prefix}used ${expression}. \`cookies()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E223",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function polyfilledResponseCookiesIterator() {
+      return this.getAll().map((c) => [
+        c.name,
+        c
+      ]).values();
+    }
+    function polyfilledResponseCookiesClear(returnable) {
+      for (const cookie of this.getAll()) {
+        this.delete(cookie.name);
+      }
+      return returnable;
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/web/spec-extension/adapters/headers.js
+var require_headers = __commonJS({
+  "../../node_modules/next/dist/server/web/spec-extension/adapters/headers.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all)
+        Object.defineProperty(target, name, {
+          enumerable: true,
+          get: all[name]
+        });
+    }
+    _export(exports, {
+      HeadersAdapter: function() {
+        return HeadersAdapter;
+      },
+      ReadonlyHeadersError: function() {
+        return ReadonlyHeadersError;
+      }
+    });
+    var _reflect = require_reflect();
+    var ReadonlyHeadersError = class extends Error {
+      constructor() {
+        super("Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers");
+      }
+      static callable() {
+        throw new ReadonlyHeadersError();
+      }
+    };
+    var HeadersAdapter = class extends Headers {
+      constructor(headers2) {
+        super();
+        this.headers = new Proxy(headers2, {
+          get(target, prop, receiver) {
+            if (typeof prop === "symbol") {
+              return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+            const lowercased = prop.toLowerCase();
+            const original = Object.keys(headers2).find((o) => o.toLowerCase() === lowercased);
+            if (typeof original === "undefined")
+              return;
+            return _reflect.ReflectAdapter.get(target, original, receiver);
+          },
+          set(target, prop, value, receiver) {
+            if (typeof prop === "symbol") {
+              return _reflect.ReflectAdapter.set(target, prop, value, receiver);
+            }
+            const lowercased = prop.toLowerCase();
+            const original = Object.keys(headers2).find((o) => o.toLowerCase() === lowercased);
+            return _reflect.ReflectAdapter.set(target, original ?? prop, value, receiver);
+          },
+          has(target, prop) {
+            if (typeof prop === "symbol")
+              return _reflect.ReflectAdapter.has(target, prop);
+            const lowercased = prop.toLowerCase();
+            const original = Object.keys(headers2).find((o) => o.toLowerCase() === lowercased);
+            if (typeof original === "undefined")
+              return false;
+            return _reflect.ReflectAdapter.has(target, original);
+          },
+          deleteProperty(target, prop) {
+            if (typeof prop === "symbol")
+              return _reflect.ReflectAdapter.deleteProperty(target, prop);
+            const lowercased = prop.toLowerCase();
+            const original = Object.keys(headers2).find((o) => o.toLowerCase() === lowercased);
+            if (typeof original === "undefined")
+              return true;
+            return _reflect.ReflectAdapter.deleteProperty(target, original);
+          }
+        });
+      }
+      /**
+      * Seals a Headers instance to prevent modification by throwing an error when
+      * any mutating method is called.
+      */
+      static seal(headers2) {
+        return new Proxy(headers2, {
+          get(target, prop, receiver) {
+            switch (prop) {
+              case "append":
+              case "delete":
+              case "set":
+                return ReadonlyHeadersError.callable;
+              default:
+                return _reflect.ReflectAdapter.get(target, prop, receiver);
+            }
+          }
+        });
+      }
+      /**
+      * 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(value) {
+        if (Array.isArray(value))
+          return value.join(", ");
+        return value;
+      }
+      /**
+      * 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(headers2) {
+        if (headers2 instanceof Headers)
+          return headers2;
+        return new HeadersAdapter(headers2);
+      }
+      append(name, value) {
+        const existing = this.headers[name];
+        if (typeof existing === "string") {
+          this.headers[name] = [
+            existing,
+            value
+          ];
+        } else if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          this.headers[name] = value;
+        }
+      }
+      delete(name) {
+        delete this.headers[name];
+      }
+      get(name) {
+        const value = this.headers[name];
+        if (typeof value !== "undefined")
+          return this.merge(value);
+        return null;
+      }
+      has(name) {
+        return typeof this.headers[name] !== "undefined";
+      }
+      set(name, value) {
+        this.headers[name] = value;
+      }
+      forEach(callbackfn, thisArg) {
+        for (const [name, value] of this.entries()) {
+          callbackfn.call(thisArg, value, name, this);
+        }
+      }
+      *entries() {
+        for (const key of Object.keys(this.headers)) {
+          const name = key.toLowerCase();
+          const value = this.get(name);
+          yield [
+            name,
+            value
+          ];
+        }
+      }
+      *keys() {
+        for (const key of Object.keys(this.headers)) {
+          const name = key.toLowerCase();
+          yield name;
+        }
+      }
+      *values() {
+        for (const key of Object.keys(this.headers)) {
+          const value = this.get(key);
+          yield value;
+        }
+      }
+      [Symbol.iterator]() {
+        return this.entries();
+      }
+    };
+  }
+});
+
+// ../../node_modules/next/dist/server/request/headers.js
+var require_headers2 = __commonJS({
+  "../../node_modules/next/dist/server/request/headers.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "headers", {
+      enumerable: true,
+      get: function() {
+        return headers2;
+      }
+    });
+    var _headers = require_headers();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var _dynamicrendering = require_dynamic_rendering();
+    var _staticgenerationbailout = require_static_generation_bailout();
+    var _dynamicrenderingutils = require_dynamic_rendering_utils();
+    var _creatededupedbycallsiteservererrorlogger = require_create_deduped_by_callsite_server_error_logger();
+    var _scheduler = require_scheduler();
+    var _utils = require_utils();
+    function headers2() {
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workStore) {
+        if (workUnitStore && workUnitStore.phase === "after" && !(0, _utils.isRequestAPICallableInsideAfter)()) {
+          throw Object.defineProperty(new Error(`Route ${workStore.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: "E367",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workStore.forceStatic) {
+          const underlyingHeaders = _headers.HeadersAdapter.seal(new Headers({}));
+          return makeUntrackedExoticHeaders(underlyingHeaders);
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "cache") {
+            throw Object.defineProperty(new Error(`Route ${workStore.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: "E304",
+              enumerable: false,
+              configurable: true
+            });
+          } else if (workUnitStore.type === "unstable-cache") {
+            throw Object.defineProperty(new Error(`Route ${workStore.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: "E127",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        }
+        if (workStore.dynamicShouldError) {
+          throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.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: "E525",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "prerender") {
+            return makeDynamicallyTrackedExoticHeaders(workStore.route, workUnitStore);
+          } else if (workUnitStore.type === "prerender-ppr") {
+            (0, _dynamicrendering.postponeWithTracking)(workStore.route, "headers", workUnitStore.dynamicTracking);
+          } else if (workUnitStore.type === "prerender-legacy") {
+            (0, _dynamicrendering.throwToInterruptStaticGeneration)("headers", workStore, workUnitStore);
+          }
+        }
+        (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workStore, workUnitStore);
+      }
+      const requestStore = (0, _workunitasyncstorageexternal.getExpectedRequestStore)("headers");
+      if (!(workStore == null ? void 0 : workStore.isPrefetchRequest)) {
+        return makeUntrackedExoticHeadersWithDevWarnings(requestStore.headers, workStore == null ? void 0 : workStore.route);
+      } else {
+        return makeUntrackedExoticHeaders(requestStore.headers);
+      }
+    }
+    var CachedHeaders = /* @__PURE__ */ new WeakMap();
+    function makeDynamicallyTrackedExoticHeaders(route, prerenderStore) {
+      const cachedHeaders = CachedHeaders.get(prerenderStore);
+      if (cachedHeaders) {
+        return cachedHeaders;
+      }
+      const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, "`headers()`");
+      CachedHeaders.set(prerenderStore, promise);
+      Object.defineProperties(promise, {
+        append: {
+          value: function append() {
+            const expression = `\`headers().append(${describeNameArg(arguments[0])}, ...)\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        delete: {
+          value: function _delete() {
+            const expression = `\`headers().delete(${describeNameArg(arguments[0])})\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        get: {
+          value: function get() {
+            const expression = `\`headers().get(${describeNameArg(arguments[0])})\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        has: {
+          value: function has() {
+            const expression = `\`headers().has(${describeNameArg(arguments[0])})\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        set: {
+          value: function set() {
+            const expression = `\`headers().set(${describeNameArg(arguments[0])}, ...)\``;
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        getSetCookie: {
+          value: function getSetCookie() {
+            const expression = "`headers().getSetCookie()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        forEach: {
+          value: function forEach() {
+            const expression = "`headers().forEach(...)`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        keys: {
+          value: function keys() {
+            const expression = "`headers().keys()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        values: {
+          value: function values() {
+            const expression = "`headers().values()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        entries: {
+          value: function entries() {
+            const expression = "`headers().entries()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        },
+        [Symbol.iterator]: {
+          value: function() {
+            const expression = "`headers()[Symbol.iterator]()`";
+            const error = createHeadersAccessError(route, expression);
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(route, expression, error, prerenderStore);
+          }
+        }
+      });
+      return promise;
+    }
+    function makeUntrackedExoticHeaders(underlyingHeaders) {
+      const cachedHeaders = CachedHeaders.get(underlyingHeaders);
+      if (cachedHeaders) {
+        return cachedHeaders;
+      }
+      const promise = Promise.resolve(underlyingHeaders);
+      CachedHeaders.set(underlyingHeaders, promise);
+      Object.defineProperties(promise, {
+        append: {
+          value: underlyingHeaders.append.bind(underlyingHeaders)
+        },
+        delete: {
+          value: underlyingHeaders.delete.bind(underlyingHeaders)
+        },
+        get: {
+          value: underlyingHeaders.get.bind(underlyingHeaders)
+        },
+        has: {
+          value: underlyingHeaders.has.bind(underlyingHeaders)
+        },
+        set: {
+          value: underlyingHeaders.set.bind(underlyingHeaders)
+        },
+        getSetCookie: {
+          value: underlyingHeaders.getSetCookie.bind(underlyingHeaders)
+        },
+        forEach: {
+          value: underlyingHeaders.forEach.bind(underlyingHeaders)
+        },
+        keys: {
+          value: underlyingHeaders.keys.bind(underlyingHeaders)
+        },
+        values: {
+          value: underlyingHeaders.values.bind(underlyingHeaders)
+        },
+        entries: {
+          value: underlyingHeaders.entries.bind(underlyingHeaders)
+        },
+        [Symbol.iterator]: {
+          value: underlyingHeaders[Symbol.iterator].bind(underlyingHeaders)
+        }
+      });
+      return promise;
+    }
+    function makeUntrackedExoticHeadersWithDevWarnings(underlyingHeaders, route) {
+      const cachedHeaders = CachedHeaders.get(underlyingHeaders);
+      if (cachedHeaders) {
+        return cachedHeaders;
+      }
+      const promise = new Promise((resolve) => (0, _scheduler.scheduleImmediate)(() => resolve(underlyingHeaders)));
+      CachedHeaders.set(underlyingHeaders, promise);
+      Object.defineProperties(promise, {
+        append: {
+          value: function append() {
+            const expression = `\`headers().append(${describeNameArg(arguments[0])}, ...)\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.append.apply(underlyingHeaders, arguments);
+          }
+        },
+        delete: {
+          value: function _delete() {
+            const expression = `\`headers().delete(${describeNameArg(arguments[0])})\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.delete.apply(underlyingHeaders, arguments);
+          }
+        },
+        get: {
+          value: function get() {
+            const expression = `\`headers().get(${describeNameArg(arguments[0])})\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.get.apply(underlyingHeaders, arguments);
+          }
+        },
+        has: {
+          value: function has() {
+            const expression = `\`headers().has(${describeNameArg(arguments[0])})\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.has.apply(underlyingHeaders, arguments);
+          }
+        },
+        set: {
+          value: function set() {
+            const expression = `\`headers().set(${describeNameArg(arguments[0])}, ...)\``;
+            syncIODev(route, expression);
+            return underlyingHeaders.set.apply(underlyingHeaders, arguments);
+          }
+        },
+        getSetCookie: {
+          value: function getSetCookie() {
+            const expression = "`headers().getSetCookie()`";
+            syncIODev(route, expression);
+            return underlyingHeaders.getSetCookie.apply(underlyingHeaders, arguments);
+          }
+        },
+        forEach: {
+          value: function forEach() {
+            const expression = "`headers().forEach(...)`";
+            syncIODev(route, expression);
+            return underlyingHeaders.forEach.apply(underlyingHeaders, arguments);
+          }
+        },
+        keys: {
+          value: function keys() {
+            const expression = "`headers().keys()`";
+            syncIODev(route, expression);
+            return underlyingHeaders.keys.apply(underlyingHeaders, arguments);
+          }
+        },
+        values: {
+          value: function values() {
+            const expression = "`headers().values()`";
+            syncIODev(route, expression);
+            return underlyingHeaders.values.apply(underlyingHeaders, arguments);
+          }
+        },
+        entries: {
+          value: function entries() {
+            const expression = "`headers().entries()`";
+            syncIODev(route, expression);
+            return underlyingHeaders.entries.apply(underlyingHeaders, arguments);
+          }
+        },
+        [Symbol.iterator]: {
+          value: function() {
+            const expression = "`...headers()` or similar iteration";
+            syncIODev(route, expression);
+            return underlyingHeaders[Symbol.iterator].apply(underlyingHeaders, arguments);
+          }
+        }
+      });
+      return promise;
+    }
+    function describeNameArg(arg) {
+      return typeof arg === "string" ? `'${arg}'` : "...";
+    }
+    function syncIODev(route, expression) {
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workUnitStore && workUnitStore.type === "request" && workUnitStore.prerenderPhase === true) {
+        const requestStore = workUnitStore;
+        (0, _dynamicrendering.trackSynchronousRequestDataAccessInDev)(requestStore);
+      }
+      warnForSyncAccess(route, expression);
+    }
+    var warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createHeadersAccessError);
+    function createHeadersAccessError(route, expression) {
+      const prefix = route ? `Route "${route}" ` : "This route ";
+      return Object.defineProperty(new Error(`${prefix}used ${expression}. \`headers()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E277",
+        enumerable: false,
+        configurable: true
+      });
+    }
+  }
+});
+
+// ../../node_modules/next/dist/server/request/draft-mode.js
+var require_draft_mode = __commonJS({
+  "../../node_modules/next/dist/server/request/draft-mode.js"(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "draftMode", {
+      enumerable: true,
+      get: function() {
+        return draftMode;
+      }
+    });
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _dynamicrendering = require_dynamic_rendering();
+    var _creatededupedbycallsiteservererrorlogger = require_create_deduped_by_callsite_server_error_logger();
+    var _staticgenerationbailout = require_static_generation_bailout();
+    var _hooksservercontext = require_hooks_server_context();
+    function draftMode() {
+      const callingExpression = "draftMode";
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (!workStore || !workUnitStore) {
+        (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
+      }
+      switch (workUnitStore.type) {
+        case "request":
+          return createOrGetCachedExoticDraftMode(workUnitStore.draftMode, workStore);
+        case "cache":
+        case "unstable-cache":
+          const draftModeProvider = (0, _workunitasyncstorageexternal.getDraftModeProviderForCacheScope)(workStore, workUnitStore);
+          if (draftModeProvider) {
+            return createOrGetCachedExoticDraftMode(draftModeProvider, workStore);
+          }
+        case "prerender":
+        case "prerender-ppr":
+        case "prerender-legacy":
+          if (!(workStore == null ? void 0 : workStore.isPrefetchRequest)) {
+            const route = workStore == null ? void 0 : workStore.route;
+            return createExoticDraftModeWithDevWarnings(null, route);
+          } else {
+            return createExoticDraftMode(null);
+          }
+        default:
+          const _exhaustiveCheck = workUnitStore;
+          return _exhaustiveCheck;
+      }
+    }
+    function createOrGetCachedExoticDraftMode(draftModeProvider, workStore) {
+      const cachedDraftMode = CachedDraftModes.get(draftMode);
+      if (cachedDraftMode) {
+        return cachedDraftMode;
+      }
+      let promise;
+      if (!(workStore == null ? void 0 : workStore.isPrefetchRequest)) {
+        const route = workStore == null ? void 0 : workStore.route;
+        promise = createExoticDraftModeWithDevWarnings(draftModeProvider, route);
+      } else {
+        promise = createExoticDraftMode(draftModeProvider);
+      }
+      CachedDraftModes.set(draftModeProvider, promise);
+      return promise;
+    }
+    var CachedDraftModes = /* @__PURE__ */ new WeakMap();
+    function createExoticDraftMode(underlyingProvider) {
+      const instance = new DraftMode(underlyingProvider);
+      const promise = Promise.resolve(instance);
+      Object.defineProperty(promise, "isEnabled", {
+        get() {
+          return instance.isEnabled;
+        },
+        set(newValue) {
+          Object.defineProperty(promise, "isEnabled", {
+            value: newValue,
+            writable: true,
+            enumerable: true
+          });
+        },
+        enumerable: true,
+        configurable: true
+      });
+      promise.enable = instance.enable.bind(instance);
+      promise.disable = instance.disable.bind(instance);
+      return promise;
+    }
+    function createExoticDraftModeWithDevWarnings(underlyingProvider, route) {
+      const instance = new DraftMode(underlyingProvider);
+      const promise = Promise.resolve(instance);
+      Object.defineProperty(promise, "isEnabled", {
+        get() {
+          const expression = "`draftMode().isEnabled`";
+          syncIODev(route, expression);
+          return instance.isEnabled;
+        },
+        set(newValue) {
+          Object.defineProperty(promise, "isEnabled", {
+            value: newValue,
+            writable: true,
+            enumerable: true
+          });
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(promise, "enable", {
+        value: function get() {
+          const expression = "`draftMode().enable()`";
+          syncIODev(route, expression);
+          return instance.enable.apply(instance, arguments);
+        }
+      });
+      Object.defineProperty(promise, "disable", {
+        value: function get() {
+          const expression = "`draftMode().disable()`";
+          syncIODev(route, expression);
+          return instance.disable.apply(instance, arguments);
+        }
+      });
+      return promise;
+    }
+    var DraftMode = class {
+      constructor(provider) {
+        this._provider = provider;
+      }
+      get isEnabled() {
+        if (this._provider !== null) {
+          return this._provider.isEnabled;
+        }
+        return false;
+      }
+      enable() {
+        trackDynamicDraftMode("draftMode().enable()");
+        if (this._provider !== null) {
+          this._provider.enable();
+        }
+      }
+      disable() {
+        trackDynamicDraftMode("draftMode().disable()");
+        if (this._provider !== null) {
+          this._provider.disable();
+        }
+      }
+    };
+    function syncIODev(route, expression) {
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workUnitStore && workUnitStore.type === "request" && workUnitStore.prerenderPhase === true) {
+        const requestStore = workUnitStore;
+        (0, _dynamicrendering.trackSynchronousRequestDataAccessInDev)(requestStore);
+      }
+      warnForSyncAccess(route, expression);
+    }
+    var warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createDraftModeAccessError);
+    function createDraftModeAccessError(route, expression) {
+      const prefix = route ? `Route "${route}" ` : "This route ";
+      return Object.defineProperty(new Error(`${prefix}used ${expression}. \`draftMode()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E377",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function trackDynamicDraftMode(expression) {
+      const store = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (store) {
+        if (workUnitStore) {
+          if (workUnitStore.type === "cache") {
+            throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" 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: "E246",
+              enumerable: false,
+              configurable: true
+            });
+          } else if (workUnitStore.type === "unstable-cache") {
+            throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" 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: "E259",
+              enumerable: false,
+              configurable: true
+            });
+          } else if (workUnitStore.phase === "after") {
+            throw Object.defineProperty(new Error(`Route ${store.route} used "${expression}" 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: "E348",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        }
+        if (store.dynamicShouldError) {
+          throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${store.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+            value: "E553",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        if (workUnitStore) {
+          if (workUnitStore.type === "prerender") {
+            const error = Object.defineProperty(new Error(`Route ${store.route} used ${expression} without first calling \`await connection()\`. See more info here: https://nextjs.org/docs/messages/next-prerender-sync-headers`), "__NEXT_ERROR_CODE", {
+              value: "E126",
+              enumerable: false,
+              configurable: true
+            });
+            (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(store.route, expression, error, workUnitStore);
+          } else if (workUnitStore.type === "prerender-ppr") {
+            (0, _dynamicrendering.postponeWithTracking)(store.route, expression, workUnitStore.dynamicTracking);
+          } else if (workUnitStore.type === "prerender-legacy") {
+            workUnitStore.revalidate = 0;
+            const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+              value: "E558",
+              enumerable: false,
+              configurable: true
+            });
+            store.dynamicUsageDescription = expression;
+            store.dynamicUsageStack = err.stack;
+            throw err;
+          } else if (workUnitStore && workUnitStore.type === "request") {
+            workUnitStore.usedDynamic = true;
+          }
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/next/headers.js
+var require_headers3 = __commonJS({
+  "../../node_modules/next/headers.js"(exports, module) {
+    module.exports.cookies = require_cookies3().cookies;
+    module.exports.headers = require_headers2().headers;
+    module.exports.draftMode = require_draft_mode().draftMode;
+  }
+});
+
+// src/lib/server-auth.ts
+var import_headers = __toESM(require_headers3(), 1);
+
+// src/lib/auth-config.ts
+var IS_PRODUCTION = false;
+var AUTH_CONFIG = {
+  // Internal API endpoint (never external)
+  // Developers will implement this endpoint in their own project
+  internalEndpoint: "/api/moonui/validate-pro",
+  // Cache configuration
+  cache: {
+    // Server-side cache duration
+    serverCacheDuration: 60 * 60 * 1e3,
+    // 1 hour in development
+    // Cookie expiry
+    cookieMaxAge: 24 * 60 * 60,
+    // 1 day in development (seconds)
+    // Validation refresh threshold (when to refresh in background)
+    refreshThreshold: 0.5
+    // Refresh when 50% of cache time passed
+  },
+  // Security configuration
+  security: {
+    // Device fingerprint validation
+    enforceDeviceFingerprint: true,
+    // Maximum devices per license
+    maxDevicesPerLicense: 5,
+    // Session timeout
+    sessionTimeout: 7 * 24 * 60 * 60 * 1e3,
+    // 7 days
+    // Cookie settings
+    cookieOptions: {
+      httpOnly: true,
+      secure: IS_PRODUCTION,
+      sameSite: "lax",
+      path: "/"
+    }
+  },
+  // API configuration for server-to-server calls
+  api: {
+    // MoonUI validation server (only called from server-side)
+    moonuiValidationEndpoint: "https://api.moonui.dev/v1/license/validate",
+    // Timeout for server-to-server calls
+    timeout: 1e4,
+    // 10 seconds
+    // Retry configuration
+    retry: {
+      attempts: 1,
+      delay: 1e3
+      // 1 second between retries
+    }
+  },
+  // Cookie names
+  cookies: {
+    validation: "moonui_pro_validation",
+    session: "moonui_pro_session",
+    device: "moonui_pro_device"
+  },
+  // Header names for server communication
+  headers: {
+    validation: "x-moonui-pro-validation",
+    device: "x-moonui-device-id",
+    session: "x-moonui-session-id"
+  }
+};
+var ENCRYPTION_KEY = process.env.MOONUI_ENCRYPTION_KEY || "moonui-pro-default-key-change-in-production";
+function encryptData(data) {
+  const cipher = crypto.createCipher("aes-256-cbc", ENCRYPTION_KEY);
+  let encrypted = cipher.update(JSON.stringify(data), "utf8", "hex");
+  encrypted += cipher.final("hex");
+  return encrypted;
+}
+function decryptData(encryptedData) {
+  try {
+    const decipher = crypto.createDecipher("aes-256-cbc", ENCRYPTION_KEY);
+    let decrypted = decipher.update(encryptedData, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return JSON.parse(decrypted);
+  } catch (error) {
+    console.error("[Server Auth] Decryption failed:", error);
+    return null;
+  }
+}
+async function generateServerDeviceFingerprint() {
+  const headersList = await (0, import_headers.headers)();
+  const components = [
+    headersList.get("user-agent") || "unknown",
+    headersList.get("accept-language") || "unknown",
+    headersList.get("accept-encoding") || "unknown",
+    headersList.get("x-forwarded-for") || headersList.get("x-real-ip") || "unknown"
+  ];
+  const fingerprint = crypto.createHash("sha256").update(components.join("|")).digest("hex");
+  return fingerprint;
+}
+async function validateWithMoonUIServer(token, deviceId) {
+  try {
+    const response = await fetch(AUTH_CONFIG.api.moonuiValidationEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`,
+        "X-Device-ID": deviceId,
+        "X-API-Key": process.env.MOONUI_SERVER_API_KEY || ""
+      },
+      body: JSON.stringify({
+        token,
+        deviceId,
+        timestamp: Date.now()
+      }),
+      signal: AbortSignal.timeout(AUTH_CONFIG.api.timeout)
+    });
+    if (!response.ok) {
+      console.error("[Server Auth] Validation failed:", response.status);
+      return { valid: false, hasProAccess: false, error: "Validation failed" };
+    }
+    const data = await response.json();
+    return {
+      valid: data.valid,
+      hasProAccess: data.valid && (data.user?.hasLifetimeAccess || data.user?.features?.includes("pro_components") || false),
+      plan: data.user?.plan
+    };
+  } catch (error) {
+    console.error("[Server Auth] Server validation error:", error);
+    return {
+      valid: false,
+      hasProAccess: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function getValidationFromCookies() {
+  const cookieStore = await (0, import_headers.cookies)();
+  const validationCookie = cookieStore.get(AUTH_CONFIG.cookies.validation);
+  if (!validationCookie) {
+    return null;
+  }
+  const decrypted = decryptData(validationCookie.value);
+  if (!decrypted) {
+    return null;
+  }
+  const age = Date.now() - decrypted.timestamp;
+  if (age > AUTH_CONFIG.cache.serverCacheDuration) {
+    return null;
+  }
+  return decrypted;
+}
+async function setValidationInCookies(validation) {
+  const cookieStore = await (0, import_headers.cookies)();
+  const data = {
+    ...validation,
+    timestamp: Date.now()
+  };
+  const encrypted = encryptData(data);
+  cookieStore.set(
+    AUTH_CONFIG.cookies.validation,
+    encrypted,
+    {
+      ...AUTH_CONFIG.security.cookieOptions,
+      maxAge: AUTH_CONFIG.cache.cookieMaxAge
+    }
+  );
+}
+async function clearValidationCookies() {
+  const cookieStore = await (0, import_headers.cookies)();
+  cookieStore.delete(AUTH_CONFIG.cookies.validation);
+  cookieStore.delete(AUTH_CONFIG.cookies.session);
+  cookieStore.delete(AUTH_CONFIG.cookies.device);
+}
+async function performServerValidation() {
+  const cached = await getValidationFromCookies();
+  if (cached) {
+    console.log("[Server Auth] Using cached validation");
+    return { ...cached, cached: true };
+  }
+  const cookieStore = await (0, import_headers.cookies)();
+  const token = cookieStore.get("moonui_auth_token")?.value || process.env.MOONUI_LICENSE_KEY || "";
+  if (!token) {
+    console.log("[Server Auth] No token found");
+    return { valid: false, hasProAccess: false };
+  }
+  const deviceId = await generateServerDeviceFingerprint();
+  console.log("[Server Auth] Performing server validation...");
+  const result = await validateWithMoonUIServer(token, deviceId);
+  if (result.valid) {
+    await setValidationInCookies(result);
+  }
+  return { ...result, cached: false };
+}
+
+// src/server.ts
+if (typeof window !== "undefined") {
+  console.warn(
+    "[MoonUI Pro] Warning: Server utilities imported in client environment. These utilities should only be used in server components or API routes."
+  );
+}
+
+export { AUTH_CONFIG, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setValidationInCookies, validateWithMoonUIServer };