Initial boiler plate project

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 };