@nextblock-cms/db 0.0.1

package/server.es.js

@@ -0,0 +1,1161 @@
+import { r as re, b as j, d as $, e as N, m as ie, f as V, g as Y, h as ne, n as se, j as oe, k as G, o as ue, l as le, a as de } from "./invariant-error-Df4RSFOM.mjs";
+import { getErrorMessage as I } from "@nextblock-monorepo/utils";
+var fe = {}, F;
+function pe() {
+  if (F) return fe;
+  throw F = 1, new Error(
+    "This module cannot be imported from a Client Component module. It should only be used from a Server Component."
+  );
+}
+pe();
+var M = {}, T = {}, U = {}, K;
+function he() {
+  return K || (K = 1, function(y) {
+    Object.defineProperty(y, "__esModule", {
+      value: !0
+    });
+    function w(S, h) {
+      for (var m in h) Object.defineProperty(S, m, {
+        enumerable: !0,
+        get: h[m]
+      });
+    }
+    w(y, {
+      MutableRequestCookiesAdapter: function() {
+        return _;
+      },
+      ReadonlyRequestCookiesError: function() {
+        return s;
+      },
+      RequestCookiesAdapter: function() {
+        return i;
+      },
+      appendMutableCookies: function() {
+        return E;
+      },
+      areCookiesMutableInCurrentPhase: function() {
+        return x;
+      },
+      getModifiedCookieValues: function() {
+        return c;
+      },
+      responseCookiesToRequestCookies: function() {
+        return P;
+      },
+      wrapWithMutableAccessCheck: function() {
+        return k;
+      }
+    });
+    const d = re(), p = j(), g = $(), A = N();
+    class s 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 s();
+      }
+    }
+    class i {
+      static seal(h) {
+        return new Proxy(h, {
+          get(m, b, R) {
+            switch (b) {
+              case "clear":
+              case "delete":
+              case "set":
+                return s.callable;
+              default:
+                return p.ReflectAdapter.get(m, b, R);
+            }
+          }
+        });
+      }
+    }
+    const l = Symbol.for("next.mutated.cookies");
+    function c(S) {
+      const h = S[l];
+      return !h || !Array.isArray(h) || h.length === 0 ? [] : h;
+    }
+    function E(S, h) {
+      const m = c(h);
+      if (m.length === 0)
+        return !1;
+      const b = new d.ResponseCookies(S), R = b.getAll();
+      for (const o of m)
+        b.set(o);
+      for (const o of R)
+        b.set(o);
+      return !0;
+    }
+    class _ {
+      static wrap(h, m) {
+        const b = new d.ResponseCookies(new Headers());
+        for (const a of h.getAll())
+          b.set(a);
+        let R = [];
+        const o = /* @__PURE__ */ new Set(), e = () => {
+          const a = g.workAsyncStorage.getStore();
+          if (a && (a.pathWasRevalidated = !0), R = b.getAll().filter((t) => o.has(t.name)), m) {
+            const t = [];
+            for (const n of R) {
+              const u = new d.ResponseCookies(new Headers());
+              u.set(n), t.push(u.toString());
+            }
+            m(t);
+          }
+        }, r = new Proxy(b, {
+          get(a, f, t) {
+            switch (f) {
+              // A special symbol to get the modified cookie values
+              case l:
+                return R;
+              // TODO: Throw error if trying to set a cookie after the response
+              // headers have been set.
+              case "delete":
+                return function(...n) {
+                  o.add(typeof n[0] == "string" ? n[0] : n[0].name);
+                  try {
+                    return a.delete(...n), r;
+                  } finally {
+                    e();
+                  }
+                };
+              case "set":
+                return function(...n) {
+                  o.add(typeof n[0] == "string" ? n[0] : n[0].name);
+                  try {
+                    return a.set(...n), r;
+                  } finally {
+                    e();
+                  }
+                };
+              default:
+                return p.ReflectAdapter.get(a, f, t);
+            }
+          }
+        });
+        return r;
+      }
+    }
+    function k(S) {
+      const h = new Proxy(S, {
+        get(m, b, R) {
+          switch (b) {
+            case "delete":
+              return function(...o) {
+                return C("cookies().delete"), m.delete(...o), h;
+              };
+            case "set":
+              return function(...o) {
+                return C("cookies().set"), m.set(...o), h;
+              };
+            default:
+              return p.ReflectAdapter.get(m, b, R);
+          }
+        }
+      });
+      return h;
+    }
+    function x(S) {
+      return S.phase === "action";
+    }
+    function C(S) {
+      const h = (0, A.getExpectedRequestStore)(S);
+      if (!x(h))
+        throw new s();
+    }
+    function P(S) {
+      const h = new d.RequestCookies(new Headers());
+      for (const m of S.getAll())
+        h.set(m);
+      return h;
+    }
+  }(U)), U;
+}
+var L = {}, J;
+function z() {
+  return J || (J = 1, function(y) {
+    Object.defineProperty(y, "__esModule", {
+      value: !0
+    }), Object.defineProperty(y, "createDedupedByCallsiteServerErrorLoggerDev", {
+      enumerable: !0,
+      get: function() {
+        return l;
+      }
+    });
+    const w = /* @__PURE__ */ p(ie());
+    function d(c) {
+      if (typeof WeakMap != "function") return null;
+      var E = /* @__PURE__ */ new WeakMap(), _ = /* @__PURE__ */ new WeakMap();
+      return (d = function(k) {
+        return k ? _ : E;
+      })(c);
+    }
+    function p(c, E) {
+      if (c && c.__esModule)
+        return c;
+      if (c === null || typeof c != "object" && typeof c != "function")
+        return {
+          default: c
+        };
+      var _ = d(E);
+      if (_ && _.has(c))
+        return _.get(c);
+      var k = {
+        __proto__: null
+      }, x = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var C in c)
+        if (C !== "default" && Object.prototype.hasOwnProperty.call(c, C)) {
+          var P = x ? Object.getOwnPropertyDescriptor(c, C) : null;
+          P && (P.get || P.set) ? Object.defineProperty(k, C, P) : k[C] = c[C];
+        }
+      return k.default = c, _ && _.set(c, k), k;
+    }
+    const g = {
+      current: null
+    }, A = typeof w.cache == "function" ? w.cache : (c) => c, s = process.env.__NEXT_DYNAMIC_IO ? console.error : console.warn, i = A(
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- cache key
+      (c) => {
+        try {
+          s(g.current);
+        } finally {
+          g.current = null;
+        }
+      }
+    );
+    function l(c) {
+      return function(..._) {
+        const k = c(..._);
+        if (process.env.NODE_ENV !== "production") {
+          var x;
+          const C = (x = new Error().stack) == null ? void 0 : x.split(`
+`);
+          if (C === void 0 || C.length < 4)
+            s(k);
+          else {
+            const P = C[4];
+            g.current = k, i(P);
+          }
+        } else
+          s(k);
+      };
+    }
+  }(L)), L;
+}
+var Q;
+function be() {
+  return Q || (Q = 1, function(y) {
+    Object.defineProperty(y, "__esModule", {
+      value: !0
+    }), Object.defineProperty(y, "cookies", {
+      enumerable: !0,
+      get: function() {
+        return x;
+      }
+    });
+    const w = he(), d = re(), p = $(), g = N(), A = V(), s = Y(), i = ne(), l = z(), c = se(), E = oe(), _ = G(), k = j();
+    function x() {
+      const t = "cookies", n = p.workAsyncStorage.getStore(), u = g.workUnitAsyncStorage.getStore();
+      if (n) {
+        if (u && u.phase === "after" && !(0, E.isRequestAPICallableInsideAfter)())
+          throw Object.defineProperty(new Error(
+            // TODO(after): clarify that this only applies to pages?
+            `Route ${n.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: !1,
+            configurable: !0
+          });
+        if (n.forceStatic) {
+          const v = C();
+          return h(v);
+        }
+        if (u) {
+          if (u.type === "cache")
+            throw Object.defineProperty(new Error(`Route ${n.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: !1,
+              configurable: !0
+            });
+          if (u.type === "unstable-cache")
+            throw Object.defineProperty(new Error(`Route ${n.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: !1,
+              configurable: !0
+            });
+        }
+        if (n.dynamicShouldError)
+          throw Object.defineProperty(new s.StaticGenBailoutError(`Route ${n.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: !1,
+            configurable: !0
+          });
+        if (u)
+          switch (u.type) {
+            case "prerender":
+              return S(u);
+            case "prerender-client":
+              const v = "`cookies`";
+              throw Object.defineProperty(new _.InvariantError(`${v} must not be used within a client component. Next.js should be preventing ${v} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                value: "E693",
+                enumerable: !1,
+                configurable: !0
+              });
+            case "prerender-ppr":
+              (0, A.postponeWithTracking)(n.route, t, u.dynamicTracking);
+              break;
+            case "prerender-legacy":
+              (0, A.throwToInterruptStaticGeneration)(t, n, u);
+              break;
+          }
+        (0, A.trackDynamicDataInDynamicRender)(n, u);
+      }
+      const D = (0, g.getExpectedRequestStore)(t);
+      let O;
+      return (0, w.areCookiesMutableInCurrentPhase)(D) ? O = D.userspaceMutableCookies : O = D.cookies, process.env.NODE_ENV === "development" && !(n != null && n.isPrefetchRequest) ? process.env.__NEXT_DYNAMIC_IO ? b(O, n == null ? void 0 : n.route) : m(O, n == null ? void 0 : n.route) : h(O);
+    }
+    function C() {
+      return w.RequestCookiesAdapter.seal(new d.RequestCookies(new Headers({})));
+    }
+    const P = /* @__PURE__ */ new WeakMap();
+    function S(t) {
+      const n = P.get(t);
+      if (n)
+        return n;
+      const u = (0, i.makeHangingPromise)(t.renderSignal, "`cookies()`");
+      return P.set(t, u), u;
+    }
+    function h(t) {
+      const n = P.get(t);
+      if (n)
+        return n;
+      const u = Promise.resolve(t);
+      return P.set(t, u), Object.defineProperties(u, {
+        [Symbol.iterator]: {
+          value: t[Symbol.iterator] ? t[Symbol.iterator].bind(t) : (
+            // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+            // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+            // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+            // has extra properties not available on RequestCookie instances.
+            a.bind(t)
+          )
+        },
+        size: {
+          get() {
+            return t.size;
+          }
+        },
+        get: {
+          value: t.get.bind(t)
+        },
+        getAll: {
+          value: t.getAll.bind(t)
+        },
+        has: {
+          value: t.has.bind(t)
+        },
+        set: {
+          value: t.set.bind(t)
+        },
+        delete: {
+          value: t.delete.bind(t)
+        },
+        clear: {
+          value: (
+            // @ts-expect-error clear is defined in RequestCookies implementation but not in the type
+            typeof t.clear == "function" ? t.clear.bind(t) : (
+              // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+              // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+              // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+              // has extra properties not available on RequestCookie instances.
+              f.bind(t, u)
+            )
+          )
+        },
+        toString: {
+          value: t.toString.bind(t)
+        }
+      }), u;
+    }
+    function m(t, n) {
+      const u = P.get(t);
+      if (u)
+        return u;
+      const D = new Promise((O) => (0, c.scheduleImmediate)(() => O(t)));
+      return P.set(t, D), Object.defineProperties(D, {
+        [Symbol.iterator]: {
+          value: function() {
+            return o(n, "`...cookies()` or similar iteration"), t[Symbol.iterator] ? t[Symbol.iterator].apply(t, arguments) : (
+              // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+              // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+              // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+              // has extra properties not available on RequestCookie instances.
+              a.call(t)
+            );
+          },
+          writable: !1
+        },
+        size: {
+          get() {
+            return o(n, "`cookies().size`"), t.size;
+          }
+        },
+        get: {
+          value: function() {
+            let v;
+            return arguments.length === 0 ? v = "`cookies().get()`" : v = `\`cookies().get(${R(arguments[0])})\``, o(n, v), t.get.apply(t, arguments);
+          },
+          writable: !1
+        },
+        getAll: {
+          value: function() {
+            let v;
+            return arguments.length === 0 ? v = "`cookies().getAll()`" : v = `\`cookies().getAll(${R(arguments[0])})\``, o(n, v), t.getAll.apply(t, arguments);
+          },
+          writable: !1
+        },
+        has: {
+          value: function() {
+            let v;
+            return arguments.length === 0 ? v = "`cookies().has()`" : v = `\`cookies().has(${R(arguments[0])})\``, o(n, v), t.has.apply(t, arguments);
+          },
+          writable: !1
+        },
+        set: {
+          value: function() {
+            let v;
+            if (arguments.length === 0)
+              v = "`cookies().set()`";
+            else {
+              const q = arguments[0];
+              q ? v = `\`cookies().set(${R(q)}, ...)\`` : v = "`cookies().set(...)`";
+            }
+            return o(n, v), t.set.apply(t, arguments);
+          },
+          writable: !1
+        },
+        delete: {
+          value: function() {
+            let O;
+            return arguments.length === 0 ? O = "`cookies().delete()`" : arguments.length === 1 ? O = `\`cookies().delete(${R(arguments[0])})\`` : O = `\`cookies().delete(${R(arguments[0])}, ...)\``, o(n, O), t.delete.apply(t, arguments);
+          },
+          writable: !1
+        },
+        clear: {
+          value: function() {
+            return o(n, "`cookies().clear()`"), typeof t.clear == "function" ? t.clear.apply(t, arguments) : (
+              // We should remove this and unify our cookies types. We could just let this continue to throw lazily
+              // but that's already a hard thing to debug so we may as well implement it consistently. The biggest problem with
+              // implementing this in this way is the underlying cookie type is a ResponseCookie and not a RequestCookie and so it
+              // has extra properties not available on RequestCookie instances.
+              f.call(t, D)
+            );
+          },
+          writable: !1
+        },
+        toString: {
+          value: function() {
+            return o(n, "`cookies().toString()` or implicit casting"), t.toString.apply(t, arguments);
+          },
+          writable: !1
+        }
+      }), D;
+    }
+    function b(t, n) {
+      const u = P.get(t);
+      if (u)
+        return u;
+      const D = new Promise((v) => (0, c.scheduleImmediate)(() => v(t))), O = new Proxy(D, {
+        get(v, q, ce) {
+          switch (q) {
+            case Symbol.iterator: {
+              e(n, "`...cookies()` or similar iteration");
+              break;
+            }
+            case "size":
+            case "get":
+            case "getAll":
+            case "has":
+            case "set":
+            case "delete":
+            case "clear":
+            case "toString": {
+              e(n, `\`cookies().${q}\``);
+              break;
+            }
+          }
+          return k.ReflectAdapter.get(v, q, ce);
+        }
+      });
+      return P.set(t, O), O;
+    }
+    function R(t) {
+      return typeof t == "object" && t !== null && typeof t.name == "string" ? `'${t.name}'` : typeof t == "string" ? `'${t}'` : "...";
+    }
+    function o(t, n) {
+      const u = g.workUnitAsyncStorage.getStore();
+      if (u && u.type === "request" && u.prerenderPhase === !0) {
+        const D = u;
+        (0, A.trackSynchronousRequestDataAccessInDev)(D);
+      }
+      e(t, n);
+    }
+    const e = (0, l.createDedupedByCallsiteServerErrorLoggerDev)(r);
+    function r(t, n) {
+      const u = t ? `Route "${t}" ` : "This route ";
+      return Object.defineProperty(new Error(`${u}used ${n}. \`cookies()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E223",
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+    function a() {
+      return this.getAll().map((t) => [
+        t.name,
+        t
+      ]).values();
+    }
+    function f(t) {
+      for (const n of this.getAll())
+        this.delete(n.name);
+      return t;
+    }
+  }(T)), T;
+}
+var X = {}, W = {}, Z;
+function me() {
+  return Z || (Z = 1, function(y) {
+    Object.defineProperty(y, "__esModule", {
+      value: !0
+    });
+    function w(A, s) {
+      for (var i in s) Object.defineProperty(A, i, {
+        enumerable: !0,
+        get: s[i]
+      });
+    }
+    w(y, {
+      HeadersAdapter: function() {
+        return g;
+      },
+      ReadonlyHeadersError: function() {
+        return p;
+      }
+    });
+    const d = j();
+    class p extends Error {
+      constructor() {
+        super("Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers");
+      }
+      static callable() {
+        throw new p();
+      }
+    }
+    class g extends Headers {
+      constructor(s) {
+        super(), this.headers = new Proxy(s, {
+          get(i, l, c) {
+            if (typeof l == "symbol")
+              return d.ReflectAdapter.get(i, l, c);
+            const E = l.toLowerCase(), _ = Object.keys(s).find((k) => k.toLowerCase() === E);
+            if (!(typeof _ > "u"))
+              return d.ReflectAdapter.get(i, _, c);
+          },
+          set(i, l, c, E) {
+            if (typeof l == "symbol")
+              return d.ReflectAdapter.set(i, l, c, E);
+            const _ = l.toLowerCase(), k = Object.keys(s).find((x) => x.toLowerCase() === _);
+            return d.ReflectAdapter.set(i, k ?? l, c, E);
+          },
+          has(i, l) {
+            if (typeof l == "symbol") return d.ReflectAdapter.has(i, l);
+            const c = l.toLowerCase(), E = Object.keys(s).find((_) => _.toLowerCase() === c);
+            return typeof E > "u" ? !1 : d.ReflectAdapter.has(i, E);
+          },
+          deleteProperty(i, l) {
+            if (typeof l == "symbol") return d.ReflectAdapter.deleteProperty(i, l);
+            const c = l.toLowerCase(), E = Object.keys(s).find((_) => _.toLowerCase() === c);
+            return typeof E > "u" ? !0 : d.ReflectAdapter.deleteProperty(i, E);
+          }
+        });
+      }
+      /**
+      * Seals a Headers instance to prevent modification by throwing an error when
+      * any mutating method is called.
+      */
+      static seal(s) {
+        return new Proxy(s, {
+          get(i, l, c) {
+            switch (l) {
+              case "append":
+              case "delete":
+              case "set":
+                return p.callable;
+              default:
+                return d.ReflectAdapter.get(i, l, c);
+            }
+          }
+        });
+      }
+      /**
+      * 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(s) {
+        return Array.isArray(s) ? s.join(", ") : s;
+      }
+      /**
+      * 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(s) {
+        return s instanceof Headers ? s : new g(s);
+      }
+      append(s, i) {
+        const l = this.headers[s];
+        typeof l == "string" ? this.headers[s] = [
+          l,
+          i
+        ] : Array.isArray(l) ? l.push(i) : this.headers[s] = i;
+      }
+      delete(s) {
+        delete this.headers[s];
+      }
+      get(s) {
+        const i = this.headers[s];
+        return typeof i < "u" ? this.merge(i) : null;
+      }
+      has(s) {
+        return typeof this.headers[s] < "u";
+      }
+      set(s, i) {
+        this.headers[s] = i;
+      }
+      forEach(s, i) {
+        for (const [l, c] of this.entries())
+          s.call(i, c, l, this);
+      }
+      *entries() {
+        for (const s of Object.keys(this.headers)) {
+          const i = s.toLowerCase(), l = this.get(i);
+          yield [
+            i,
+            l
+          ];
+        }
+      }
+      *keys() {
+        for (const s of Object.keys(this.headers))
+          yield s.toLowerCase();
+      }
+      *values() {
+        for (const s of Object.keys(this.headers))
+          yield this.get(s);
+      }
+      [Symbol.iterator]() {
+        return this.entries();
+      }
+    }
+  }(W)), W;
+}
+var H;
+function ge() {
+  return H || (H = 1, function(y) {
+    Object.defineProperty(y, "__esModule", {
+      value: !0
+    }), Object.defineProperty(y, "headers", {
+      enumerable: !0,
+      get: function() {
+        return k;
+      }
+    });
+    const w = me(), d = $(), p = N(), g = V(), A = Y(), s = ne(), i = z(), l = se(), c = oe(), E = G(), _ = j();
+    function k() {
+      const e = d.workAsyncStorage.getStore(), r = p.workUnitAsyncStorage.getStore();
+      if (e) {
+        if (r && r.phase === "after" && !(0, c.isRequestAPICallableInsideAfter)())
+          throw Object.defineProperty(new Error(`Route ${e.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: !1,
+            configurable: !0
+          });
+        if (e.forceStatic) {
+          const f = w.HeadersAdapter.seal(new Headers({}));
+          return P(f);
+        }
+        if (r) {
+          if (r.type === "cache")
+            throw Object.defineProperty(new Error(`Route ${e.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: !1,
+              configurable: !0
+            });
+          if (r.type === "unstable-cache")
+            throw Object.defineProperty(new Error(`Route ${e.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: !1,
+              configurable: !0
+            });
+        }
+        if (e.dynamicShouldError)
+          throw Object.defineProperty(new A.StaticGenBailoutError(`Route ${e.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: !1,
+            configurable: !0
+          });
+        if (r)
+          switch (r.type) {
+            case "prerender":
+              return C(r);
+            case "prerender-client":
+              const f = "`headers`";
+              throw Object.defineProperty(new E.InvariantError(`${f} must not be used within a client component. Next.js should be preventing ${f} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                value: "E693",
+                enumerable: !1,
+                configurable: !0
+              });
+            case "prerender-ppr":
+              (0, g.postponeWithTracking)(e.route, "headers", r.dynamicTracking);
+              break;
+            case "prerender-legacy":
+              (0, g.throwToInterruptStaticGeneration)("headers", e, r);
+              break;
+          }
+        (0, g.trackDynamicDataInDynamicRender)(e, r);
+      }
+      const a = (0, p.getExpectedRequestStore)("headers");
+      return process.env.NODE_ENV === "development" && !(e != null && e.isPrefetchRequest) ? process.env.__NEXT_DYNAMIC_IO ? h(a.headers, e == null ? void 0 : e.route) : S(a.headers, e == null ? void 0 : e.route) : P(a.headers);
+    }
+    const x = /* @__PURE__ */ new WeakMap();
+    function C(e) {
+      const r = x.get(e);
+      if (r)
+        return r;
+      const a = (0, s.makeHangingPromise)(e.renderSignal, "`headers()`");
+      return x.set(e, a), a;
+    }
+    function P(e) {
+      const r = x.get(e);
+      if (r)
+        return r;
+      const a = Promise.resolve(e);
+      return x.set(e, a), Object.defineProperties(a, {
+        append: {
+          value: e.append.bind(e)
+        },
+        delete: {
+          value: e.delete.bind(e)
+        },
+        get: {
+          value: e.get.bind(e)
+        },
+        has: {
+          value: e.has.bind(e)
+        },
+        set: {
+          value: e.set.bind(e)
+        },
+        getSetCookie: {
+          value: e.getSetCookie.bind(e)
+        },
+        forEach: {
+          value: e.forEach.bind(e)
+        },
+        keys: {
+          value: e.keys.bind(e)
+        },
+        values: {
+          value: e.values.bind(e)
+        },
+        entries: {
+          value: e.entries.bind(e)
+        },
+        [Symbol.iterator]: {
+          value: e[Symbol.iterator].bind(e)
+        }
+      }), a;
+    }
+    function S(e, r) {
+      const a = x.get(e);
+      if (a)
+        return a;
+      const f = new Promise((t) => (0, l.scheduleImmediate)(() => t(e)));
+      return x.set(e, f), Object.defineProperties(f, {
+        append: {
+          value: function() {
+            const n = `\`headers().append(${m(arguments[0])}, ...)\``;
+            return b(r, n), e.append.apply(e, arguments);
+          }
+        },
+        delete: {
+          value: function() {
+            const n = `\`headers().delete(${m(arguments[0])})\``;
+            return b(r, n), e.delete.apply(e, arguments);
+          }
+        },
+        get: {
+          value: function() {
+            const n = `\`headers().get(${m(arguments[0])})\``;
+            return b(r, n), e.get.apply(e, arguments);
+          }
+        },
+        has: {
+          value: function() {
+            const n = `\`headers().has(${m(arguments[0])})\``;
+            return b(r, n), e.has.apply(e, arguments);
+          }
+        },
+        set: {
+          value: function() {
+            const n = `\`headers().set(${m(arguments[0])}, ...)\``;
+            return b(r, n), e.set.apply(e, arguments);
+          }
+        },
+        getSetCookie: {
+          value: function() {
+            return b(r, "`headers().getSetCookie()`"), e.getSetCookie.apply(e, arguments);
+          }
+        },
+        forEach: {
+          value: function() {
+            return b(r, "`headers().forEach(...)`"), e.forEach.apply(e, arguments);
+          }
+        },
+        keys: {
+          value: function() {
+            return b(r, "`headers().keys()`"), e.keys.apply(e, arguments);
+          }
+        },
+        values: {
+          value: function() {
+            return b(r, "`headers().values()`"), e.values.apply(e, arguments);
+          }
+        },
+        entries: {
+          value: function() {
+            return b(r, "`headers().entries()`"), e.entries.apply(e, arguments);
+          }
+        },
+        [Symbol.iterator]: {
+          value: function() {
+            return b(r, "`...headers()` or similar iteration"), e[Symbol.iterator].apply(e, arguments);
+          }
+        }
+      }), f;
+    }
+    function h(e, r) {
+      const a = x.get(e);
+      if (a)
+        return a;
+      const f = new Promise((n) => (0, l.scheduleImmediate)(() => n(e))), t = new Proxy(f, {
+        get(n, u, D) {
+          switch (u) {
+            case Symbol.iterator: {
+              R(r, "`...headers()` or similar iteration");
+              break;
+            }
+            case "append":
+            case "delete":
+            case "get":
+            case "has":
+            case "set":
+            case "getSetCookie":
+            case "forEach":
+            case "keys":
+            case "values":
+            case "entries": {
+              R(r, `\`headers().${u}\``);
+              break;
+            }
+          }
+          return _.ReflectAdapter.get(n, u, D);
+        }
+      });
+      return x.set(e, t), t;
+    }
+    function m(e) {
+      return typeof e == "string" ? `'${e}'` : "...";
+    }
+    function b(e, r) {
+      const a = p.workUnitAsyncStorage.getStore();
+      if (a && a.type === "request" && a.prerenderPhase === !0) {
+        const f = a;
+        (0, g.trackSynchronousRequestDataAccessInDev)(f);
+      }
+      R(e, r);
+    }
+    const R = (0, i.createDedupedByCallsiteServerErrorLoggerDev)(o);
+    function o(e, r) {
+      const a = e ? `Route "${e}" ` : "This route ";
+      return Object.defineProperty(new Error(`${a}used ${r}. \`headers()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E277",
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+  }(X)), X;
+}
+var B = {}, ee;
+function ve() {
+  return ee || (ee = 1, function(y) {
+    Object.defineProperty(y, "__esModule", {
+      value: !0
+    }), Object.defineProperty(y, "draftMode", {
+      enumerable: !0,
+      get: function() {
+        return c;
+      }
+    });
+    const w = N(), d = $(), p = V(), g = z(), A = Y(), s = ue(), i = G(), l = j();
+    function c() {
+      const o = "draftMode", e = d.workAsyncStorage.getStore(), r = w.workUnitAsyncStorage.getStore();
+      switch ((!e || !r) && (0, w.throwForMissingRequestStore)(o), r.type) {
+        case "request":
+          return E(r.draftMode, e);
+        case "cache":
+        case "unstable-cache":
+          const a = (0, w.getDraftModeProviderForCacheScope)(e, r);
+          if (a)
+            return E(a, e);
+        // Otherwise, we fall through to providing an empty draft mode.
+        // eslint-disable-next-line no-fallthrough
+        case "prerender":
+        case "prerender-client":
+        case "prerender-ppr":
+        case "prerender-legacy":
+          return E(null, e);
+        default:
+          return r;
+      }
+    }
+    function E(o, e) {
+      const r = o ?? _, a = k.get(r);
+      if (a)
+        return a;
+      let f;
+      if (process.env.NODE_ENV === "development" && !(e != null && e.isPrefetchRequest)) {
+        const t = e == null ? void 0 : e.route;
+        if (process.env.__NEXT_DYNAMIC_IO)
+          return P(o, t);
+        f = C(o, t);
+      } else {
+        if (process.env.__NEXT_DYNAMIC_IO)
+          return Promise.resolve(new S(o));
+        f = x(o);
+      }
+      return k.set(r, f), f;
+    }
+    const _ = {}, k = /* @__PURE__ */ new WeakMap();
+    function x(o) {
+      const e = new S(o), r = Promise.resolve(e);
+      return Object.defineProperty(r, "isEnabled", {
+        get() {
+          return e.isEnabled;
+        },
+        enumerable: !0,
+        configurable: !0
+      }), r.enable = e.enable.bind(e), r.disable = e.disable.bind(e), r;
+    }
+    function C(o, e) {
+      const r = new S(o), a = Promise.resolve(r);
+      return Object.defineProperty(a, "isEnabled", {
+        get() {
+          return h(e, "`draftMode().isEnabled`"), r.isEnabled;
+        },
+        enumerable: !0,
+        configurable: !0
+      }), Object.defineProperty(a, "enable", {
+        value: function() {
+          return h(e, "`draftMode().enable()`"), r.enable.apply(r, arguments);
+        }
+      }), Object.defineProperty(a, "disable", {
+        value: function() {
+          return h(e, "`draftMode().disable()`"), r.disable.apply(r, arguments);
+        }
+      }), a;
+    }
+    function P(o, e) {
+      const r = new S(o), a = Promise.resolve(r);
+      return new Proxy(a, {
+        get(t, n, u) {
+          switch (n) {
+            case "isEnabled":
+              m(e, `\`draftMode().${n}\``);
+              break;
+            case "enable":
+            case "disable": {
+              m(e, `\`draftMode().${n}()\``);
+              break;
+            }
+          }
+          return l.ReflectAdapter.get(t, n, u);
+        }
+      });
+    }
+    class S {
+      constructor(e) {
+        this._provider = e;
+      }
+      get isEnabled() {
+        return this._provider !== null ? this._provider.isEnabled : !1;
+      }
+      enable() {
+        R("draftMode().enable()"), this._provider !== null && this._provider.enable();
+      }
+      disable() {
+        R("draftMode().disable()"), this._provider !== null && this._provider.disable();
+      }
+    }
+    function h(o, e) {
+      const r = w.workUnitAsyncStorage.getStore();
+      if (r && r.type === "request" && r.prerenderPhase === !0) {
+        const a = r;
+        (0, p.trackSynchronousRequestDataAccessInDev)(a);
+      }
+      m(o, e);
+    }
+    const m = (0, g.createDedupedByCallsiteServerErrorLoggerDev)(b);
+    function b(o, e) {
+      const r = o ? `Route "${o}" ` : "This route ";
+      return Object.defineProperty(new Error(`${r}used ${e}. \`draftMode()\` should be awaited before using its value. Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E377",
+        enumerable: !1,
+        configurable: !0
+      });
+    }
+    function R(o) {
+      const e = d.workAsyncStorage.getStore(), r = w.workUnitAsyncStorage.getStore();
+      if (e) {
+        if (r) {
+          if (r.type === "cache")
+            throw Object.defineProperty(new Error(`Route ${e.route} used "${o}" 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: !1,
+              configurable: !0
+            });
+          if (r.type === "unstable-cache")
+            throw Object.defineProperty(new Error(`Route ${e.route} used "${o}" 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: !1,
+              configurable: !0
+            });
+          if (r.phase === "after")
+            throw Object.defineProperty(new Error(`Route ${e.route} used "${o}" 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: !1,
+              configurable: !0
+            });
+        }
+        if (e.dynamicShouldError)
+          throw Object.defineProperty(new A.StaticGenBailoutError(`Route ${e.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${o}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+            value: "E553",
+            enumerable: !1,
+            configurable: !0
+          });
+        if (r)
+          switch (r.type) {
+            case "prerender":
+              const a = Object.defineProperty(new Error(`Route ${e.route} used ${o} without first calling \`await connection()\`. See more info here: https://nextjs.org/docs/messages/next-prerender-sync-headers`), "__NEXT_ERROR_CODE", {
+                value: "E126",
+                enumerable: !1,
+                configurable: !0
+              });
+              (0, p.abortAndThrowOnSynchronousRequestDataAccess)(e.route, o, a, r);
+              break;
+            case "prerender-client":
+              const f = "`draftMode`";
+              throw Object.defineProperty(new i.InvariantError(`${f} must not be used within a client component. Next.js should be preventing ${f} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                value: "E693",
+                enumerable: !1,
+                configurable: !0
+              });
+            case "prerender-ppr":
+              (0, p.postponeWithTracking)(e.route, o, r.dynamicTracking);
+              break;
+            case "prerender-legacy":
+              r.revalidate = 0;
+              const t = Object.defineProperty(new s.DynamicServerError(`Route ${e.route} couldn't be rendered statically because it used \`${o}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+                value: "E558",
+                enumerable: !1,
+                configurable: !0
+              });
+              throw e.dynamicUsageDescription = o, e.dynamicUsageStack = t.stack, t;
+            case "request":
+              process.env.NODE_ENV === "development" && (r.usedDynamic = !0);
+              break;
+          }
+      }
+    }
+  }(B)), B;
+}
+var te;
+function _e() {
+  return te || (te = 1, M.cookies = be().cookies, M.headers = ge().headers, M.draftMode = ve().draftMode), M;
+}
+var ye = _e();
+const ae = () => {
+  const y = ye.cookies(), w = process.env.NEXT_PUBLIC_SUPABASE_URL, d = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
+  if (!w || !d)
+    throw new Error("Missing Supabase environment variables");
+  return le(
+    w,
+    d,
+    {
+      cookies: {
+        async get(p) {
+          var g;
+          try {
+            return (g = (await y).get(p)) == null ? void 0 : g.value;
+          } catch (A) {
+            throw console.error(`Supabase cookie operation 'get' failed. Error: ${I(A)}`), new Error("A server-side error occurred while handling user session.");
+          }
+        },
+        set(p, g, A) {
+          (async () => {
+            try {
+              (await y).set({ name: p, value: g, ...A });
+            } catch (s) {
+              throw console.error(`Supabase cookie operation 'set' failed. Error: ${I(s)}`), new Error("A server-side error occurred while handling user session.");
+            }
+          })();
+        },
+        remove(p, g) {
+          (async () => {
+            try {
+              (await y).set({ name: p, value: "", ...g });
+            } catch (A) {
+              throw console.error(`Supabase cookie operation 'remove' failed. Error: ${I(A)}`), new Error("A server-side error occurred while handling user session.");
+            }
+          })();
+        }
+      }
+    }
+  );
+};
+async function ke(y) {
+  const w = ae(), { data: d, error: p } = await w.from("profiles").select("id, full_name, avatar_url, role, updated_at, username, website").eq("id", y).single();
+  return p || !d ? (console.error("Error fetching profile (server-side):", p == null ? void 0 : p.message), null) : d;
+}
+async function Se() {
+  const y = ae(), { data: w, error: d } = await y.from("languages").select("id, code, name, is_default, is_active, created_at, updated_at").order("name", { ascending: !0 });
+  return d ? (console.error("Error fetching languages (server-side):", d.message), []) : w || [];
+}
+const Re = () => {
+  if (!process.env.NEXT_PUBLIC_SUPABASE_URL || !process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY)
+    throw new Error("Supabase URL or Anon Key is missing for SSG client. Check .env.local");
+  return de(
+    process.env.NEXT_PUBLIC_SUPABASE_URL,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY
+  );
+};
+export {
+  ae as createClient,
+  Se as getActiveLanguagesServerSide,
+  ke as getProfileWithRoleServerSide,
+  Re as getSsgSupabaseClient
+};