antigravity-mobile-proxy 0.1.2 → 0.1.4

package/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/generated/ffi.WASM_RELEASE_SYNC.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuickJSFFI = void 0;
-/**
- * Low-level FFI bindings to QuickJS's Emscripten module.
- * See instead [[QuickJSContext]], the public Javascript interface exposed by this
- * library.
- *
- * @unstable The FFI interface is considered private and may change.
- */
-class QuickJSFFI {
-    constructor(module) {
-        this.module = module;
-        /** Set at compile time. */
-        this.DEBUG = false;
-        this.QTS_Throw = this.module.cwrap("QTS_Throw", "number", ["number", "number"]);
-        this.QTS_NewError = this.module.cwrap("QTS_NewError", "number", ["number"]);
-        this.QTS_RuntimeSetMemoryLimit = this.module.cwrap("QTS_RuntimeSetMemoryLimit", null, ["number", "number"]);
-        this.QTS_RuntimeComputeMemoryUsage = this.module.cwrap("QTS_RuntimeComputeMemoryUsage", "number", ["number", "number"]);
-        this.QTS_RuntimeDumpMemoryUsage = this.module.cwrap("QTS_RuntimeDumpMemoryUsage", "number", ["number"]);
-        this.QTS_RecoverableLeakCheck = this.module.cwrap("QTS_RecoverableLeakCheck", "number", []);
-        this.QTS_BuildIsSanitizeLeak = this.module.cwrap("QTS_BuildIsSanitizeLeak", "number", []);
-        this.QTS_RuntimeSetMaxStackSize = this.module.cwrap("QTS_RuntimeSetMaxStackSize", null, ["number", "number"]);
-        this.QTS_GetUndefined = this.module.cwrap("QTS_GetUndefined", "number", []);
-        this.QTS_GetNull = this.module.cwrap("QTS_GetNull", "number", []);
-        this.QTS_GetFalse = this.module.cwrap("QTS_GetFalse", "number", []);
-        this.QTS_GetTrue = this.module.cwrap("QTS_GetTrue", "number", []);
-        this.QTS_NewRuntime = this.module.cwrap("QTS_NewRuntime", "number", []);
-        this.QTS_FreeRuntime = this.module.cwrap("QTS_FreeRuntime", null, ["number"]);
-        this.QTS_NewContext = this.module.cwrap("QTS_NewContext", "number", ["number"]);
-        this.QTS_FreeContext = this.module.cwrap("QTS_FreeContext", null, ["number"]);
-        this.QTS_FreeValuePointer = this.module.cwrap("QTS_FreeValuePointer", null, ["number", "number"]);
-        this.QTS_FreeValuePointerRuntime = this.module.cwrap("QTS_FreeValuePointerRuntime", null, ["number", "number"]);
-        this.QTS_FreeVoidPointer = this.module.cwrap("QTS_FreeVoidPointer", null, ["number", "number"]);
-        this.QTS_FreeCString = this.module.cwrap("QTS_FreeCString", null, ["number", "number"]);
-        this.QTS_DupValuePointer = this.module.cwrap("QTS_DupValuePointer", "number", ["number", "number"]);
-        this.QTS_NewObject = this.module.cwrap("QTS_NewObject", "number", ["number"]);
-        this.QTS_NewObjectProto = this.module.cwrap("QTS_NewObjectProto", "number", ["number", "number"]);
-        this.QTS_NewArray = this.module.cwrap("QTS_NewArray", "number", ["number"]);
-        this.QTS_NewFloat64 = this.module.cwrap("QTS_NewFloat64", "number", ["number", "number"]);
-        this.QTS_GetFloat64 = this.module.cwrap("QTS_GetFloat64", "number", ["number", "number"]);
-        this.QTS_NewString = this.module.cwrap("QTS_NewString", "number", ["number", "number"]);
-        this.QTS_GetString = this.module.cwrap("QTS_GetString", "number", ["number", "number"]);
-        this.QTS_NewSymbol = this.module.cwrap("QTS_NewSymbol", "number", ["number", "number", "number"]);
-        this.QTS_GetSymbolDescriptionOrKey = this.module.cwrap("QTS_GetSymbolDescriptionOrKey", "number", ["number", "number"]);
-        this.QTS_IsGlobalSymbol = this.module.cwrap("QTS_IsGlobalSymbol", "number", ["number", "number"]);
-        this.QTS_IsJobPending = this.module.cwrap("QTS_IsJobPending", "number", ["number"]);
-        this.QTS_ExecutePendingJob = this.module.cwrap("QTS_ExecutePendingJob", "number", ["number", "number", "number"]);
-        this.QTS_GetProp = this.module.cwrap("QTS_GetProp", "number", ["number", "number", "number"]);
-        this.QTS_SetProp = this.module.cwrap("QTS_SetProp", null, ["number", "number", "number", "number"]);
-        this.QTS_DefineProp = this.module.cwrap("QTS_DefineProp", null, ["number", "number", "number", "number", "number", "number", "boolean", "boolean", "boolean"]);
-        this.QTS_Call = this.module.cwrap("QTS_Call", "number", ["number", "number", "number", "number", "number"]);
-        this.QTS_ResolveException = this.module.cwrap("QTS_ResolveException", "number", ["number", "number"]);
-        this.QTS_Dump = this.module.cwrap("QTS_Dump", "number", ["number", "number"]);
-        this.QTS_Eval = this.module.cwrap("QTS_Eval", "number", ["number", "number", "string", "number", "number"]);
-        this.QTS_Typeof = this.module.cwrap("QTS_Typeof", "number", ["number", "number"]);
-        this.QTS_GetGlobalObject = this.module.cwrap("QTS_GetGlobalObject", "number", ["number"]);
-        this.QTS_NewPromiseCapability = this.module.cwrap("QTS_NewPromiseCapability", "number", ["number", "number"]);
-        this.QTS_TestStringArg = this.module.cwrap("QTS_TestStringArg", null, ["string"]);
-        this.QTS_BuildIsDebug = this.module.cwrap("QTS_BuildIsDebug", "number", []);
-        this.QTS_BuildIsAsyncify = this.module.cwrap("QTS_BuildIsAsyncify", "number", []);
-        this.QTS_NewFunction = this.module.cwrap("QTS_NewFunction", "number", ["number", "number", "string"]);
-        this.QTS_ArgvGetJSValueConstPointer = this.module.cwrap("QTS_ArgvGetJSValueConstPointer", "number", ["number", "number"]);
-        this.QTS_RuntimeEnableInterruptHandler = this.module.cwrap("QTS_RuntimeEnableInterruptHandler", null, ["number"]);
-        this.QTS_RuntimeDisableInterruptHandler = this.module.cwrap("QTS_RuntimeDisableInterruptHandler", null, ["number"]);
-        this.QTS_RuntimeEnableModuleLoader = this.module.cwrap("QTS_RuntimeEnableModuleLoader", null, ["number", "number"]);
-        this.QTS_RuntimeDisableModuleLoader = this.module.cwrap("QTS_RuntimeDisableModuleLoader", null, ["number"]);
-    }
-}
-exports.QuickJSFFI = QuickJSFFI;
-//# sourceMappingURL=ffi.WASM_RELEASE_SYNC.js.map

package/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/index.js

@@ -1,128 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldInterruptAfterDeadline = exports.newAsyncContext = exports.newAsyncRuntime = exports.getQuickJSSync = exports.getQuickJS = exports.errors = exports.RELEASE_SYNC = exports.RELEASE_ASYNC = exports.DEBUG_SYNC = exports.DEBUG_ASYNC = exports.newQuickJSAsyncWASMModule = exports.newQuickJSWASMModule = void 0;
-// Build variants
-const variants_1 = require("./variants");
-Object.defineProperty(exports, "newQuickJSWASMModule", { enumerable: true, get: function () { return variants_1.newQuickJSWASMModule; } });
-Object.defineProperty(exports, "newQuickJSAsyncWASMModule", { enumerable: true, get: function () { return variants_1.newQuickJSAsyncWASMModule; } });
-Object.defineProperty(exports, "DEBUG_ASYNC", { enumerable: true, get: function () { return variants_1.DEBUG_ASYNC; } });
-Object.defineProperty(exports, "DEBUG_SYNC", { enumerable: true, get: function () { return variants_1.DEBUG_SYNC; } });
-Object.defineProperty(exports, "RELEASE_ASYNC", { enumerable: true, get: function () { return variants_1.RELEASE_ASYNC; } });
-Object.defineProperty(exports, "RELEASE_SYNC", { enumerable: true, get: function () { return variants_1.RELEASE_SYNC; } });
-// Export helpers
-__exportStar(require("./vm-interface"), exports);
-__exportStar(require("./lifetime"), exports);
-/** Collects the informative errors this library may throw. */
-exports.errors = __importStar(require("./errors"));
-__exportStar(require("./deferred-promise"), exports);
-__exportStar(require("./module-test"), exports);
-let singleton = undefined;
-let singletonPromise = undefined;
-/**
- * Get a shared singleton {@link QuickJSWASMModule}. Use this to evaluate code
- * or create Javascript environments.
- *
- * This is the top-level entrypoint for the quickjs-emscripten library.
- *
- * If you need strictest possible isolation guarantees, you may create a
- * separate {@link QuickJSWASMModule} via {@link newQuickJSWASMModule}.
- *
- * To work with the asyncified version of this library, see these functions:
- *
- * - {@link newAsyncRuntime}.
- * - {@link newAsyncContext}.
- * - {@link newQuickJSAsyncWASMModule}.
- */
-async function getQuickJS() {
-    singletonPromise ?? (singletonPromise = (0, variants_1.newQuickJSWASMModule)().then((instance) => {
-        singleton = instance;
-        return instance;
-    }));
-    return await singletonPromise;
-}
-exports.getQuickJS = getQuickJS;
-/**
- * Provides synchronous access to the shared {@link QuickJSWASMModule} instance returned by {@link getQuickJS}, as long as
- * least once.
- * @throws If called before `getQuickJS` resolves.
- */
-function getQuickJSSync() {
-    if (!singleton) {
-        throw new Error("QuickJS not initialized. Await getQuickJS() at least once.");
-    }
-    return singleton;
-}
-exports.getQuickJSSync = getQuickJSSync;
-/**
- * Create a new [[QuickJSAsyncRuntime]] in a separate WebAssembly module.
- *
- * Each runtime is isolated in a separate WebAssembly module, so that errors in
- * one runtime cannot contaminate another runtime, and each runtime can execute
- * an asynchronous action without conflicts.
- *
- * Note that there is a hard limit on the number of WebAssembly modules in older
- * versions of v8:
- * https://bugs.chromium.org/p/v8/issues/detail?id=12076
- */
-async function newAsyncRuntime(options) {
-    const module = await (0, variants_1.newQuickJSAsyncWASMModule)();
-    return module.newRuntime(options);
-}
-exports.newAsyncRuntime = newAsyncRuntime;
-/**
- * Create a new [[QuickJSAsyncContext]] (with an associated runtime) in an
- * separate WebAssembly module.
- *
- * Each context is isolated in a separate WebAssembly module, so that errors in
- * one runtime cannot contaminate another runtime, and each runtime can execute
- * an asynchronous action without conflicts.
- *
- * Note that there is a hard limit on the number of WebAssembly modules in older
- * versions of v8:
- * https://bugs.chromium.org/p/v8/issues/detail?id=12076
- */
-async function newAsyncContext(options) {
-    const module = await (0, variants_1.newQuickJSAsyncWASMModule)();
-    return module.newContext(options);
-}
-exports.newAsyncContext = newAsyncContext;
-/**
- * Returns an interrupt handler that interrupts Javascript execution after a deadline time.
- *
- * @param deadline - Interrupt execution if it's still running after this time.
- *   Number values are compared against `Date.now()`
- */
-function shouldInterruptAfterDeadline(deadline) {
-    const deadlineAsNumber = typeof deadline === "number" ? deadline : deadline.getTime();
-    return function () {
-        return Date.now() > deadlineAsNumber;
-    };
-}
-exports.shouldInterruptAfterDeadline = shouldInterruptAfterDeadline;
-//# sourceMappingURL=index.js.map

package/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/lifetime.js

@@ -1,227 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Scope = exports.WeakLifetime = exports.StaticLifetime = exports.Lifetime = void 0;
-const asyncify_helpers_1 = require("./asyncify-helpers");
-const debug_1 = require("./debug");
-const errors_1 = require("./errors");
-/**
- * A lifetime prevents access to a value after the lifetime has been
- * [[dispose]]ed.
- *
- * Typically, quickjs-emscripten uses Lifetimes to protect C memory pointers.
- */
-class Lifetime {
-    /**
-     * When the Lifetime is disposed, it will call `disposer(_value)`. Use the
-     * disposer function to implement whatever cleanup needs to happen at the end
-     * of `value`'s lifetime.
-     *
-     * `_owner` is not used or controlled by the lifetime. It's just metadata for
-     * the creator.
-     */
-    constructor(_value, copier, disposer, _owner) {
-        this._value = _value;
-        this.copier = copier;
-        this.disposer = disposer;
-        this._owner = _owner;
-        this._alive = true;
-        this._constructorStack = debug_1.QTS_DEBUG ? new Error("Lifetime constructed").stack : undefined;
-    }
-    get alive() {
-        return this._alive;
-    }
-    /**
-     * The value this Lifetime protects. You must never retain the value - it
-     * may become invalid, leading to memory errors.
-     *
-     * @throws If the lifetime has been [[dispose]]d already.
-     */
-    get value() {
-        this.assertAlive();
-        return this._value;
-    }
-    get owner() {
-        return this._owner;
-    }
-    get dupable() {
-        return !!this.copier;
-    }
-    /**
-     * Create a new handle pointing to the same [[value]].
-     */
-    dup() {
-        this.assertAlive();
-        if (!this.copier) {
-            throw new Error("Non-dupable lifetime");
-        }
-        return new Lifetime(this.copier(this._value), this.copier, this.disposer, this._owner);
-    }
-    consume(map) {
-        this.assertAlive();
-        const result = map(this);
-        this.dispose();
-        return result;
-    }
-    /**
-     * Dispose of [[value]] and perform cleanup.
-     */
-    dispose() {
-        this.assertAlive();
-        if (this.disposer) {
-            this.disposer(this._value);
-        }
-        this._alive = false;
-    }
-    assertAlive() {
-        if (!this.alive) {
-            if (this._constructorStack) {
-                throw new errors_1.QuickJSUseAfterFree(`Lifetime not alive\n${this._constructorStack}\nLifetime used`);
-            }
-            throw new errors_1.QuickJSUseAfterFree("Lifetime not alive");
-        }
-    }
-}
-exports.Lifetime = Lifetime;
-/**
- * A Lifetime that lives forever. Used for constants.
- */
-class StaticLifetime extends Lifetime {
-    constructor(value, owner) {
-        super(value, undefined, undefined, owner);
-    }
-    // Static lifetime doesn't need a copier to be copiable
-    get dupable() {
-        return true;
-    }
-    // Copy returns the same instance.
-    dup() {
-        return this;
-    }
-    // Dispose does nothing.
-    dispose() { }
-}
-exports.StaticLifetime = StaticLifetime;
-/**
- * A Lifetime that does not own its `value`. A WeakLifetime never calls its
- * `disposer` function, but can be `dup`ed to produce regular lifetimes that
- * do.
- *
- * Used for function arguments.
- */
-class WeakLifetime extends Lifetime {
-    constructor(value, copier, disposer, owner) {
-        // We don't care if the disposer doesn't support freeing T
-        super(value, copier, disposer, owner);
-    }
-    dispose() {
-        this._alive = false;
-    }
-}
-exports.WeakLifetime = WeakLifetime;
-function scopeFinally(scope, blockError) {
-    // console.log('scopeFinally', scope, blockError)
-    let disposeError;
-    try {
-        scope.dispose();
-    }
-    catch (error) {
-        disposeError = error;
-    }
-    if (blockError && disposeError) {
-        Object.assign(blockError, {
-            message: `${blockError.message}\n Then, failed to dispose scope: ${disposeError.message}`,
-            disposeError,
-        });
-        throw blockError;
-    }
-    if (blockError || disposeError) {
-        throw blockError || disposeError;
-    }
-}
-/**
- * Scope helps reduce the burden of manually tracking and disposing of
- * Lifetimes. See [[withScope]]. and [[withScopeAsync]].
- */
-class Scope {
-    constructor() {
-        this._disposables = new Lifetime(new Set());
-    }
-    /**
-     * Run `block` with a new Scope instance that will be disposed after the block returns.
-     * Inside `block`, call `scope.manage` on each lifetime you create to have the lifetime
-     * automatically disposed after the block returns.
-     *
-     * @warning Do not use with async functions. Instead, use [[withScopeAsync]].
-     */
-    static withScope(block) {
-        const scope = new Scope();
-        let blockError;
-        try {
-            return block(scope);
-        }
-        catch (error) {
-            blockError = error;
-            throw error;
-        }
-        finally {
-            scopeFinally(scope, blockError);
-        }
-    }
-    static withScopeMaybeAsync(_this, block) {
-        return (0, asyncify_helpers_1.maybeAsync)(undefined, function* (awaited) {
-            const scope = new Scope();
-            let blockError;
-            try {
-                return yield* awaited.of(block.call(_this, awaited, scope));
-            }
-            catch (error) {
-                blockError = error;
-                throw error;
-            }
-            finally {
-                scopeFinally(scope, blockError);
-            }
-        });
-    }
-    /**
-     * Run `block` with a new Scope instance that will be disposed after the
-     * block's returned promise settles. Inside `block`, call `scope.manage` on each
-     * lifetime you create to have the lifetime automatically disposed after the
-     * block returns.
-     */
-    static async withScopeAsync(block) {
-        const scope = new Scope();
-        let blockError;
-        try {
-            return await block(scope);
-        }
-        catch (error) {
-            blockError = error;
-            throw error;
-        }
-        finally {
-            scopeFinally(scope, blockError);
-        }
-    }
-    /**
-     * Track `lifetime` so that it is disposed when this scope is disposed.
-     */
-    manage(lifetime) {
-        this._disposables.value.add(lifetime);
-        return lifetime;
-    }
-    get alive() {
-        return this._disposables.alive;
-    }
-    dispose() {
-        const lifetimes = Array.from(this._disposables.value.values()).reverse();
-        for (const lifetime of lifetimes) {
-            if (lifetime.alive) {
-                lifetime.dispose();
-            }
-        }
-        this._disposables.dispose();
-    }
-}
-exports.Scope = Scope;
-//# sourceMappingURL=lifetime.js.map

package/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/memory.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleMemory = void 0;
-const lifetime_1 = require("./lifetime");
-/**
- * @private
- */
-class ModuleMemory {
-    constructor(module) {
-        this.module = module;
-    }
-    toPointerArray(handleArray) {
-        const typedArray = new Int32Array(handleArray.map((handle) => handle.value));
-        const numBytes = typedArray.length * typedArray.BYTES_PER_ELEMENT;
-        const ptr = this.module._malloc(numBytes);
-        var heapBytes = new Uint8Array(this.module.HEAPU8.buffer, ptr, numBytes);
-        heapBytes.set(new Uint8Array(typedArray.buffer));
-        return new lifetime_1.Lifetime(ptr, undefined, (ptr) => this.module._free(ptr));
-    }
-    newMutablePointerArray(length) {
-        const zeros = new Int32Array(new Array(length).fill(0));
-        const numBytes = zeros.length * zeros.BYTES_PER_ELEMENT;
-        const ptr = this.module._malloc(numBytes);
-        const typedArray = new Int32Array(this.module.HEAPU8.buffer, ptr, length);
-        typedArray.set(zeros);
-        return new lifetime_1.Lifetime({ typedArray, ptr }, undefined, (value) => this.module._free(value.ptr));
-    }
-    newHeapCharPointer(string) {
-        const numBytes = this.module.lengthBytesUTF8(string) + 1;
-        const ptr = this.module._malloc(numBytes);
-        this.module.stringToUTF8(string, ptr, numBytes);
-        return new lifetime_1.Lifetime(ptr, undefined, (value) => this.module._free(value));
-    }
-    consumeHeapCharPointer(ptr) {
-        const str = this.module.UTF8ToString(ptr);
-        this.module._free(ptr);
-        return str;
-    }
-}
-exports.ModuleMemory = ModuleMemory;
-//# sourceMappingURL=memory.js.map

package/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/module-asyncify.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuickJSAsyncWASMModule = void 0;
-const errors_1 = require("./errors");
-const lifetime_1 = require("./lifetime");
-const module_1 = require("./module");
-const runtime_asyncify_1 = require("./runtime-asyncify");
-/**
- * Asyncified version of [[QuickJSWASMModule]].
- *
- * Due to limitations of Emscripten's ASYNCIFY process, only a single async
- * function call can happen at a time across the entire WebAssembly module.
- *
- * That means that all runtimes, contexts, functions, etc created inside this
- * WebAssembly are limited to a single concurrent async action.
- * **Multiple concurrent async actions is an error.**
- *
- * To allow for multiple concurrent async actions, you must create multiple WebAssembly
- * modules.
- */
-class QuickJSAsyncWASMModule extends module_1.QuickJSWASMModule {
-    /** @private */
-    constructor(module, ffi) {
-        super(module, ffi);
-        this.ffi = ffi;
-        this.module = module;
-    }
-    /**
-     * Create a new async runtime inside this WebAssembly module. All runtimes inside a
-     * module are limited to a single async call at a time. For multiple
-     * concurrent async actions, create multiple WebAssembly modules.
-     */
-    newRuntime(options = {}) {
-        const rt = new lifetime_1.Lifetime(this.ffi.QTS_NewRuntime(), undefined, (rt_ptr) => {
-            this.callbacks.deleteRuntime(rt_ptr);
-            this.ffi.QTS_FreeRuntime(rt_ptr);
-        });
-        const runtime = new runtime_asyncify_1.QuickJSAsyncRuntime({
-            module: this.module,
-            ffi: this.ffi,
-            rt,
-            callbacks: this.callbacks,
-        });
-        (0, module_1.applyBaseRuntimeOptions)(runtime, options);
-        if (options.moduleLoader) {
-            runtime.setModuleLoader(options.moduleLoader);
-        }
-        return runtime;
-    }
-    /**
-     * A simplified API to create a new [[QuickJSRuntime]] and a
-     * [[QuickJSContext]] inside that runtime at the same time. The runtime will
-     * be disposed when the context is disposed.
-     */
-    newContext(options = {}) {
-        const runtime = this.newRuntime();
-        const lifetimes = options.ownedLifetimes ? options.ownedLifetimes.concat([runtime]) : [runtime];
-        const context = runtime.newContext({ ...options, ownedLifetimes: lifetimes });
-        runtime.context = context;
-        return context;
-    }
-    /** Synchronous evalCode is not supported. */
-    evalCode() {
-        throw new errors_1.QuickJSNotImplemented("QuickJSWASMModuleAsyncify.evalCode: use evalCodeAsync instead");
-    }
-    /**
-     * One-off evaluate code without needing to create a [[QuickJSRuntimeAsync]] or
-     * [[QuickJSContextSync]] explicitly.
-     *
-     * This version allows for asynchronous Ecmascript module loading.
-     *
-     * Note that only a single async action can occur at a time inside the entire WebAssembly module.
-     * **Multiple concurrent async actions is an error.**
-     *
-     * See the documentation for [[QuickJSWASMModule.evalCode]] for more details.
-     */
-    evalCodeAsync(code, options) {
-        // TODO: we should really figure out generator for the Promise monad...
-        return lifetime_1.Scope.withScopeAsync(async (scope) => {
-            const vm = scope.manage(this.newContext());
-            (0, module_1.applyModuleEvalRuntimeOptions)(vm.runtime, options);
-            const result = await vm.evalCodeAsync(code, "eval.js");
-            if (options.memoryLimitBytes !== undefined) {
-                // Remove memory limit so we can dump the result without exceeding it.
-                vm.runtime.setMemoryLimit(-1);
-            }
-            if (result.error) {
-                const error = vm.dump(scope.manage(result.error));
-                throw error;
-            }
-            const value = vm.dump(scope.manage(result.value));
-            return value;
-        });
-    }
-}
-exports.QuickJSAsyncWASMModule = QuickJSAsyncWASMModule;
-//# sourceMappingURL=module-asyncify.js.map

package/.next/standalone/node_modules/@tootallnate/quickjs-emscripten/dist/module-test.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestQuickJSWASMModule = void 0;
-const errors_1 = require("./errors");
-const lifetime_1 = require("./lifetime");
-/**
- * A test wrapper of [[QuickJSWASMModule]] that keeps a reference to each
- * context or runtime created.
- *
- * Call [[disposeAll]] to reset these sets and calls `dispose` on any left alive
- * (which may throw an error).
- *
- * Call [[assertNoMemoryAllocated]] at the end of a test, when you expect that you've
- * freed all the memory you've ever allocated.
- */
-class TestQuickJSWASMModule {
-    constructor(parent) {
-        this.parent = parent;
-        this.contexts = new Set();
-        this.runtimes = new Set();
-    }
-    newRuntime(options) {
-        const runtime = this.parent.newRuntime({
-            ...options,
-            ownedLifetimes: [
-                new lifetime_1.Lifetime(undefined, undefined, () => this.runtimes.delete(runtime)),
-                ...(options?.ownedLifetimes ?? []),
-            ],
-        });
-        this.runtimes.add(runtime);
-        return runtime;
-    }
-    newContext(options) {
-        const context = this.parent.newContext({
-            ...options,
-            ownedLifetimes: [
-                new lifetime_1.Lifetime(undefined, undefined, () => this.contexts.delete(context)),
-                ...(options?.ownedLifetimes ?? []),
-            ],
-        });
-        this.contexts.add(context);
-        return context;
-    }
-    evalCode(code, options) {
-        return this.parent.evalCode(code, options);
-    }
-    disposeAll() {
-        const allDisposables = [...this.contexts, ...this.runtimes];
-        this.runtimes.clear();
-        this.contexts.clear();
-        allDisposables.forEach((d) => {
-            if (d.alive) {
-                d.dispose();
-            }
-        });
-    }
-    assertNoMemoryAllocated() {
-        const leaksDetected = this.getFFI().QTS_RecoverableLeakCheck();
-        if (leaksDetected) {
-            // Note: this is currently only available when building from source
-            // with debug builds.
-            throw new errors_1.QuickJSMemoryLeakDetected("Leak sanitizer detected un-freed memory");
-        }
-        if (this.contexts.size > 0) {
-            throw new errors_1.QuickJSMemoryLeakDetected(`${this.contexts.size} contexts leaked`);
-        }
-        if (this.runtimes.size > 0) {
-            throw new errors_1.QuickJSMemoryLeakDetected(`${this.runtimes.size} runtimes leaked`);
-        }
-    }
-    /** @private */
-    getFFI() {
-        return this.parent.getFFI();
-    }
-}
-exports.TestQuickJSWASMModule = TestQuickJSWASMModule;
-//# sourceMappingURL=module-test.js.map