Initial boiler plate project

node_modules/next/dist/compiled/@edge-runtime/cookies/index.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Basic HTTP cookie parser and serializer for HTTP servers.
+ */
+
+/**
+ * Additional serialization options
+ */
+interface CookieSerializeOptions {
+    /**
+     * Specifies the value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.3|Domain Set-Cookie attribute}. By default, no
+     * domain is set, and most clients will consider the cookie to apply to only
+     * the current domain.
+     */
+    domain?: string | undefined;
+
+    /**
+     * Specifies a function that will be used to encode a cookie's value. Since
+     * value of a cookie has a limited character set (and must be a simple
+     * string), this function can be used to encode a value into a string suited
+     * for a cookie's value.
+     *
+     * The default function is the global `encodeURIComponent`, which will
+     * encode a JavaScript string into UTF-8 byte sequences and then URL-encode
+     * any that fall outside of the cookie range.
+     */
+    encode?(value: string): string;
+
+    /**
+     * Specifies the `Date` object to be the value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.1|`Expires` `Set-Cookie` attribute}. By default,
+     * no expiration is set, and most clients will consider this a "non-persistent cookie" and will delete
+     * it on a condition like exiting a web browser application.
+     *
+     * *Note* the {@link https://tools.ietf.org/html/rfc6265#section-5.3|cookie storage model specification}
+     * states that if both `expires` and `maxAge` are set, then `maxAge` takes precedence, but it is
+     * possible not all clients by obey this, so if both are set, they should
+     * point to the same date and time.
+     */
+    expires?: Date | undefined;
+    /**
+     * Specifies the boolean value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.6|`HttpOnly` `Set-Cookie` attribute}.
+     * When truthy, the `HttpOnly` attribute is set, otherwise it is not. By
+     * default, the `HttpOnly` attribute is not set.
+     *
+     * *Note* be careful when setting this to true, as compliant clients will
+     * not allow client-side JavaScript to see the cookie in `document.cookie`.
+     */
+    httpOnly?: boolean | undefined;
+    /**
+     * Specifies the number (in seconds) to be the value for the `Max-Age`
+     * `Set-Cookie` attribute. The given number will be converted to an integer
+     * by rounding down. By default, no maximum age is set.
+     *
+     * *Note* the {@link https://tools.ietf.org/html/rfc6265#section-5.3|cookie storage model specification}
+     * states that if both `expires` and `maxAge` are set, then `maxAge` takes precedence, but it is
+     * possible not all clients by obey this, so if both are set, they should
+     * point to the same date and time.
+     */
+    maxAge?: number | undefined;
+    /**
+     * Specifies the `boolean` value for the [`Partitioned` `Set-Cookie`](rfc-cutler-httpbis-partitioned-cookies)
+     * attribute. When truthy, the `Partitioned` attribute is set, otherwise it is not. By default, the
+     * `Partitioned` attribute is not set.
+     *
+     * **note** This is an attribute that has not yet been fully standardized, and may change in the future.
+     * This also means many clients may ignore this attribute until they understand it.
+     *
+     * More information about can be found in [the proposal](https://github.com/privacycg/CHIPS)
+     */
+    partitioned?: boolean | undefined;
+    /**
+     * Specifies the value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.4|`Path` `Set-Cookie` attribute}.
+     * By default, the path is considered the "default path".
+     */
+    path?: string | undefined;
+    /**
+     * Specifies the `string` to be the value for the [`Priority` `Set-Cookie` attribute][rfc-west-cookie-priority-00-4.1].
+     *
+     * - `'low'` will set the `Priority` attribute to `Low`.
+     * - `'medium'` will set the `Priority` attribute to `Medium`, the default priority when not set.
+     * - `'high'` will set the `Priority` attribute to `High`.
+     *
+     * More information about the different priority levels can be found in
+     * [the specification][rfc-west-cookie-priority-00-4.1].
+     *
+     * **note** This is an attribute that has not yet been fully standardized, and may change in the future.
+     * This also means many clients may ignore this attribute until they understand it.
+     */
+    priority?: "low" | "medium" | "high" | undefined;
+    /**
+     * Specifies the boolean or string to be the value for the {@link https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03#section-4.1.2.7|`SameSite` `Set-Cookie` attribute}.
+     *
+     * - `true` will set the `SameSite` attribute to `Strict` for strict same
+     * site enforcement.
+     * - `false` will not set the `SameSite` attribute.
+     * - `'lax'` will set the `SameSite` attribute to Lax for lax same site
+     * enforcement.
+     * - `'strict'` will set the `SameSite` attribute to Strict for strict same
+     * site enforcement.
+     *  - `'none'` will set the SameSite attribute to None for an explicit
+     *  cross-site cookie.
+     *
+     * More information about the different enforcement levels can be found in {@link https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03#section-4.1.2.7|the specification}.
+     *
+     * *note* This is an attribute that has not yet been fully standardized, and may change in the future. This also means many clients may ignore this attribute until they understand it.
+     */
+    sameSite?: true | false | "lax" | "strict" | "none" | undefined;
+    /**
+     * Specifies the boolean value for the {@link https://tools.ietf.org/html/rfc6265#section-5.2.5|`Secure` `Set-Cookie` attribute}. When truthy, the
+     * `Secure` attribute is set, otherwise it is not. By default, the `Secure` attribute is not set.
+     *
+     * *Note* be careful when setting this to `true`, as compliant clients will
+     * not send the cookie back to the server in the future if the browser does
+     * not have an HTTPS connection.
+     */
+    secure?: boolean | undefined;
+}
+
+/**
+ * {@link https://wicg.github.io/cookie-store/#dictdef-cookielistitem CookieListItem}
+ * as specified by W3C.
+ */
+interface CookieListItem extends Pick<CookieSerializeOptions, 'domain' | 'path' | 'secure' | 'sameSite' | 'partitioned'> {
+    /** A string with the name of a cookie. */
+    name: string;
+    /** A string containing the value of the cookie. */
+    value: string;
+    /** A number of milliseconds or Date interface containing the expires of the cookie. */
+    expires?: number | CookieSerializeOptions['expires'];
+}
+/**
+ * Superset of {@link CookieListItem} extending it with
+ * the `httpOnly`, `maxAge` and `priority` properties.
+ */
+type ResponseCookie = CookieListItem & Pick<CookieSerializeOptions, 'httpOnly' | 'maxAge' | 'priority'>;
+/**
+ * Subset of {@link CookieListItem}, only containing `name` and `value`
+ * since other cookie attributes aren't be available on a `Request`.
+ */
+type RequestCookie = Pick<CookieListItem, 'name' | 'value'>;
+
+/**
+ * A class for manipulating {@link Request} cookies (`Cookie` header).
+ */
+declare class RequestCookies {
+    constructor(requestHeaders: Headers);
+    [Symbol.iterator](): IterableIterator<[string, RequestCookie]>;
+    /**
+     * The amount of cookies received from the client
+     */
+    get size(): number;
+    get(...args: [name: string] | [RequestCookie]): RequestCookie | undefined;
+    getAll(...args: [name: string] | [RequestCookie] | []): RequestCookie[];
+    has(name: string): boolean;
+    set(...args: [key: string, value: string] | [options: RequestCookie]): this;
+    /**
+     * Delete the cookies matching the passed name or names in the request.
+     */
+    delete(
+    /** Name or names of the cookies to be deleted  */
+    names: string | string[]): boolean | boolean[];
+    /**
+     * Delete all the cookies in the cookies in the request.
+     */
+    clear(): this;
+    toString(): string;
+}
+
+/**
+ * A class for manipulating {@link Response} cookies (`Set-Cookie` header).
+ * Loose implementation of the experimental [Cookie Store API](https://wicg.github.io/cookie-store/#dictdef-cookie)
+ * The main difference is `ResponseCookies` methods do not return a Promise.
+ */
+declare class ResponseCookies {
+    constructor(responseHeaders: Headers);
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
+     */
+    get(...args: [key: string] | [options: ResponseCookie]): ResponseCookie | undefined;
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
+     */
+    getAll(...args: [key: string] | [options: ResponseCookie] | []): ResponseCookie[];
+    has(name: string): boolean;
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
+     */
+    set(...args: [key: string, value: string, cookie?: Partial<ResponseCookie>] | [options: ResponseCookie]): this;
+    /**
+     * {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
+     */
+    delete(...args: [key: string] | [options: Omit<ResponseCookie, 'value' | 'expires'>]): this;
+    toString(): string;
+}
+
+declare function stringifyCookie(c: ResponseCookie | RequestCookie): string;
+/** Parse a `Cookie` header value */
+declare function parseCookie(cookie: string): Map<string, string>;
+/** Parse a `Set-Cookie` header value */
+declare function parseSetCookie(setCookie: string): undefined | ResponseCookie;
+
+export { type CookieListItem, type RequestCookie, RequestCookies, type ResponseCookie, ResponseCookies, parseCookie, parseSetCookie, stringifyCookie };

node_modules/next/dist/compiled/@edge-runtime/cookies/index.js

@@ -0,0 +1,336 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  RequestCookies: () => RequestCookies,
+  ResponseCookies: () => ResponseCookies,
+  parseCookie: () => parseCookie,
+  parseSetCookie: () => parseSetCookie,
+  stringifyCookie: () => stringifyCookie
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/serialize.ts
+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(), 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;
+}
+
+// src/request-cookies.ts
+var RequestCookies = class {
+  constructor(requestHeaders) {
+    /** @internal */
+    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("; ");
+  }
+};
+
+// src/response-cookies.ts
+var ResponseCookies = class {
+  constructor(responseHeaders) {
+    /** @internal */
+    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, path, domain] = typeof args[0] === "string" ? [args[0]] : [args[0].name, args[0].path, args[0].domain];
+    return this.set({ name, path, domain, 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, headers) {
+  headers.delete("set-cookie");
+  for (const [, value] of bag) {
+    const serialized = stringifyCookie(value);
+    headers.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestCookies,
+  ResponseCookies,
+  parseCookie,
+  parseSetCookie,
+  stringifyCookie
+});

node_modules/next/dist/compiled/@edge-runtime/cookies/package.json

@@ -0,0 +1 @@
+{"name":"@edge-runtime/cookies","version":"5.0.0","main":"./index.js","license":"MIT"}

node_modules/next/dist/compiled/@edge-runtime/ponyfill/index.d.ts

@@ -0,0 +1 @@
+export * from '@edge-runtime/primitives'

node_modules/next/dist/compiled/@edge-runtime/ponyfill/index.js

@@ -0,0 +1,46 @@
+module.exports =
+  typeof EdgeRuntime === 'string' ? edge() : require("next/dist/compiled/@edge-runtime/primitives")
+
+function edge() {
+  return {
+    AbortController,
+    AbortSignal,
+    atob,
+    Blob,
+    btoa,
+    console,
+    crypto,
+    Crypto,
+    CryptoKey,
+    DOMException,
+    Event,
+    EventTarget,
+    fetch,
+    FetchEvent,
+    File,
+    FormData,
+    Headers,
+    performance,
+    PromiseRejectionEvent,
+    ReadableStream,
+    ReadableStreamBYOBReader,
+    ReadableStreamDefaultReader,
+    Request,
+    Response,
+    setInterval,
+    setTimeout,
+    structuredClone,
+    SubtleCrypto,
+    TextDecoder,
+    TextDecoderStream,
+    TextEncoder,
+    TextEncoderStream,
+    TransformStream,
+    URL,
+    URLPattern,
+    URLSearchParams,
+    WebSocket,
+    WritableStream,
+    WritableStreamDefaultWriter,
+  }
+}

node_modules/next/dist/compiled/@edge-runtime/ponyfill/package.json

@@ -0,0 +1 @@
+{"name":"@edge-runtime/ponyfill","version":"3.0.0","main":"./index.js","types":"./index.d.ts","license":"MIT"}

node_modules/next/dist/compiled/@edge-runtime/primitives/abort-controller.d.ts

@@ -0,0 +1,14 @@
+declare const AbortControllerConstructor: typeof AbortController
+
+declare const DOMExceptionConstructor: typeof DOMException
+
+declare var AbortSignal: {
+  prototype: typeof AbortSignal
+  new (): typeof AbortSignal
+  /** Returns an AbortSignal instance which will be aborted in milliseconds milliseconds. Its abort reason will be set to a "TimeoutError" DOMException. */
+  timeout(milliseconds: number): AbortSignal
+  /** Returns an AbortSignal instance whose abort reason is set to reason if not undefined; otherwise to an "AbortError" DOMException. */
+  abort(reason?: string): AbortSignal
+}
+
+export { AbortControllerConstructor as AbortController, AbortSignal, DOMExceptionConstructor as DOMException };

node_modules/next/dist/compiled/@edge-runtime/primitives/abort-controller.js.text.js

@@ -0,0 +1 @@
+module.exports = "\"use strict\";\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __name = (target, value) => __defProp(target, \"name\", { value, configurable: true });\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// src/primitives/abort-controller.js\nvar abort_controller_exports = {};\n__export(abort_controller_exports, {\n  AbortController: () => AbortController,\n  AbortSignal: () => AbortSignal,\n  DOMException: () => DOMException\n});\nmodule.exports = __toCommonJS(abort_controller_exports);\nvar kSignal = Symbol(\"kSignal\");\nvar kAborted = Symbol(\"kAborted\");\nvar kReason = Symbol(\"kReason\");\nvar kName = Symbol(\"kName\");\nvar kOnabort = Symbol(\"kOnabort\");\nvar _DOMException = class _DOMException extends Error {\n  constructor(message, name) {\n    super(message);\n    this[kName] = name;\n  }\n  get name() {\n    return this[kName];\n  }\n};\n__name(_DOMException, \"DOMException\");\nvar DOMException = _DOMException;\nfunction createAbortSignal() {\n  const signal = new EventTarget();\n  Object.setPrototypeOf(signal, AbortSignal.prototype);\n  signal[kAborted] = false;\n  signal[kReason] = void 0;\n  signal[kOnabort] = void 0;\n  return signal;\n}\n__name(createAbortSignal, \"createAbortSignal\");\nfunction abortSignalAbort(signal, reason) {\n  if (typeof reason === \"undefined\") {\n    reason = new DOMException(\"This operation was aborted\", \"AbortError\");\n  }\n  if (signal.aborted) {\n    return;\n  }\n  signal[kReason] = reason;\n  signal[kAborted] = true;\n  signal.dispatchEvent(new Event(\"abort\"));\n}\n__name(abortSignalAbort, \"abortSignalAbort\");\nvar _AbortController = class _AbortController {\n  constructor() {\n    this[kSignal] = createAbortSignal();\n  }\n  get signal() {\n    return this[kSignal];\n  }\n  abort(reason) {\n    abortSignalAbort(this.signal, reason);\n  }\n};\n__name(_AbortController, \"AbortController\");\nvar AbortController = _AbortController;\nvar _AbortSignal = class _AbortSignal extends EventTarget {\n  constructor() {\n    throw new TypeError(\"Illegal constructor\");\n  }\n  get aborted() {\n    return this[kAborted];\n  }\n  get reason() {\n    return this[kReason];\n  }\n  get onabort() {\n    return this[kOnabort];\n  }\n  set onabort(value) {\n    if (this[kOnabort]) {\n      this.removeEventListener(\"abort\", this[kOnabort]);\n    }\n    if (value) {\n      this[kOnabort] = value;\n      this.addEventListener(\"abort\", this[kOnabort]);\n    }\n  }\n  throwIfAborted() {\n    if (this[kAborted]) {\n      throw this[kReason];\n    }\n  }\n  static abort(reason) {\n    const signal = createAbortSignal();\n    abortSignalAbort(signal, reason);\n    return signal;\n  }\n  static timeout(milliseconds) {\n    const signal = createAbortSignal();\n    setTimeout(() => {\n      abortSignalAbort(\n        signal,\n        new DOMException(\n          \"The operation was aborted due to timeout\",\n          \"TimeoutError\"\n        )\n      );\n    }, milliseconds);\n    return signal;\n  }\n};\n__name(_AbortSignal, \"AbortSignal\");\nvar AbortSignal = _AbortSignal;\n// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n  AbortController,\n  AbortSignal,\n  DOMException\n});\n"

node_modules/next/dist/compiled/@edge-runtime/primitives/blob.d.ts

@@ -0,0 +1,3 @@
+declare const BlobConstructor: typeof Blob
+
+export { BlobConstructor as Blob };

node_modules/next/dist/compiled/@edge-runtime/primitives/console.d.ts

@@ -0,0 +1,18 @@
+interface IConsole {
+  assert: Console['assert']
+  count: Console['count']
+  debug: Console['debug']
+  dir: Console['dir']
+  error: Console['error']
+  info: Console['info']
+  log: Console['log']
+  time: Console['time']
+  timeEnd: Console['timeEnd']
+  timeLog: Console['timeLog']
+  trace: Console['trace']
+  warn: Console['warn']
+}
+
+declare const console: IConsole
+
+export { console };

node_modules/next/dist/compiled/@edge-runtime/primitives/crypto.d.ts

@@ -0,0 +1,7 @@
+declare const crypto: Crypto
+
+declare const CryptoConstructor: typeof Crypto
+declare const CryptoKeyConstructor: typeof CryptoKey
+declare const SubtleCryptoConstructor: typeof SubtleCrypto
+
+export { CryptoConstructor as Crypto, CryptoKeyConstructor as CryptoKey, SubtleCryptoConstructor as SubtleCrypto, crypto };

node_modules/next/dist/compiled/@edge-runtime/primitives/crypto.js.text.js

@@ -0,0 +1 @@
+module.exports = "\"use strict\";\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __name = (target, value) => __defProp(target, \"name\", { value, configurable: true });\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// src/primitives/crypto.js\nvar crypto_exports = {};\n__export(crypto_exports, {\n  Crypto: () => Crypto,\n  CryptoKey: () => CryptoKey,\n  SubtleCrypto: () => SubtleCrypto,\n  crypto: () => crypto\n});\nmodule.exports = __toCommonJS(crypto_exports);\nvar import_node_crypto = require(\"crypto\");\nvar { Crypto, CryptoKey } = import_node_crypto.webcrypto;\nfunction SubtleCrypto() {\n  if (!(this instanceof SubtleCrypto))\n    return new SubtleCrypto();\n  throw TypeError(\"Illegal constructor\");\n}\n__name(SubtleCrypto, \"SubtleCrypto\");\nvar crypto = new Crypto();\n// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n  Crypto,\n  CryptoKey,\n  SubtleCrypto,\n  crypto\n});\n"

node_modules/next/dist/compiled/@edge-runtime/primitives/events.d.ts

@@ -0,0 +1,325 @@
+/**
+ * An implementation of the `EventTarget` interface.
+ * @see https://dom.spec.whatwg.org/#eventtarget
+ */
+declare class EventTarget<TEventMap extends Record<string, Event$1> = Record<string, Event$1>, TMode extends "standard" | "strict" = "standard"> {
+	/**
+	 * Initialize this instance.
+	 */
+	constructor();
+	/**
+	 * Add an event listener.
+	 * @param type The event type.
+	 * @param callback The event listener.
+	 * @param options Options.
+	 */
+	addEventListener<T extends string & keyof TEventMap>(type: T, callback?: EventTarget.EventListener<this, TEventMap[T]> | null, options?: EventTarget.AddOptions): void;
+	/**
+	 * Add an event listener.
+	 * @param type The event type.
+	 * @param callback The event listener.
+	 * @param options Options.
+	 */
+	addEventListener(type: string, callback?: EventTarget.FallbackEventListener<this, TMode>, options?: EventTarget.AddOptions): void;
+	/**
+	 * Add an event listener.
+	 * @param type The event type.
+	 * @param callback The event listener.
+	 * @param capture The capture flag.
+	 * @deprecated Use `{capture: boolean}` object instead of a boolean value.
+	 */
+	addEventListener<T extends string & keyof TEventMap>(type: T, callback: EventTarget.EventListener<this, TEventMap[T]> | null | undefined, capture: boolean): void;
+	/**
+	 * Add an event listener.
+	 * @param type The event type.
+	 * @param callback The event listener.
+	 * @param capture The capture flag.
+	 * @deprecated Use `{capture: boolean}` object instead of a boolean value.
+	 */
+	addEventListener(type: string, callback: EventTarget.FallbackEventListener<this, TMode>, capture: boolean): void;
+	/**
+	 * Remove an added event listener.
+	 * @param type The event type.
+	 * @param callback The event listener.
+	 * @param options Options.
+	 */
+	removeEventListener<T extends string & keyof TEventMap>(type: T, callback?: EventTarget.EventListener<this, TEventMap[T]> | null, options?: EventTarget.Options): void;
+	/**
+	 * Remove an added event listener.
+	 * @param type The event type.
+	 * @param callback The event listener.
+	 * @param options Options.
+	 */
+	removeEventListener(type: string, callback?: EventTarget.FallbackEventListener<this, TMode>, options?: EventTarget.Options): void;
+	/**
+	 * Remove an added event listener.
+	 * @param type The event type.
+	 * @param callback The event listener.
+	 * @param capture The capture flag.
+	 * @deprecated Use `{capture: boolean}` object instead of a boolean value.
+	 */
+	removeEventListener<T extends string & keyof TEventMap>(type: T, callback: EventTarget.EventListener<this, TEventMap[T]> | null | undefined, capture: boolean): void;
+	/**
+	 * Remove an added event listener.
+	 * @param type The event type.
+	 * @param callback The event listener.
+	 * @param capture The capture flag.
+	 * @deprecated Use `{capture: boolean}` object instead of a boolean value.
+	 */
+	removeEventListener(type: string, callback: EventTarget.FallbackEventListener<this, TMode>, capture: boolean): void;
+	/**
+	 * Dispatch an event.
+	 * @param event The `Event` object to dispatch.
+	 */
+	dispatchEvent<T extends string & keyof TEventMap>(event: EventTarget.EventData<TEventMap, TMode, T>): boolean;
+	/**
+	 * Dispatch an event.
+	 * @param event The `Event` object to dispatch.
+	 */
+	dispatchEvent(event: EventTarget.FallbackEvent<TMode>): boolean;
+}
+declare namespace EventTarget {
+	/**
+	 * The event listener.
+	 */
+	type EventListener<TEventTarget extends EventTarget<any, any>, TEvent extends Event$1> = CallbackFunction<TEventTarget, TEvent> | CallbackObject<TEvent>;
+	/**
+	 * The event listener function.
+	 */
+	interface CallbackFunction<TEventTarget extends EventTarget<any, any>, TEvent extends Event$1> {
+		(this: TEventTarget, event: TEvent): void;
+	}
+	/**
+	 * The event listener object.
+	 * @see https://dom.spec.whatwg.org/#callbackdef-eventlistener
+	 */
+	interface CallbackObject<TEvent extends Event$1> {
+		handleEvent(event: TEvent): void;
+	}
+	/**
+	 * The common options for both `addEventListener` and `removeEventListener` methods.
+	 * @see https://dom.spec.whatwg.org/#dictdef-eventlisteneroptions
+	 */
+	interface Options {
+		capture?: boolean;
+	}
+	/**
+	 * The options for the `addEventListener` methods.
+	 * @see https://dom.spec.whatwg.org/#dictdef-addeventlisteneroptions
+	 */
+	interface AddOptions extends Options {
+		passive?: boolean;
+		once?: boolean;
+		signal?: AbortSignal | null | undefined;
+	}
+	/**
+	 * The abort signal.
+	 * @see https://dom.spec.whatwg.org/#abortsignal
+	 */
+	interface AbortSignal extends EventTarget<{
+		abort: Event$1;
+	}> {
+		readonly aborted: boolean;
+		onabort: CallbackFunction<this, Event$1> | null;
+	}
+	/**
+	 * The event data to dispatch in strict mode.
+	 */
+	type EventData<TEventMap extends Record<string, Event$1>, TMode extends "standard" | "strict", TEventType extends string> = TMode extends "strict" ? IsValidEventMap<TEventMap> extends true ? ExplicitType<TEventType> & Omit<TEventMap[TEventType], keyof Event$1> & Partial<Omit<Event$1, "type">> : never : never;
+	/**
+	 * Define explicit `type` property if `T` is a string literal.
+	 * Otherwise, never.
+	 */
+	type ExplicitType<T extends string> = string extends T ? never : {
+		readonly type: T;
+	};
+	/**
+	 * The event listener type in standard mode.
+	 * Otherwise, never.
+	 */
+	type FallbackEventListener<TEventTarget extends EventTarget<any, any>, TMode extends "standard" | "strict"> = TMode extends "standard" ? EventListener<TEventTarget, Event$1> | null | undefined : never;
+	/**
+	 * The event type in standard mode.
+	 * Otherwise, never.
+	 */
+	type FallbackEvent<TMode extends "standard" | "strict"> = TMode extends "standard" ? Event$1 : never;
+	/**
+	 * Check if given event map is valid.
+	 * It's valid if the keys of the event map are narrower than `string`.
+	 */
+	type IsValidEventMap<T> = string extends keyof T ? false : true;
+}
+/**
+ * An implementation of `Event` interface, that wraps a given event object.
+ * `EventTarget` shim can control the internal state of this `Event` objects.
+ * @see https://dom.spec.whatwg.org/#event
+ */
+declare class Event$1<TEventType extends string = string> {
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-none
+	 */
+	static get NONE(): number;
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-capturing_phase
+	 */
+	static get CAPTURING_PHASE(): number;
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-at_target
+	 */
+	static get AT_TARGET(): number;
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-bubbling_phase
+	 */
+	static get BUBBLING_PHASE(): number;
+	/**
+	 * Initialize this event instance.
+	 * @param type The type of this event.
+	 * @param eventInitDict Options to initialize.
+	 * @see https://dom.spec.whatwg.org/#dom-event-event
+	 */
+	constructor(type: TEventType, eventInitDict?: Event$1.EventInit);
+	/**
+	 * The type of this event.
+	 * @see https://dom.spec.whatwg.org/#dom-event-type
+	 */
+	get type(): TEventType;
+	/**
+	 * The event target of the current dispatching.
+	 * @see https://dom.spec.whatwg.org/#dom-event-target
+	 */
+	get target(): EventTarget | null;
+	/**
+	 * The event target of the current dispatching.
+	 * @deprecated Use the `target` property instead.
+	 * @see https://dom.spec.whatwg.org/#dom-event-srcelement
+	 */
+	get srcElement(): EventTarget | null;
+	/**
+	 * The event target of the current dispatching.
+	 * @see https://dom.spec.whatwg.org/#dom-event-currenttarget
+	 */
+	get currentTarget(): EventTarget | null;
+	/**
+	 * The event target of the current dispatching.
+	 * This doesn't support node tree.
+	 * @see https://dom.spec.whatwg.org/#dom-event-composedpath
+	 */
+	composedPath(): EventTarget[];
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-none
+	 */
+	get NONE(): number;
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-capturing_phase
+	 */
+	get CAPTURING_PHASE(): number;
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-at_target
+	 */
+	get AT_TARGET(): number;
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-bubbling_phase
+	 */
+	get BUBBLING_PHASE(): number;
+	/**
+	 * The current event phase.
+	 * @see https://dom.spec.whatwg.org/#dom-event-eventphase
+	 */
+	get eventPhase(): number;
+	/**
+	 * Stop event bubbling.
+	 * Because this shim doesn't support node tree, this merely changes the `cancelBubble` property value.
+	 * @see https://dom.spec.whatwg.org/#dom-event-stoppropagation
+	 */
+	stopPropagation(): void;
+	/**
+	 * `true` if event bubbling was stopped.
+	 * @deprecated
+	 * @see https://dom.spec.whatwg.org/#dom-event-cancelbubble
+	 */
+	get cancelBubble(): boolean;
+	/**
+	 * Stop event bubbling if `true` is set.
+	 * @deprecated Use the `stopPropagation()` method instead.
+	 * @see https://dom.spec.whatwg.org/#dom-event-cancelbubble
+	 */
+	set cancelBubble(value: boolean);
+	/**
+	 * Stop event bubbling and subsequent event listener callings.
+	 * @see https://dom.spec.whatwg.org/#dom-event-stopimmediatepropagation
+	 */
+	stopImmediatePropagation(): void;
+	/**
+	 * `true` if this event will bubble.
+	 * @see https://dom.spec.whatwg.org/#dom-event-bubbles
+	 */
+	get bubbles(): boolean;
+	/**
+	 * `true` if this event can be canceled by the `preventDefault()` method.
+	 * @see https://dom.spec.whatwg.org/#dom-event-cancelable
+	 */
+	get cancelable(): boolean;
+	/**
+	 * `true` if the default behavior will act.
+	 * @deprecated Use the `defaultPrevented` proeprty instead.
+	 * @see https://dom.spec.whatwg.org/#dom-event-returnvalue
+	 */
+	get returnValue(): boolean;
+	/**
+	 * Cancel the default behavior if `false` is set.
+	 * @deprecated Use the `preventDefault()` method instead.
+	 * @see https://dom.spec.whatwg.org/#dom-event-returnvalue
+	 */
+	set returnValue(value: boolean);
+	/**
+	 * Cancel the default behavior.
+	 * @see https://dom.spec.whatwg.org/#dom-event-preventdefault
+	 */
+	preventDefault(): void;
+	/**
+	 * `true` if the default behavior was canceled.
+	 * @see https://dom.spec.whatwg.org/#dom-event-defaultprevented
+	 */
+	get defaultPrevented(): boolean;
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-composed
+	 */
+	get composed(): boolean;
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-istrusted
+	 */
+	get isTrusted(): boolean;
+	/**
+	 * @see https://dom.spec.whatwg.org/#dom-event-timestamp
+	 */
+	get timeStamp(): number;
+	/**
+	 * @deprecated Don't use this method. The constructor did initialization.
+	 */
+	initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+}
+declare namespace Event$1 {
+	/**
+	 * The options of the `Event` constructor.
+	 * @see https://dom.spec.whatwg.org/#dictdef-eventinit
+	 */
+	interface EventInit {
+		bubbles?: boolean;
+		cancelable?: boolean;
+		composed?: boolean;
+	}
+}
+
+declare const EventTargetConstructor: typeof EventTarget
+declare const EventConstructor: typeof Event
+
+declare class FetchEvent {
+  request: Request
+  response: Response | null
+  awaiting: Set<Promise<void>>
+  constructor(request: Request)
+  respondWith(response: Response | Promise<Response>): void
+  waitUntil(promise: Promise<void>): void
+}
+
+export { EventConstructor as Event, EventTargetConstructor as EventTarget, FetchEvent, EventTarget as PromiseRejectionEvent };

node_modules/next/dist/compiled/@edge-runtime/primitives/events.js.text.js

@@ -0,0 +1 @@
+module.exports = "\"use strict\";\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __name = (target, value) => __defProp(target, \"name\", { value, configurable: true });\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// src/primitives/events.js\nvar events_exports = {};\n__export(events_exports, {\n  FetchEvent: () => FetchEvent,\n  PromiseRejectionEvent: () => PromiseRejectionEvent\n});\nmodule.exports = __toCommonJS(events_exports);\nvar _FetchEvent = class _FetchEvent extends Event {\n  constructor(request) {\n    super(\"fetch\");\n    this.request = request;\n    this.response = null;\n    this.awaiting = /* @__PURE__ */ new Set();\n  }\n  respondWith = (response) => {\n    this.response = response;\n  };\n  waitUntil = (promise) => {\n    this.awaiting.add(promise);\n    promise.finally(() => this.awaiting.delete(promise));\n  };\n};\n__name(_FetchEvent, \"FetchEvent\");\nvar FetchEvent = _FetchEvent;\nvar _PromiseRejectionEvent = class _PromiseRejectionEvent extends Event {\n  constructor(type, init) {\n    super(type, { cancelable: true });\n    this.promise = init.promise;\n    this.reason = init.reason;\n  }\n};\n__name(_PromiseRejectionEvent, \"PromiseRejectionEvent\");\nvar PromiseRejectionEvent = _PromiseRejectionEvent;\n// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n  FetchEvent,\n  PromiseRejectionEvent\n});\n"

node_modules/next/dist/compiled/@edge-runtime/primitives/fetch.d.ts

@@ -0,0 +1,27 @@
+declare class Headers extends globalThis.Headers {
+  /** @deprecated Use [`.getSetCookie()`](https://developer.mozilla.org/en-US/docs/Web/API/Headers/getSetCookie) instead. */
+  getAll?(key: 'set-cookie'): string[]
+}
+
+declare class Request extends globalThis.Request {
+  readonly headers: Headers
+  readonly duplex: string
+}
+
+declare class Response extends globalThis.Response {
+  readonly headers: Headers
+  static json(data: any, init?: ResponseInit): Response
+}
+
+type RequestInfo = string | Request | globalThis.Request
+type RequestInit = globalThis.RequestInit
+declare const fetchImplementation: (
+  info: RequestInfo,
+  init?: RequestInit,
+) => Promise<Response>
+
+declare const FileConstructor: typeof File
+declare const FormDataConstructor: typeof FormData
+declare const WebSocketConstructor: typeof WebSocket
+
+export { FileConstructor as File, FormDataConstructor as FormData, Headers, Request, type RequestInfo, type RequestInit, Response, WebSocketConstructor as WebSocket, fetchImplementation as fetch };

node_modules/next/dist/compiled/@edge-runtime/primitives/fetch.js.LEGAL.txt

@@ -0,0 +1,7 @@
+Bundled license information:
+
+undici/lib/fetch/body.js:
+  /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+
+undici/lib/websocket/frame.js:
+  /*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> */

node_modules/next/dist/compiled/@edge-runtime/primitives/index.d.ts

@@ -0,0 +1,44 @@
+export { AbortController, AbortSignal, DOMException } from './abort-controller.d.js';
+export { Blob } from './blob.d.js';
+export { console } from './console.d.js';
+export { Crypto, CryptoKey, SubtleCrypto, crypto } from './crypto.d.js';
+export { Event, EventTarget, FetchEvent, PromiseRejectionEvent } from './events.d.js';
+export { File, FormData, Headers, Request, RequestInfo, RequestInit, Response, WebSocket, fetch } from './fetch.d.js';
+export { structuredClone } from './structured-clone.d.js';
+export { URL, URLPattern, URLSearchParams } from './url.d.js';
+export { setInterval, setTimeout } from './timers.d.js';
+
+declare const TextEncoderConstructor: typeof TextEncoder
+declare const TextDecoderConstructor: typeof TextDecoder
+
+
+declare const _atob: typeof atob
+declare const _btoa: typeof btoa
+
+/**
+ * The type of `ReadableStreamBYOBReader` is not included in Typescript so we
+ * are declaring it inline to not have to worry about bundling.
+ */
+declare class ReadableStreamBYOBReader {
+  constructor(stream: ReadableStream<Uint8Array>)
+  get closed(): Promise<undefined>
+  cancel(reason?: any): Promise<void>
+  read<T extends ArrayBufferView>(
+    view: T,
+  ): Promise<{ done: false; value: T } | { done: true; value: T | undefined }>
+  releaseLock(): void
+}
+
+declare const ReadableStreamConstructor: typeof ReadableStream
+declare const ReadableStreamBYOBReaderConstructor: typeof ReadableStreamBYOBReader
+declare const ReadableStreamDefaultReaderConstructor: typeof ReadableStreamDefaultReader
+declare const TransformStreamConstructor: typeof TransformStream
+declare const WritableStreamConstructor: typeof WritableStream
+declare const WritableStreamDefaultWriterConstructor: typeof WritableStreamDefaultWriter
+
+declare const TextDecoderStreamConstructor: typeof TextDecoderStream
+declare const TextEncoderStreamConstructor: typeof TextEncoderStream
+
+declare const performanceConstructor: typeof performance
+
+export { ReadableStreamConstructor as ReadableStream, ReadableStreamBYOBReaderConstructor as ReadableStreamBYOBReader, ReadableStreamDefaultReaderConstructor as ReadableStreamDefaultReader, TextDecoderConstructor as TextDecoder, TextDecoderStreamConstructor as TextDecoderStream, TextEncoderConstructor as TextEncoder, TextEncoderStreamConstructor as TextEncoderStream, TransformStreamConstructor as TransformStream, WritableStreamConstructor as WritableStream, WritableStreamDefaultWriterConstructor as WritableStreamDefaultWriter, _atob as atob, _btoa as btoa, performanceConstructor as performance };

node_modules/next/dist/compiled/@edge-runtime/primitives/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+// src/primitives/index.js
+var import_load = require("./load");
+module.exports = (0, import_load.load)({ WeakRef: global.WeakRef });

node_modules/next/dist/compiled/@edge-runtime/primitives/load.d.ts

@@ -0,0 +1,26 @@
+import * as __index from './index';
+
+/**
+ * Load all the modules in the correct order.
+ * This is just like the entrypoint (`@edge-runtime/primitives`), only
+ * lazy.
+ *
+ * @param scopedContext a record of values that will be available to
+ * all modules. This is useful for providing a different implementation of
+ * globals, like `Uint8Array`.
+ *
+ * @example
+ * ```ts
+ * import { load } from '@edge-runtime/primitives/load'
+ *
+ * const { crypto, fetch, Request, Headers } = load({
+ *   Uint8Array: MyCustomUint8Array,
+ *   Error: MyCustomError,
+ * })
+ * ```
+ */
+declare function load(
+  scopedContext: Record<string, unknown>,
+): typeof __index
+
+export { load };

node_modules/next/dist/compiled/@edge-runtime/primitives/load.js

@@ -0,0 +1,251 @@
+"use strict";
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/primitives/load.js
+var load_exports = {};
+__export(load_exports, {
+  load: () => load
+});
+module.exports = __toCommonJS(load_exports);
+var import_module = __toESM(require("module"));
+var import_crypto = __toESM(require("crypto"));
+var import_web = require("stream/web");
+function requireWithFakeGlobalScope(params) {
+  const getModuleCode = `(function(module,exports,require,globalThis,${Object.keys(
+    params.scopedContext
+  ).join(",")}) {${params.sourceCode}
+})`;
+  const module = {
+    exports: {},
+    loaded: false,
+    id: params.id
+  };
+  const moduleRequire = (import_module.default.createRequire || import_module.default.createRequireFromPath)(
+    __filename
+  );
+  function throwingRequire(pathToRequire) {
+    if (pathToRequire.startsWith("./")) {
+      const moduleName = pathToRequire.replace(/^\.\//, "");
+      if (!params.cache || !params.cache.has(moduleName)) {
+        throw new Error(`Cannot find module '${moduleName}'`);
+      }
+      return params.cache.get(moduleName).exports;
+    }
+    return moduleRequire(pathToRequire);
+  }
+  __name(throwingRequire, "throwingRequire");
+  throwingRequire.resolve = moduleRequire.resolve.bind(moduleRequire);
+  eval(getModuleCode)(
+    module,
+    module.exports,
+    throwingRequire,
+    params.context,
+    ...Object.values(params.scopedContext)
+  );
+  return module.exports;
+}
+__name(requireWithFakeGlobalScope, "requireWithFakeGlobalScope");
+function load(scopedContext = {}) {
+  const context = {};
+  assign(context, {
+    TextDecoder,
+    TextEncoder,
+    TextEncoderStream: import_web.TextEncoderStream,
+    TextDecoderStream: import_web.TextDecoderStream,
+    atob,
+    btoa,
+    performance
+  });
+  const consoleImpl = requireWithFakeGlobalScope({
+    context,
+    id: "console.js",
+    sourceCode: require("./console.js.text.js"),
+    scopedContext
+  });
+  assign(context, { console: consoleImpl.console });
+  const timersImpl = requireWithFakeGlobalScope({
+    context,
+    id: "timers.js",
+    sourceCode: require("./timers.js.text.js"),
+    scopedContext
+  });
+  assign(context, {
+    setTimeout: timersImpl.setTimeout,
+    setInterval: timersImpl.setInterval
+  });
+  const eventsImpl = requireWithFakeGlobalScope({
+    context,
+    id: "events.js",
+    sourceCode: require("./events.js.text.js"),
+    scopedContext
+  });
+  assign(context, {
+    Event,
+    EventTarget,
+    FetchEvent: eventsImpl.FetchEvent,
+    // @ts-expect-error we need to add this to the type definitions maybe
+    PromiseRejectionEvent: eventsImpl.PromiseRejectionEvent
+  });
+  const streamsImpl = {
+    ReadableStream: import_web.ReadableStream,
+    ReadableStreamBYOBReader: import_web.ReadableStreamBYOBReader,
+    ReadableStreamDefaultReader: import_web.ReadableStreamDefaultReader,
+    TransformStream: import_web.TransformStream,
+    WritableStream: import_web.WritableStream,
+    WritableStreamDefaultWriter: import_web.WritableStreamDefaultWriter
+  };
+  assign(context, streamsImpl);
+  const abortControllerImpl = requireWithFakeGlobalScope({
+    context,
+    id: "abort-controller.js",
+    sourceCode: require("./abort-controller.js.text.js"),
+    scopedContext: { ...scopedContext }
+  });
+  assign(context, {
+    AbortController: abortControllerImpl.AbortController,
+    AbortSignal: abortControllerImpl.AbortSignal,
+    DOMException: abortControllerImpl.DOMException
+  });
+  const urlImpl = requireWithFakeGlobalScope({
+    context,
+    id: "url.js",
+    sourceCode: require("./url.js.text.js"),
+    scopedContext: { ...scopedContext }
+  });
+  assign(context, {
+    URL,
+    URLSearchParams,
+    URLPattern: urlImpl.URLPattern
+  });
+  const blobImpl = (() => {
+    if (typeof scopedContext.Blob === "function") {
+      return { Blob: scopedContext.Blob };
+    }
+    if (typeof Blob === "function") {
+      return { Blob };
+    }
+    const global = { ...streamsImpl, ...scopedContext };
+    const globalGlobal = { ...global, Blob: void 0 };
+    Object.setPrototypeOf(globalGlobal, globalThis);
+    global.global = globalGlobal;
+    return requireWithFakeGlobalScope({
+      context,
+      id: "blob.js",
+      sourceCode: require("./blob.js.text.js"),
+      scopedContext: global
+    });
+  })();
+  assign(context, {
+    Blob: blobImpl.Blob
+  });
+  const structuredCloneImpl = requireWithFakeGlobalScope({
+    id: "structured-clone.js",
+    context,
+    sourceCode: require("./structured-clone.js.text.js"),
+    scopedContext: { ...streamsImpl, ...scopedContext }
+  });
+  assign(context, {
+    structuredClone: structuredCloneImpl.structuredClone
+  });
+  const fetchImpl = requireWithFakeGlobalScope({
+    context,
+    id: "fetch.js",
+    sourceCode: require("./fetch.js.text.js"),
+    cache: /* @__PURE__ */ new Map([
+      ["abort-controller", { exports: abortControllerImpl }],
+      ["streams", { exports: streamsImpl }]
+    ]),
+    scopedContext: {
+      global: { ...scopedContext },
+      ...scopedContext,
+      ...urlImpl,
+      ...abortControllerImpl,
+      ...eventsImpl,
+      ...streamsImpl,
+      structuredClone: context.structuredClone
+    }
+  });
+  assign(context, {
+    fetch: fetchImpl.fetch,
+    File: fetchImpl.File,
+    FormData: fetchImpl.FormData,
+    Headers: fetchImpl.Headers,
+    Request: fetchImpl.Request,
+    Response: fetchImpl.Response,
+    WebSocket: fetchImpl.WebSocket
+  });
+  const cryptoImpl = getCrypto(context, scopedContext);
+  assign(context, {
+    crypto: cryptoImpl.crypto,
+    Crypto: cryptoImpl.Crypto,
+    CryptoKey: cryptoImpl.CryptoKey,
+    SubtleCrypto: cryptoImpl.SubtleCrypto
+  });
+  return context;
+}
+__name(load, "load");
+function getCrypto(context, scopedContext) {
+  if (typeof SubtleCrypto !== "undefined" || scopedContext.SubtleCrypto) {
+    return {
+      crypto: scopedContext.crypto || globalThis.crypto,
+      Crypto: scopedContext.Crypto || globalThis.Crypto,
+      CryptoKey: scopedContext.CryptoKey || globalThis.CryptoKey,
+      SubtleCrypto: scopedContext.SubtleCrypto || globalThis.SubtleCrypto
+    };
+  } else if (
+    // @ts-ignore
+    import_crypto.default.webcrypto
+  ) {
+    const webcrypto = import_crypto.default.webcrypto;
+    return {
+      crypto: webcrypto,
+      Crypto: webcrypto.constructor,
+      CryptoKey: webcrypto.CryptoKey,
+      SubtleCrypto: webcrypto.subtle.constructor
+    };
+  }
+  return requireWithFakeGlobalScope({
+    context,
+    id: "crypto.js",
+    sourceCode: require("./crypto.js.text.js"),
+    scopedContext: {
+      ...scopedContext
+    }
+  });
+}
+__name(getCrypto, "getCrypto");
+function assign(context, additions) {
+  Object.assign(context, additions);
+}
+__name(assign, "assign");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  load
+});

node_modules/next/dist/compiled/@edge-runtime/primitives/package.json

@@ -0,0 +1 @@
+{"name":"@edge-runtime/primitives","version":"5.0.0","main":"./index.js","license":"MIT"}

node_modules/next/dist/compiled/@edge-runtime/primitives/structured-clone.d.ts

@@ -0,0 +1,3 @@
+declare const structuredClone: <T>(any: T, options?: { lossy?: boolean }) => T
+
+export { structuredClone };

node_modules/next/dist/compiled/@edge-runtime/primitives/timers.d.ts

@@ -0,0 +1,4 @@
+declare const _setTimeout: (callback: () => void, ms?: number) => number
+declare const _setInterval: (callback: () => void, ms?: number) => number
+
+export { _setInterval as setInterval, _setTimeout as setTimeout };

node_modules/next/dist/compiled/@edge-runtime/primitives/timers.js.text.js

@@ -0,0 +1 @@
+module.exports = "\"use strict\";\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// src/primitives/timers.js\nvar timers_exports = {};\n__export(timers_exports, {\n  setInterval: () => setIntervalProxy,\n  setTimeout: () => setTimeoutProxy\n});\nmodule.exports = __toCommonJS(timers_exports);\nvar setTimeoutProxy = new Proxy(setTimeout, {\n  apply: (target, thisArg, args) => {\n    const timeout = Reflect.apply(target, thisArg, args);\n    return timeout[Symbol.toPrimitive]();\n  }\n});\nvar setIntervalProxy = new Proxy(setInterval, {\n  apply: (target, thisArg, args) => {\n    const timeout = Reflect.apply(target, thisArg, args);\n    return timeout[Symbol.toPrimitive]();\n  }\n});\n// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n  setInterval,\n  setTimeout\n});\n"

node_modules/next/dist/compiled/@edge-runtime/primitives/url.d.ts

@@ -0,0 +1,55 @@
+type URLPatternInput = URLPatternInit | string;
+
+declare class URLPattern {
+  constructor(init?: URLPatternInput, baseURL?: string);
+
+  test(input?: URLPatternInput, baseURL?: string): boolean;
+
+  exec(input?: URLPatternInput, baseURL?: string): URLPatternResult | null;
+
+  readonly protocol: string;
+  readonly username: string;
+  readonly password: string;
+  readonly hostname: string;
+  readonly port: string;
+  readonly pathname: string;
+  readonly search: string;
+  readonly hash: string;
+}
+
+interface URLPatternInit {
+  baseURL?: string;
+  username?: string;
+  password?: string;
+  protocol?: string;
+  hostname?: string;
+  port?: string;
+  pathname?: string;
+  search?: string;
+  hash?: string;
+}
+
+interface URLPatternResult {
+  inputs: [URLPatternInput];
+  protocol: URLPatternComponentResult;
+  username: URLPatternComponentResult;
+  password: URLPatternComponentResult;
+  hostname: URLPatternComponentResult;
+  port: URLPatternComponentResult;
+  pathname: URLPatternComponentResult;
+  search: URLPatternComponentResult;
+  hash: URLPatternComponentResult;
+}
+
+interface URLPatternComponentResult {
+  input: string;
+  groups: {
+    [key: string]: string | undefined;
+  };
+}
+
+declare const _URL: typeof URL
+declare const _URLSearchParams: typeof URLSearchParams
+declare class _URLPattern extends URLPattern {}
+
+export { _URL as URL, _URLPattern as URLPattern, _URLSearchParams as URLSearchParams };