Update app and tooling

node_modules/@edge-runtime/vm/LICENSE.md

@@ -0,0 +1,382 @@
+# Mozilla Public License Version 2.0
+
+1. Definitions
+
+---
+
+1.1. "Contributor"
+means each individual or legal entity that creates, contributes to
+the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+means the combination of the Contributions of others (if any) used
+by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+means Source Code Form to which the initial Contributor has attached
+the notice in Exhibit A, the Executable Form of such Source Code
+Form, and Modifications of such Source Code Form, in each case
+including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+means a work that combines Covered Software with other material, in
+a separate file or files, that is not Covered Software.
+
+1.8. "License"
+means this document.
+
+1.9. "Licensable"
+means having the right to grant, to the maximum extent possible,
+whether at the time of the initial grant or subsequently, any and
+all of the rights conveyed by this License.
+
+1.10. "Modifications"
+means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+means any patent claim(s), including without limitation, method,
+process, and apparatus claims, in any patent Licensable by such
+Contributor that would be infringed, but for the grant of the
+License, by the making, using, selling, offering for sale, having
+made, import, or transfer of either its Contributions or its
+Contributor Version.
+
+1.12. "Secondary License"
+means either the GNU General Public License, Version 2.0, the GNU
+Lesser General Public License, Version 2.1, the GNU Affero General
+Public License, Version 3.0, or any later versions of those
+licenses.
+
+1.13. "Source Code Form"
+means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+means an individual or a legal entity exercising rights under this
+License. For legal entities, "You" includes any entity that
+controls, is controlled by, or is under common control with You. For
+purposes of this definition, "control" means (a) the power, direct
+or indirect, to cause the direction or management of such entity,
+whether by contract or otherwise, or (b) ownership of more than
+fifty percent (50%) of the outstanding shares or beneficial
+ownership of such entity.
+
+2. License Grants and Conditions
+
+---
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+Licensable by such Contributor to use, reproduce, make available,
+modify, display, perform, distribute, and otherwise exploit its
+Contributions, either on an unmodified basis, with Modifications, or
+as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+for sale, have made, import, and otherwise transfer either its
+Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+or
+
+(b) for infringements caused by: (i) Your and any other third party's
+modifications of Covered Software, or (ii) the combination of its
+Contributions with other software (except as part of its Contributor
+Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+
+---
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+Form, as described in Section 3.1, and You must inform recipients of
+the Executable Form how they can obtain a copy of such Source Code
+Form by reasonable means in a timely manner, at a charge no more
+than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+License, or sublicense it under different terms, provided that the
+license for the Executable Form does not attempt to limit or alter
+the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+---
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+
+---
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+---
+
+-                                                                      *
+- 6.  Disclaimer of Warranty \*
+- ------------------------- \*
+-                                                                      *
+- Covered Software is provided under this License on an "as is" \*
+- basis, without warranty of any kind, either expressed, implied, or \*
+- statutory, including, without limitation, warranties that the \*
+- Covered Software is free of defects, merchantable, fit for a \*
+- particular purpose or non-infringing. The entire risk as to the \*
+- quality and performance of the Covered Software is with You. \*
+- Should any Covered Software prove defective in any respect, You \*
+- (not any Contributor) assume the cost of any necessary servicing, \*
+- repair, or correction. This disclaimer of warranty constitutes an \*
+- essential part of this License. No use of any Covered Software is \*
+- authorized under this License except under this disclaimer. \*
+-                                                                      *
+
+---
+
+---
+
+-                                                                      *
+- 7.  Limitation of Liability \*
+- -------------------------- \*
+-                                                                      *
+- Under no circumstances and under no legal theory, whether tort \*
+- (including negligence), contract, or otherwise, shall any \*
+- Contributor, or anyone who distributes Covered Software as \*
+- permitted above, be liable to You for any direct, indirect, \*
+- special, incidental, or consequential damages of any character \*
+- including, without limitation, damages for lost profits, loss of \*
+- goodwill, work stoppage, computer failure or malfunction, or any \*
+- and all other commercial damages or losses, even if such party \*
+- shall have been informed of the possibility of such damages. This \*
+- limitation of liability shall not apply to liability for death or \*
+- personal injury resulting from such party's negligence to the \*
+- extent applicable law prohibits such limitation. Some \*
+- jurisdictions do not allow the exclusion or limitation of \*
+- incidental or consequential damages, so this exclusion and \*
+- limitation may not apply to You. \*
+-                                                                      *
+
+---
+
+8. Litigation
+
+---
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+
+---
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+
+---
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+## Exhibit A - Source Code Form License Notice
+
+This Source Code Form is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+## Exhibit B - "Incompatible With Secondary Licenses" Notice
+
+This Source Code Form is "Incompatible With Secondary Licenses", as
+defined by the Mozilla Public License, v. 2.0.

node_modules/@edge-runtime/vm/README.md

@@ -0,0 +1,37 @@
+<div align="center">
+  <br>
+  <img src="https://user-images.githubusercontent.com/2096101/235130063-e561514e-1f66-4ff6-9034-70dbf7ca3260.png#gh-dark-mode-only">
+  <img src="https://user-images.githubusercontent.com/2096101/235127419-ac6fe609-d0cd-4339-a593-c48305a83823.png#gh-light-mode-only">
+  <br>
+  <br>
+  <p align="center"><strong>@edge-runtime/vm</strong>: Low level bindings for creating Web Standard contexts.</p>
+  <p align="center">See <a href="https://edge-runtime.vercel.app/packages/vm" target='_blank' rel='noopener noreferrer'>@edge-runtime/vm</a> section in our <a href="https://edge-runtime.vercel.app/" target='_blank' rel='noopener noreferrer'>website</a> for more information.</p>
+  <br>
+</div>
+
+## Install
+
+Using npm:
+
+```sh
+npm install @edge-runtime/vm --save
+```
+
+or using yarn:
+
+```sh
+yarn add @edge-runtime/vm --dev
+```
+
+or using pnpm:
+
+```sh
+pnpm install @edge-runtime/vm --save
+```
+
+## License
+
+**@edge-runtime/vm** © [Vercel](https://vercel.com), released under the [MPLv2](https://github.com/vercel/edge-runtime/blob/main/LICENSE.md) License.<br>
+Authored and maintained by [Vercel](https://vercel.com) with help from [contributors](https://github.com/vercel/edge-runtime/contributors).
+
+> [vercel.com](https://vercel.com) · GitHub [Vercel](https://github.com/vercel) · Twitter [@vercel](https://twitter.com/vercel)

node_modules/@edge-runtime/vm/dist/edge-vm.d.ts

@@ -0,0 +1,67 @@
+import type * as EdgePrimitives from '@edge-runtime/primitives';
+import type { DispatchFetch } from './types';
+import { VM, type VMContext, type VMOptions } from './vm';
+export interface EdgeVMOptions<T extends EdgeContext> {
+    /**
+     * Provide code generation options to the Node.js VM.
+     * If you don't provide any option, code generation will be disabled.
+     */
+    codeGeneration?: VMOptions<T>['codeGeneration'];
+    /**
+     * Allows to extend the VMContext. Note that it must return a contextified
+     * object so ideally it should return the same reference it receives.
+     */
+    extend?: (context: EdgeContext) => EdgeContext & T;
+    /**
+     * Code to be evaluated as when the Edge Runtime is created. This is handy
+     * to run code directly instead of first creating the runtime and then
+     * evaluating.
+     */
+    initialCode?: string;
+}
+export declare class EdgeVM<T extends EdgeContext = EdgeContext> extends VM<T> {
+    readonly dispatchFetch: DispatchFetch;
+    constructor(options?: EdgeVMOptions<T>);
+}
+export type EdgeContext = VMContext & {
+    self: EdgeContext;
+    globalThis: EdgeContext;
+    AbortController: typeof EdgePrimitives.AbortController;
+    AbortSignal: typeof EdgePrimitives.AbortSignal;
+    atob: typeof EdgePrimitives.atob;
+    Blob: typeof EdgePrimitives.Blob;
+    btoa: typeof EdgePrimitives.btoa;
+    console: typeof EdgePrimitives.console;
+    crypto: typeof EdgePrimitives.crypto;
+    Crypto: typeof EdgePrimitives.Crypto;
+    CryptoKey: typeof EdgePrimitives.CryptoKey;
+    DOMException: typeof EdgePrimitives.DOMException;
+    Event: typeof EdgePrimitives.Event;
+    EventTarget: typeof EdgePrimitives.EventTarget;
+    fetch: typeof EdgePrimitives.fetch;
+    FetchEvent: typeof EdgePrimitives.FetchEvent;
+    File: typeof EdgePrimitives.File;
+    FormData: typeof EdgePrimitives.FormData;
+    Headers: typeof EdgePrimitives.Headers;
+    PromiseRejectionEvent: typeof EdgePrimitives.PromiseRejectionEvent;
+    ReadableStream: typeof EdgePrimitives.ReadableStream;
+    ReadableStreamBYOBReader: typeof EdgePrimitives.ReadableStreamBYOBReader;
+    ReadableStreamDefaultReader: typeof EdgePrimitives.ReadableStreamDefaultReader;
+    Request: typeof EdgePrimitives.Request;
+    Response: typeof EdgePrimitives.Response;
+    setTimeout: typeof EdgePrimitives.setTimeout;
+    setInterval: typeof EdgePrimitives.setInterval;
+    structuredClone: typeof EdgePrimitives.structuredClone;
+    SubtleCrypto: typeof EdgePrimitives.SubtleCrypto;
+    TextDecoder: typeof EdgePrimitives.TextDecoder;
+    TextDecoderStream: typeof EdgePrimitives.TextDecoderStream;
+    TextEncoder: typeof EdgePrimitives.TextEncoder;
+    TextEncoderStream: typeof EdgePrimitives.TextEncoderStream;
+    TransformStream: typeof EdgePrimitives.TransformStream;
+    URL: typeof EdgePrimitives.URL;
+    URLPattern: typeof EdgePrimitives.URLPattern;
+    URLSearchParams: typeof EdgePrimitives.URLSearchParams;
+    WritableStream: typeof EdgePrimitives.WritableStream;
+    WritableStreamDefaultWriter: typeof EdgePrimitives.WritableStreamDefaultWriter;
+    EdgeRuntime: string;
+};

node_modules/@edge-runtime/vm/dist/edge-vm.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeVM = void 0;
+const load_1 = require("@edge-runtime/primitives/load");
+const vm_1 = require("vm");
+const vm_2 = require("./vm");
+/**
+ * Store handlers that the user defined from code so that we can invoke them
+ * from the Node.js realm.
+ */
+let unhandledRejectionHandlers;
+let uncaughtExceptionHandlers;
+class EdgeVM extends vm_2.VM {
+    constructor(options) {
+        super({
+            ...options,
+            extend: (context) => {
+                return (options === null || options === void 0 ? void 0 : options.extend)
+                    ? options.extend(addPrimitives(context))
+                    : addPrimitives(context);
+            },
+        });
+        Object.defineProperty(this.context, '__onUnhandledRejectionHandlers', {
+            set: registerUnhandledRejectionHandlers,
+            configurable: false,
+            enumerable: false,
+        });
+        Object.defineProperty(this, '__rejectionHandlers', {
+            get: () => unhandledRejectionHandlers,
+            configurable: false,
+            enumerable: false,
+        });
+        Object.defineProperty(this.context, '__onErrorHandlers', {
+            set: registerUncaughtExceptionHandlers,
+            configurable: false,
+            enumerable: false,
+        });
+        Object.defineProperty(this, '__errorHandlers', {
+            get: () => uncaughtExceptionHandlers,
+            configurable: false,
+            enumerable: false,
+        });
+        this.evaluate(getDefineEventListenersCode());
+        this.dispatchFetch = this.evaluate(getDispatchFetchCode());
+        for (const name of transferableConstructors) {
+            patchInstanceOf(name, this.context);
+        }
+        if (options === null || options === void 0 ? void 0 : options.initialCode) {
+            this.evaluate(options.initialCode);
+        }
+    }
+}
+exports.EdgeVM = EdgeVM;
+/**
+ * Transferable constructors are the constructors that we expect to be
+ * "shared" between the realms.
+ *
+ * When a user creates an instance of one of these constructors, we want
+ * to make sure that the `instanceof` operator works as expected:
+ *
+ * * If the instance was created in the Node.js realm, then `instanceof`
+ *   should return true when used in the EdgeVM realm.
+ * * If the instance was created in the EdgeVM realm, then `instanceof`
+ *   should return true when used in the EdgeVM realm.
+ *
+ * For example, the return value from `new TextEncoder().encode("hello")` is a
+ * Uint8Array. Since `TextEncoder` implementation is coming from the Node.js realm,
+ * therefore the following will be false, which doesn't fit the expectation of the user:
+ * ```ts
+ * new TextEncoder().encode("hello") instanceof Uint8Array
+ * ```
+ *
+ * This is because the `Uint8Array` in the `vm` context is not the same
+ * as the one in the Node.js realm.
+ *
+ * Patching the constructors in the `vm` is done by the {@link patchInstanceOf}
+ * function, and this is the list of constructors that need to be patched.
+ *
+ * These constructors are also being injected as "globals" when the VM is
+ * constructed, by passing them as arguments to the {@link loadPrimitives}
+ * function.
+ */
+const transferableConstructors = [
+    'Object',
+    'Array',
+    'RegExp',
+    'Uint8Array',
+    'ArrayBuffer',
+    'Error',
+    'SyntaxError',
+    'TypeError',
+];
+function patchInstanceOf(item, ctx) {
+    // @ts-ignore
+    ctx[Symbol.for(`node:${item}`)] = eval(item);
+    return (0, vm_1.runInContext)(`
+      globalThis.${item} = new Proxy(${item}, {
+        get(target, prop, receiver) {
+          if (prop === Symbol.hasInstance && receiver === globalThis.${item}) {
+            const nodeTarget = globalThis[Symbol.for('node:${item}')];
+            if (nodeTarget) {
+              return function(instance) {
+                return instance instanceof target || instance instanceof nodeTarget;
+              };
+            } else {
+              throw new Error('node target must exist')
+            }
+          }
+
+          return Reflect.get(target, prop, receiver);
+        }
+      })
+    `, ctx);
+}
+/**
+ * Register system-level handlers to make sure that we report to the user
+ * whenever there is an unhandled rejection or exception before the process crashes.
+ * Do it on demand so we don't swallow rejections/errors for no reason.
+ */
+function registerUnhandledRejectionHandlers(handlers) {
+    if (!unhandledRejectionHandlers) {
+        process.on('unhandledRejection', function invokeRejectionHandlers(reason, promise) {
+            unhandledRejectionHandlers.forEach((handler) => handler({ reason, promise }));
+        });
+    }
+    unhandledRejectionHandlers = handlers;
+}
+function registerUncaughtExceptionHandlers(handlers) {
+    if (!uncaughtExceptionHandlers) {
+        process.on('uncaughtException', function invokeErrorHandlers(error) {
+            uncaughtExceptionHandlers.forEach((handler) => handler(error));
+        });
+    }
+    uncaughtExceptionHandlers = handlers;
+}
+/**
+ * Generates polyfills for addEventListener and removeEventListener. It keeps
+ * all listeners in hidden property __listeners. It will also call a hook
+ * `__onUnhandledRejectionHandler` and `__onErrorHandler` when unhandled rejection
+ * events are added or removed and prevent from having more than one FetchEvent
+ * handler.
+ */
+function getDefineEventListenersCode() {
+    return `
+    Object.defineProperty(self, '__listeners', {
+      configurable: false,
+      enumerable: false,
+      value: {},
+      writable: true,
+    })
+
+    function __conditionallyUpdatesHandlerList(eventType) {
+      if (eventType === 'unhandledrejection') {
+        self.__onUnhandledRejectionHandlers = self.__listeners[eventType];
+      } else if (eventType === 'error') {
+        self.__onErrorHandlers = self.__listeners[eventType];
+      }
+    }
+
+    function addEventListener(type, handler) {
+      const eventType = type.toLowerCase();
+      if (eventType === 'fetch' && self.__listeners.fetch) {
+        throw new TypeError('You can register just one "fetch" event listener');
+      }
+
+      self.__listeners[eventType] = self.__listeners[eventType] || [];
+      self.__listeners[eventType].push(handler);
+      __conditionallyUpdatesHandlerList(eventType);
+    }
+
+    function removeEventListener(type, handler) {
+      const eventType = type.toLowerCase();
+      if (self.__listeners[eventType]) {
+        self.__listeners[eventType] = self.__listeners[eventType].filter(item => {
+          return item !== handler;
+        });
+
+        if (self.__listeners[eventType].length === 0) {
+          delete self.__listeners[eventType];
+        }
+      }
+      __conditionallyUpdatesHandlerList(eventType);
+    }
+  `;
+}
+/**
+ * Generates the code to dispatch a FetchEvent invoking the handlers defined
+ * for such events. In case there is no event handler defined it will throw
+ * an error.
+ */
+function getDispatchFetchCode() {
+    return `(async function dispatchFetch(input, init) {
+    const request = new Request(input, init);
+    const event = new FetchEvent(request);
+    if (!self.__listeners.fetch) {
+      throw new Error("No fetch event listeners found");
+    }
+
+    const getResponse = ({ response, error }) => {
+     if (error || !response || !(response instanceof Response)) {
+        console.error(error ? error.toString() : 'The event listener did not respond')
+        response = new Response(null, {
+          statusText: 'Internal Server Error',
+          status: 500
+        })
+      }
+
+      response.waitUntil = () => Promise.all(event.awaiting);
+
+      if (response.status < 300 || response.status >= 400 ) {
+        response.headers.delete('content-encoding');
+        response.headers.delete('transform-encoding');
+        response.headers.delete('content-length');
+      }
+
+      return response;
+    }
+
+    try {
+      await self.__listeners.fetch[0].call(event, event)
+    } catch (error) {
+      return getResponse({ error })
+    }
+
+    return Promise.resolve(event.response)
+      .then(response => getResponse({ response }))
+      .catch(error => getResponse({ error }))
+  })`;
+}
+function addPrimitives(context) {
+    defineProperty(context, 'self', { enumerable: true, value: context });
+    defineProperty(context, 'globalThis', { value: context });
+    defineProperty(context, 'Symbol', { value: Symbol });
+    defineProperty(context, 'clearInterval', { value: clearInterval });
+    defineProperty(context, 'clearTimeout', { value: clearTimeout });
+    defineProperty(context, 'queueMicrotask', { value: queueMicrotask });
+    defineProperty(context, 'EdgeRuntime', { value: 'edge-runtime' });
+    const transferables = getTransferablePrimitivesFromContext(context);
+    defineProperties(context, {
+        exports: (0, load_1.load)({
+            ...transferables,
+            WeakRef: (0, vm_1.runInContext)(`WeakRef`, context),
+        }),
+        enumerable: ['crypto'],
+        nonenumerable: [
+            // Crypto
+            'Crypto',
+            'CryptoKey',
+            'SubtleCrypto',
+            // Fetch APIs
+            'fetch',
+            'File',
+            'FormData',
+            'Headers',
+            'Request',
+            'Response',
+            'WebSocket',
+            // Structured Clone
+            'structuredClone',
+            // Blob
+            'Blob',
+            // URL
+            'URL',
+            'URLSearchParams',
+            'URLPattern',
+            // AbortController
+            'AbortController',
+            'AbortSignal',
+            'DOMException',
+            // Streams
+            'ReadableStream',
+            'ReadableStreamBYOBReader',
+            'ReadableStreamDefaultReader',
+            'TextDecoderStream',
+            'TextEncoderStream',
+            'TransformStream',
+            'WritableStream',
+            'WritableStreamDefaultWriter',
+            // Encoding
+            'atob',
+            'btoa',
+            'TextEncoder',
+            'TextDecoder',
+            // Events
+            'Event',
+            'EventTarget',
+            'FetchEvent',
+            'PromiseRejectionEvent',
+            // Console
+            'console',
+            // Performance
+            'performance',
+            // Timers
+            'setTimeout',
+            'setInterval',
+        ],
+    });
+    return context;
+}
+function defineProperty(obj, prop, attrs) {
+    var _a, _b, _c;
+    Object.defineProperty(obj, prop, {
+        configurable: (_a = attrs.configurable) !== null && _a !== void 0 ? _a : false,
+        enumerable: (_b = attrs.enumerable) !== null && _b !== void 0 ? _b : false,
+        value: attrs.value,
+        writable: (_c = attrs.writable) !== null && _c !== void 0 ? _c : true,
+    });
+}
+function defineProperties(context, options) {
+    var _a, _b;
+    for (const property of (_a = options.enumerable) !== null && _a !== void 0 ? _a : []) {
+        if (!options.exports[property]) {
+            throw new Error(`Attempt to export a nullable value for "${property}"`);
+        }
+        defineProperty(context, property, {
+            enumerable: true,
+            value: options.exports[property],
+        });
+    }
+    for (const property of (_b = options.nonenumerable) !== null && _b !== void 0 ? _b : []) {
+        if (!options.exports[property]) {
+            throw new Error(`Attempt to export a nullable value for "${property}"`);
+        }
+        defineProperty(context, property, {
+            value: options.exports[property],
+        });
+    }
+}
+/**
+ * Create an object that contains all the {@link transferableConstructors}
+ * implemented in the provided context.
+ */
+function getTransferablePrimitivesFromContext(context) {
+    const keys = transferableConstructors.join(',');
+    const stringifedObject = `({${keys}})`;
+    return (0, vm_1.runInContext)(stringifedObject, context);
+}
+//# sourceMappingURL=edge-vm.js.map

node_modules/@edge-runtime/vm/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { EdgeVMOptions, EdgeContext } from './edge-vm';
+export type { VMOptions, VMContext } from './vm';
+export { EdgeVM } from './edge-vm';
+export { VM } from './vm';

node_modules/@edge-runtime/vm/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VM = exports.EdgeVM = void 0;
+var edge_vm_1 = require("./edge-vm");
+Object.defineProperty(exports, "EdgeVM", { enumerable: true, get: function () { return edge_vm_1.EdgeVM; } });
+var vm_1 = require("./vm");
+Object.defineProperty(exports, "VM", { enumerable: true, get: function () { return vm_1.VM; } });
+//# sourceMappingURL=index.js.map

node_modules/@edge-runtime/vm/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAEA,qCAAkC;AAAzB,iGAAA,MAAM,OAAA;AACf,2BAAyB;AAAhB,wFAAA,EAAE,OAAA","sourcesContent":["export type { EdgeVMOptions, EdgeContext } from './edge-vm'\nexport type { VMOptions, VMContext } from './vm'\nexport { EdgeVM } from './edge-vm'\nexport { VM } from './vm'\n"]}

node_modules/@edge-runtime/vm/dist/types.d.ts

@@ -0,0 +1,11 @@
+export interface DispatchFetch {
+    (input: string, init?: RequestInit): Promise<Response & {
+        waitUntil: () => Promise<any>;
+    }>;
+}
+export interface RejectionHandler {
+    (reason?: {} | null, promise?: Promise<any>): void;
+}
+export interface ErrorHandler {
+    (error?: {} | null): void;
+}

node_modules/@edge-runtime/vm/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

node_modules/@edge-runtime/vm/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["export interface DispatchFetch {\n  (\n    input: string,\n    init?: RequestInit,\n  ): Promise<\n    Response & {\n      waitUntil: () => Promise<any>\n    }\n  >\n}\n\nexport interface RejectionHandler {\n  (reason?: {} | null, promise?: Promise<any>): void\n}\n\nexport interface ErrorHandler {\n  (error?: {} | null): void\n}\n"]}

node_modules/@edge-runtime/vm/dist/vm.d.ts

@@ -0,0 +1,82 @@
+/// <reference types="node" />
+import type { CreateContextOptions } from 'vm';
+export interface VMOptions<T> {
+    /**
+     * Provide code generation options to the Node.js VM.
+     * If you don't provide any option, code generation will be disabled.
+     */
+    codeGeneration?: CreateContextOptions['codeGeneration'];
+    /**
+     * Allows to extend the VMContext. Note that it must return a contextified
+     * object so ideally it should return the same reference it receives.
+     */
+    extend?: (context: VMContext) => VMContext & T;
+}
+/**
+ * A raw VM with a context that can be extended on instantiation. Implements
+ * a realm-like interface where one can evaluate code or require CommonJS
+ * modules in multiple ways.
+ */
+export declare class VM<T extends Record<string | number, any>> {
+    readonly context: VMContext & T;
+    constructor(options?: VMOptions<T>);
+    /**
+     * Allows to run arbitrary code within the VM.
+     */
+    evaluate<T = any>(code: string): T;
+}
+export interface VMContext {
+    Array: typeof Array;
+    ArrayBuffer: typeof ArrayBuffer;
+    Atomics: typeof Atomics;
+    BigInt: typeof BigInt;
+    BigInt64Array: typeof BigInt64Array;
+    BigUint64Array: typeof BigUint64Array;
+    Boolean: typeof Boolean;
+    DataView: typeof DataView;
+    Date: typeof Date;
+    decodeURI: typeof decodeURI;
+    decodeURIComponent: typeof decodeURIComponent;
+    encodeURI: typeof encodeURI;
+    encodeURIComponent: typeof encodeURIComponent;
+    Error: typeof Error;
+    EvalError: typeof EvalError;
+    Float32Array: typeof Float32Array;
+    Float64Array: typeof Float64Array;
+    Function: typeof Function;
+    Infinity: typeof Infinity;
+    Int8Array: typeof Int8Array;
+    Int16Array: typeof Int16Array;
+    Int32Array: typeof Int32Array;
+    Intl: typeof Intl;
+    isFinite: typeof isFinite;
+    isNaN: typeof isNaN;
+    JSON: typeof JSON;
+    Map: typeof Map;
+    Math: typeof Math;
+    Number: typeof Number;
+    Object: typeof Object;
+    parseFloat: typeof parseFloat;
+    parseInt: typeof parseInt;
+    Promise: typeof Promise;
+    Proxy: typeof Proxy;
+    RangeError: typeof RangeError;
+    ReferenceError: typeof ReferenceError;
+    Reflect: typeof Reflect;
+    RegExp: typeof RegExp;
+    Set: typeof Set;
+    SharedArrayBuffer: typeof SharedArrayBuffer;
+    String: typeof String;
+    Symbol: typeof Symbol;
+    SyntaxError: typeof SyntaxError;
+    TypeError: typeof TypeError;
+    Uint8Array: typeof Uint8Array;
+    Uint8ClampedArray: typeof Uint8ClampedArray;
+    Uint16Array: typeof Uint16Array;
+    Uint32Array: typeof Uint32Array;
+    URIError: typeof URIError;
+    WeakMap: typeof WeakMap;
+    WeakSet: typeof WeakSet;
+    WebAssembly: typeof WebAssembly;
+    [key: string | number]: any;
+}

node_modules/@edge-runtime/vm/dist/vm.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VM = void 0;
+const vm_1 = require("vm");
+/**
+ * A raw VM with a context that can be extended on instantiation. Implements
+ * a realm-like interface where one can evaluate code or require CommonJS
+ * modules in multiple ways.
+ */
+class VM {
+    constructor(options = {}) {
+        var _a, _b, _c;
+        const context = (0, vm_1.createContext)({}, {
+            name: 'Edge Runtime',
+            codeGeneration: (_a = options.codeGeneration) !== null && _a !== void 0 ? _a : {
+                strings: false,
+                wasm: true,
+            },
+        });
+        this.context = (_c = (_b = options.extend) === null || _b === void 0 ? void 0 : _b.call(options, context)) !== null && _c !== void 0 ? _c : context;
+    }
+    /**
+     * Allows to run arbitrary code within the VM.
+     */
+    evaluate(code) {
+        return (0, vm_1.runInContext)(code, this.context);
+    }
+}
+exports.VM = VM;
+//# sourceMappingURL=vm.js.map

node_modules/@edge-runtime/vm/dist/vm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vm.js","sourceRoot":"","sources":["../src/vm.ts"],"names":[],"mappings":";;;AACA,2BAAgD;AAehD;;;;GAIG;AACH,MAAa,EAAE;IAGb,YAAY,UAAwB,EAAE;;QACpC,MAAM,OAAO,GAAG,IAAA,kBAAa,EAC3B,EAAE,EACF;YACE,IAAI,EAAE,cAAc;YACpB,cAAc,EAAE,MAAA,OAAO,CAAC,cAAc,mCAAI;gBACxC,OAAO,EAAE,KAAK;gBACd,IAAI,EAAE,IAAI;aACX;SACF,CACW,CAAA;QAEd,IAAI,CAAC,OAAO,GAAG,MAAA,MAAA,OAAO,CAAC,MAAM,wDAAG,OAAO,CAAC,mCAAK,OAAyB,CAAA;IACxE,CAAC;IAED;;OAEG;IACH,QAAQ,CAAU,IAAY;QAC5B,OAAO,IAAA,iBAAY,EAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;IACzC,CAAC;CACF;AAxBD,gBAwBC","sourcesContent":["import type { CreateContextOptions } from 'vm'\nimport { createContext, runInContext } from 'vm'\n\nexport interface VMOptions<T> {\n  /**\n   * Provide code generation options to the Node.js VM.\n   * If you don't provide any option, code generation will be disabled.\n   */\n  codeGeneration?: CreateContextOptions['codeGeneration']\n  /**\n   * Allows to extend the VMContext. Note that it must return a contextified\n   * object so ideally it should return the same reference it receives.\n   */\n  extend?: (context: VMContext) => VMContext & T\n}\n\n/**\n * A raw VM with a context that can be extended on instantiation. Implements\n * a realm-like interface where one can evaluate code or require CommonJS\n * modules in multiple ways.\n */\nexport class VM<T extends Record<string | number, any>> {\n  public readonly context: VMContext & T\n\n  constructor(options: VMOptions<T> = {}) {\n    const context = createContext(\n      {},\n      {\n        name: 'Edge Runtime',\n        codeGeneration: options.codeGeneration ?? {\n          strings: false,\n          wasm: true,\n        },\n      },\n    ) as VMContext\n\n    this.context = options.extend?.(context) ?? (context as VMContext & T)\n  }\n\n  /**\n   * Allows to run arbitrary code within the VM.\n   */\n  evaluate<T = any>(code: string): T {\n    return runInContext(code, this.context)\n  }\n}\n\nexport interface VMContext {\n  Array: typeof Array\n  ArrayBuffer: typeof ArrayBuffer\n  Atomics: typeof Atomics\n  BigInt: typeof BigInt\n  BigInt64Array: typeof BigInt64Array\n  BigUint64Array: typeof BigUint64Array\n  Boolean: typeof Boolean\n  DataView: typeof DataView\n  Date: typeof Date\n  decodeURI: typeof decodeURI\n  decodeURIComponent: typeof decodeURIComponent\n  encodeURI: typeof encodeURI\n  encodeURIComponent: typeof encodeURIComponent\n  Error: typeof Error\n  EvalError: typeof EvalError\n  Float32Array: typeof Float32Array\n  Float64Array: typeof Float64Array\n  Function: typeof Function\n  Infinity: typeof Infinity\n  Int8Array: typeof Int8Array\n  Int16Array: typeof Int16Array\n  Int32Array: typeof Int32Array\n  Intl: typeof Intl\n  isFinite: typeof isFinite\n  isNaN: typeof isNaN\n  JSON: typeof JSON\n  Map: typeof Map\n  Math: typeof Math\n  Number: typeof Number\n  Object: typeof Object\n  parseFloat: typeof parseFloat\n  parseInt: typeof parseInt\n  Promise: typeof Promise\n  Proxy: typeof Proxy\n  RangeError: typeof RangeError\n  ReferenceError: typeof ReferenceError\n  Reflect: typeof Reflect\n  RegExp: typeof RegExp\n  Set: typeof Set\n  SharedArrayBuffer: typeof SharedArrayBuffer\n  String: typeof String\n  Symbol: typeof Symbol\n  SyntaxError: typeof SyntaxError\n  TypeError: typeof TypeError\n  Uint8Array: typeof Uint8Array\n  Uint8ClampedArray: typeof Uint8ClampedArray\n  Uint16Array: typeof Uint16Array\n  Uint32Array: typeof Uint32Array\n  URIError: typeof URIError\n  WeakMap: typeof WeakMap\n  WeakSet: typeof WeakSet\n  WebAssembly: typeof WebAssembly\n  [key: string | number]: any\n}\n"]}

node_modules/@edge-runtime/vm/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@edge-runtime/vm",
+  "description": "Low level bindings for creating Web Standard contexts.",
+  "homepage": "https://edge-runtime.vercel.app/packages/vm",
+  "version": "3.2.0",
+  "main": "dist/index.js",
+  "repository": {
+    "directory": "packages/vm",
+    "type": "git",
+    "url": "git+https://github.com/vercel/edge-runtime.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vercel/edge-runtime/issues"
+  },
+  "keywords": [
+    "context",
+    "edge",
+    "edge-runtime",
+    "functions",
+    "runtime",
+    "standard",
+    "vm",
+    "web"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MPL-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@edge-runtime/primitives": "4.1.0"
+  },
+  "devDependencies": {
+    "@types/test-listen": "1.1.2",
+    "@types/ws": "8.5.10",
+    "test-listen": "1.1.0",
+    "ws": "8.16.0"
+  },
+  "scripts": {
+    "build": "tsc --project ./tsconfig.prod.json",
+    "clean": "pnpm run clean:node && pnpm run clean:build",
+    "clean:build": "rm -rf dist",
+    "clean:node": "rm -rf node_modules",
+    "test": "jest"
+  }
+}