.

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\";var c=Object.defineProperty,f=Object.getOwnPropertyDescriptor,y=Object.getOwnPropertyNames,S=Object.prototype.hasOwnProperty,a=(r,t)=>c(r,\"name\",{value:t,configurable:!0}),m=(r,t)=>{for(var e in t)c(r,e,{get:t[e],enumerable:!0})},w=(r,t,e,p)=>{if(t&&typeof t==\"object\"||typeof t==\"function\")for(let n of y(t))!S.call(r,n)&&n!==e&&c(r,n,{get:()=>t[n],enumerable:!(p=f(t,n))||p.enumerable});return r},E=r=>w(c({},\"__esModule\",{value:!0}),r),_={};m(_,{AbortController:()=>x,AbortSignal:()=>O,DOMException:()=>u});module.exports=E(_);var v=Symbol(\"kSignal\"),i=Symbol(\"kAborted\"),s=Symbol(\"kReason\"),g=Symbol(\"kName\"),o=Symbol(\"kOnabort\"),h=class extends Error{constructor(t,e){super(t),this[g]=e}get name(){return this[g]}};a(h,\"DOMException\");var u=h;function b(){let r=new EventTarget;return Object.setPrototypeOf(r,O.prototype),r[i]=!1,r[s]=void 0,r[o]=void 0,r}a(b,\"createAbortSignal\");function l(r,t){typeof t>\"u\"&&(t=new u(\"This operation was aborted\",\"AbortError\")),!r.aborted&&(r[s]=t,r[i]=!0,r.dispatchEvent(new Event(\"abort\")))}a(l,\"abortSignalAbort\");var d=class{constructor(){this[v]=b()}get signal(){return this[v]}abort(t){l(this.signal,t)}};a(d,\"AbortController\");var x=d,A=class extends EventTarget{constructor(){throw new TypeError(\"Illegal constructor\")}get aborted(){return this[i]}get reason(){return this[s]}get onabort(){return this[o]}set onabort(t){this[o]&&this.removeEventListener(\"abort\",this[o]),t&&(this[o]=t,this.addEventListener(\"abort\",this[o]))}throwIfAborted(){if(this[i])throw this[s]}static abort(t){let e=b();return l(e,t),e}static timeout(t){let e=b();return setTimeout(()=>{l(e,new u(\"The operation was aborted due to timeout\",\"TimeoutError\"))},t),e}};a(A,\"AbortSignal\");var O=A;\n"

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

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/primitives/crypto.js
+var crypto_exports = {};
+__export(crypto_exports, {
+  Crypto: () => Crypto,
+  CryptoKey: () => CryptoKey,
+  SubtleCrypto: () => SubtleCrypto,
+  crypto: () => crypto
+});
+module.exports = __toCommonJS(crypto_exports);
+var import_node_crypto = require("crypto");
+var { Crypto, CryptoKey } = import_node_crypto.webcrypto;
+function SubtleCrypto() {
+  if (!(this instanceof SubtleCrypto))
+    return new SubtleCrypto();
+  throw TypeError("Illegal constructor");
+}
+__name(SubtleCrypto, "SubtleCrypto");
+var crypto = new Crypto();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Crypto,
+  CryptoKey,
+  SubtleCrypto,
+  crypto
+});

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\";var s=Object.defineProperty,p=Object.getOwnPropertyDescriptor,_=Object.getOwnPropertyNames,u=Object.prototype.hasOwnProperty,a=(t,e)=>s(t,\"name\",{value:e,configurable:!0}),h=(t,e)=>{for(var r in e)s(t,r,{get:e[r],enumerable:!0})},l=(t,e,r,o)=>{if(e&&typeof e==\"object\"||typeof e==\"function\")for(let n of _(e))!u.call(t,n)&&n!==r&&s(t,n,{get:()=>e[n],enumerable:!(o=p(e,n))||o.enumerable});return t},P=t=>l(s({},\"__esModule\",{value:!0}),t),i={};h(i,{FetchEvent:()=>E,PromiseRejectionEvent:()=>j});module.exports=P(i);var c=class extends Event{constructor(e){super(\"fetch\"),this.request=e,this.response=null,this.awaiting=new Set}respondWith=e=>{this.response=e};waitUntil=e=>{this.awaiting.add(e),e.finally(()=>this.awaiting.delete(e))}};a(c,\"FetchEvent\");var E=c,v=class extends Event{constructor(e,r){super(e,{cancelable:!0}),this.promise=r.promise,this.reason=r.reason}};a(v,\"PromiseRejectionEvent\");var j=v;\n"

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

@@ -0,0 +1,23 @@
+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
+declare const HeadersConstructor: typeof Headers
+
+export { FileConstructor as File, FormDataConstructor as FormData, HeadersConstructor as 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/web/fetch/body.js:
+  /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+
+undici/lib/web/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,46 @@
+export { AbortController, AbortSignal, DOMException } from './abort-controller.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 { URL, URLPattern, URLSearchParams } from './url.d.js';
+export { setInterval, setTimeout } from './timers.d.js';
+
+declare const BlobConstructor: typeof Blob
+
+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 structuredCloneConstructor: typeof structuredClone
+
+declare const performanceConstructor: typeof performance
+
+export { BlobConstructor as Blob, 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, structuredCloneConstructor as structuredClone };

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.LEGAL.txt

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

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

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

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

@@ -0,0 +1,44 @@
+"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/primitives/stream.js
+var stream_exports = {};
+__export(stream_exports, {
+  ReadableStream: () => import_web.ReadableStream,
+  ReadableStreamBYOBReader: () => import_web.ReadableStreamBYOBReader,
+  ReadableStreamDefaultReader: () => import_web.ReadableStreamDefaultReader,
+  TextDecoderStream: () => import_web.TextDecoderStream,
+  TextEncoderStream: () => import_web.TextEncoderStream,
+  TransformStream: () => import_web.TransformStream,
+  WritableStream: () => import_web.WritableStream,
+  WritableStreamDefaultWriter: () => import_web.WritableStreamDefaultWriter
+});
+module.exports = __toCommonJS(stream_exports);
+var import_web = require("stream/web");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReadableStream,
+  ReadableStreamBYOBReader,
+  ReadableStreamDefaultReader,
+  TextDecoderStream,
+  TextEncoderStream,
+  TransformStream,
+  WritableStream,
+  WritableStreamDefaultWriter
+});

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\";var a=Object.defineProperty,s=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,u=Object.prototype.hasOwnProperty,l=(t,e)=>{for(var r in e)a(t,r,{get:e[r],enumerable:!0})},y=(t,e,r,p)=>{if(e&&typeof e==\"object\"||typeof e==\"function\")for(let o of i(e))!u.call(t,o)&&o!==r&&a(t,o,{get:()=>e[o],enumerable:!(p=s(e,o))||p.enumerable});return t},v=t=>y(a({},\"__esModule\",{value:!0}),t),n={};l(n,{setInterval:()=>m,setTimeout:()=>_});module.exports=v(n);var _=new Proxy(setTimeout,{apply:(t,e,r)=>Reflect.apply(t,e,r)[Symbol.toPrimitive]()}),m=new Proxy(setInterval,{apply:(t,e,r)=>Reflect.apply(t,e,r)[Symbol.toPrimitive]()});\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 };