antigravity-mobile-proxy 0.1.2 → 0.1.4

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

@@ -1,302 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuickJSWASMModule = exports.applyModuleEvalRuntimeOptions = exports.applyBaseRuntimeOptions = exports.QuickJSModuleCallbacks = void 0;
-const debug_1 = require("./debug");
-const errors_1 = require("./errors");
-const lifetime_1 = require("./lifetime");
-const runtime_1 = require("./runtime");
-const types_1 = require("./types");
-class QuickJSEmscriptenModuleCallbacks {
-    constructor(args) {
-        this.callFunction = args.callFunction;
-        this.shouldInterrupt = args.shouldInterrupt;
-        this.loadModuleSource = args.loadModuleSource;
-        this.normalizeModule = args.normalizeModule;
-    }
-}
-/**
- * We use static functions per module to dispatch runtime or context calls from
- * C to the host.  This class manages the indirection from a specific runtime or
- * context pointer to the appropriate callback handler.
- *
- * @private
- */
-class QuickJSModuleCallbacks {
-    constructor(module) {
-        this.contextCallbacks = new Map();
-        this.runtimeCallbacks = new Map();
-        this.suspendedCount = 0;
-        this.cToHostCallbacks = new QuickJSEmscriptenModuleCallbacks({
-            callFunction: (asyncify, ctx, this_ptr, argc, argv, fn_id) => this.handleAsyncify(asyncify, () => {
-                try {
-                    const vm = this.contextCallbacks.get(ctx);
-                    if (!vm) {
-                        throw new Error(`QuickJSContext(ctx = ${ctx}) not found for C function call "${fn_id}"`);
-                    }
-                    return vm.callFunction(ctx, this_ptr, argc, argv, fn_id);
-                }
-                catch (error) {
-                    console.error("[C to host error: returning null]", error);
-                    return 0;
-                }
-            }),
-            shouldInterrupt: (asyncify, rt) => this.handleAsyncify(asyncify, () => {
-                try {
-                    const vm = this.runtimeCallbacks.get(rt);
-                    if (!vm) {
-                        throw new Error(`QuickJSRuntime(rt = ${rt}) not found for C interrupt`);
-                    }
-                    return vm.shouldInterrupt(rt);
-                }
-                catch (error) {
-                    console.error("[C to host interrupt: returning error]", error);
-                    return 1;
-                }
-            }),
-            loadModuleSource: (asyncify, rt, ctx, moduleName) => this.handleAsyncify(asyncify, () => {
-                try {
-                    const runtimeCallbacks = this.runtimeCallbacks.get(rt);
-                    if (!runtimeCallbacks) {
-                        throw new Error(`QuickJSRuntime(rt = ${rt}) not found for C module loader`);
-                    }
-                    const loadModule = runtimeCallbacks.loadModuleSource;
-                    if (!loadModule) {
-                        throw new Error(`QuickJSRuntime(rt = ${rt}) does not support module loading`);
-                    }
-                    return loadModule(rt, ctx, moduleName);
-                }
-                catch (error) {
-                    console.error("[C to host module loader error: returning null]", error);
-                    return 0;
-                }
-            }),
-            normalizeModule: (asyncify, rt, ctx, moduleBaseName, moduleName) => this.handleAsyncify(asyncify, () => {
-                try {
-                    const runtimeCallbacks = this.runtimeCallbacks.get(rt);
-                    if (!runtimeCallbacks) {
-                        throw new Error(`QuickJSRuntime(rt = ${rt}) not found for C module loader`);
-                    }
-                    const normalizeModule = runtimeCallbacks.normalizeModule;
-                    if (!normalizeModule) {
-                        throw new Error(`QuickJSRuntime(rt = ${rt}) does not support module loading`);
-                    }
-                    return normalizeModule(rt, ctx, moduleBaseName, moduleName);
-                }
-                catch (error) {
-                    console.error("[C to host module loader error: returning null]", error);
-                    return 0;
-                }
-            }),
-        });
-        this.module = module;
-        this.module.callbacks = this.cToHostCallbacks;
-    }
-    setRuntimeCallbacks(rt, callbacks) {
-        this.runtimeCallbacks.set(rt, callbacks);
-    }
-    deleteRuntime(rt) {
-        this.runtimeCallbacks.delete(rt);
-    }
-    setContextCallbacks(ctx, callbacks) {
-        this.contextCallbacks.set(ctx, callbacks);
-    }
-    deleteContext(ctx) {
-        this.contextCallbacks.delete(ctx);
-    }
-    handleAsyncify(asyncify, fn) {
-        if (asyncify) {
-            // We must always call asyncify.handleSync around our function.
-            // This allows asyncify to resume suspended execution on the second call.
-            // Asyncify internally can detect sync behavior, and avoid suspending.
-            return asyncify.handleSleep((done) => {
-                try {
-                    const result = fn();
-                    if (!(result instanceof Promise)) {
-                        (0, debug_1.debugLog)("asyncify.handleSleep: not suspending:", result);
-                        done(result);
-                        return;
-                    }
-                    // Is promise, we intend to suspend.
-                    if (this.suspended) {
-                        throw new errors_1.QuickJSAsyncifyError(`Already suspended at: ${this.suspended.stack}\nAttempted to suspend at:`);
-                    }
-                    else {
-                        this.suspended = new errors_1.QuickJSAsyncifySuspended(`(${this.suspendedCount++})`);
-                        (0, debug_1.debugLog)("asyncify.handleSleep: suspending:", this.suspended);
-                    }
-                    result.then((resolvedResult) => {
-                        this.suspended = undefined;
-                        (0, debug_1.debugLog)("asyncify.handleSleep: resolved:", resolvedResult);
-                        done(resolvedResult);
-                    }, (error) => {
-                        (0, debug_1.debugLog)("asyncify.handleSleep: rejected:", error);
-                        console.error("QuickJS: cannot handle error in suspended function", error);
-                        this.suspended = undefined;
-                    });
-                }
-                catch (error) {
-                    (0, debug_1.debugLog)("asyncify.handleSleep: error:", error);
-                    this.suspended = undefined;
-                    throw error;
-                }
-            });
-        }
-        // No asyncify - we should never return a promise.
-        const value = fn();
-        if (value instanceof Promise) {
-            throw new Error("Promise return value not supported in non-asyncify context.");
-        }
-        return value;
-    }
-}
-exports.QuickJSModuleCallbacks = QuickJSModuleCallbacks;
-/**
- * Process RuntimeOptions and apply them to a QuickJSRuntime.
- * @private
- */
-function applyBaseRuntimeOptions(runtime, options) {
-    if (options.interruptHandler) {
-        runtime.setInterruptHandler(options.interruptHandler);
-    }
-    if (options.maxStackSizeBytes !== undefined) {
-        runtime.setMaxStackSize(options.maxStackSizeBytes);
-    }
-    if (options.memoryLimitBytes !== undefined) {
-        runtime.setMemoryLimit(options.memoryLimitBytes);
-    }
-}
-exports.applyBaseRuntimeOptions = applyBaseRuntimeOptions;
-/**
- * Process ModuleEvalOptions and apply them to a QuickJSRuntime.
- * @private
- */
-function applyModuleEvalRuntimeOptions(runtime, options) {
-    if (options.moduleLoader) {
-        runtime.setModuleLoader(options.moduleLoader);
-    }
-    if (options.shouldInterrupt) {
-        runtime.setInterruptHandler(options.shouldInterrupt);
-    }
-    if (options.memoryLimitBytes !== undefined) {
-        runtime.setMemoryLimit(options.memoryLimitBytes);
-    }
-    if (options.maxStackSizeBytes !== undefined) {
-        runtime.setMaxStackSize(options.maxStackSizeBytes);
-    }
-}
-exports.applyModuleEvalRuntimeOptions = applyModuleEvalRuntimeOptions;
-/**
- * This class presents a Javascript interface to QuickJS, a Javascript interpreter
- * that supports EcmaScript 2020 (ES2020).
- *
- * It wraps a single WebAssembly module containing the QuickJS library and
- * associated helper C code. WebAssembly modules are completely isolated from
- * each other by the host's WebAssembly runtime. Separate WebAssembly modules
- * have the most isolation guarantees possible with this library.
- *
- * The simplest way to start running code is {@link evalCode}. This shortcut
- * method will evaluate Javascript safely and return the result as a native
- * Javascript value.
- *
- * For more control over the execution environment, or to interact with values
- * inside QuickJS, create a context with {@link newContext} or a runtime with
- * {@link newRuntime}.
- */
-class QuickJSWASMModule {
-    /** @private */
-    constructor(module, ffi) {
-        this.module = module;
-        this.ffi = ffi;
-        this.callbacks = new QuickJSModuleCallbacks(module);
-    }
-    /**
-     * Create a runtime.
-     * Use the runtime to set limits on CPU and memory usage and configure module
-     * loading for one or more [[QuickJSContext]]s inside the runtime.
-     */
-    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_1.QuickJSRuntime({
-            module: this.module,
-            callbacks: this.callbacks,
-            ffi: this.ffi,
-            rt,
-        });
-        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 context = runtime.newContext({
-            ...options,
-            ownedLifetimes: (0, types_1.concat)(runtime, options.ownedLifetimes),
-        });
-        runtime.context = context;
-        return context;
-    }
-    /**
-     * One-off evaluate code without needing to create a [[QuickJSRuntime]] or
-     * [[QuickJSContext]] explicitly.
-     *
-     * To protect against infinite loops, use the `shouldInterrupt` option. The
-     * [[shouldInterruptAfterDeadline]] function will create a time-based deadline.
-     *
-     * If you need more control over how the code executes, create a
-     * [[QuickJSRuntime]] (with [[newRuntime]]) or a [[QuickJSContext]] (with
-     * [[newContext]] or [[QuickJSRuntime.newContext]]), and use its
-     * [[QuickJSContext.evalCode]] method.
-     *
-     * Asynchronous callbacks may not run during the first call to `evalCode`. If
-     * you need to work with async code inside QuickJS, create a runtime and use
-     * [[QuickJSRuntime.executePendingJobs]].
-     *
-     * @returns The result is coerced to a native Javascript value using JSON
-     * serialization, so properties and values unsupported by JSON will be dropped.
-     *
-     * @throws If `code` throws during evaluation, the exception will be
-     * converted into a native Javascript value and thrown.
-     *
-     * @throws if `options.shouldInterrupt` interrupted execution, will throw a Error
-     * with name `"InternalError"` and  message `"interrupted"`.
-     */
-    evalCode(code, options = {}) {
-        return lifetime_1.Scope.withScope((scope) => {
-            const vm = scope.manage(this.newContext());
-            applyModuleEvalRuntimeOptions(vm.runtime, options);
-            const result = vm.evalCode(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;
-        });
-    }
-    /**
-     * Get a low-level interface to the QuickJS functions in this WebAssembly
-     * module.
-     * @experimental
-     * @unstable No warranty is provided with this API. It could change at any time.
-     * @private
-     */
-    getFFI() {
-        return this.ffi;
-    }
-}
-exports.QuickJSWASMModule = QuickJSWASMModule;
-//# sourceMappingURL=module.js.map

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

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuickJSAsyncRuntime = void 0;
-const _1 = require(".");
-const context_asyncify_1 = require("./context-asyncify");
-const runtime_1 = require("./runtime");
-const types_1 = require("./types");
-class QuickJSAsyncRuntime extends runtime_1.QuickJSRuntime {
-    /** @private */
-    constructor(args) {
-        super(args);
-    }
-    newContext(options = {}) {
-        if (options.intrinsics && options.intrinsics !== types_1.DefaultIntrinsics) {
-            throw new Error("TODO: Custom intrinsics are not supported yet");
-        }
-        const ctx = new _1.Lifetime(this.ffi.QTS_NewContext(this.rt.value), undefined, (ctx_ptr) => {
-            this.contextMap.delete(ctx_ptr);
-            this.callbacks.deleteContext(ctx_ptr);
-            this.ffi.QTS_FreeContext(ctx_ptr);
-        });
-        const context = new context_asyncify_1.QuickJSAsyncContext({
-            module: this.module,
-            ctx,
-            ffi: this.ffi,
-            rt: this.rt,
-            ownedLifetimes: [],
-            runtime: this,
-            callbacks: this.callbacks,
-        });
-        this.contextMap.set(ctx.value, context);
-        return context;
-    }
-    setModuleLoader(moduleLoader, moduleNormalizer) {
-        super.setModuleLoader(moduleLoader, moduleNormalizer);
-    }
-    /**
-     * Set the max stack size for this runtime in bytes.
-     * To remove the limit, set to `0`.
-     *
-     * Setting this limit also adjusts the global `ASYNCIFY_STACK_SIZE` for the entire {@link QuickJSAsyncWASMModule}.
-     * See the [pull request](https://github.com/justjake/quickjs-emscripten/pull/114) for more details.
-     */
-    setMaxStackSize(stackSize) {
-        return super.setMaxStackSize(stackSize);
-    }
-}
-exports.QuickJSAsyncRuntime = QuickJSAsyncRuntime;
-//# sourceMappingURL=runtime-asyncify.js.map

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

@@ -1,300 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuickJSRuntime = void 0;
-const asyncify_helpers_1 = require("./asyncify-helpers");
-const context_1 = require("./context");
-const debug_1 = require("./debug");
-const errors_1 = require("./errors");
-const lifetime_1 = require("./lifetime");
-const memory_1 = require("./memory");
-const types_1 = require("./types");
-/**
- * A runtime represents a Javascript runtime corresponding to an object heap.
- * Several runtimes can exist at the same time but they cannot exchange objects.
- * Inside a given runtime, no multi-threading is supported.
- *
- * You can think of separate runtimes like different domains in a browser, and
- * the contexts within a runtime like the different windows open to the same
- * domain.
- *
- * Create a runtime via {@link QuickJSWASMModule.newRuntime}.
- *
- * You should create separate runtime instances for untrusted code from
- * different sources for isolation. However, stronger isolation is also
- * available (at the cost of memory usage), by creating separate WebAssembly
- * modules to further isolate untrusted code.
- * See {@link newQuickJSWASMModule}.
- *
- * Implement memory and CPU constraints with [[setInterruptHandler]]
- * (called regularly while the interpreter runs), [[setMemoryLimit]], and
- * [[setMaxStackSize]].
- * Use [[computeMemoryUsage]] or [[dumpMemoryUsage]] to guide memory limit
- * tuning.
- *
- * Configure ES module loading with [[setModuleLoader]].
- */
-class QuickJSRuntime {
-    /** @private */
-    constructor(args) {
-        /** @private */
-        this.scope = new lifetime_1.Scope();
-        /** @private */
-        this.contextMap = new Map();
-        this.cToHostCallbacks = {
-            shouldInterrupt: (rt) => {
-                if (rt !== this.rt.value) {
-                    throw new Error("QuickJSContext instance received C -> JS interrupt with mismatched rt");
-                }
-                const fn = this.interruptHandler;
-                if (!fn) {
-                    throw new Error("QuickJSContext had no interrupt handler");
-                }
-                return fn(this) ? 1 : 0;
-            },
-            loadModuleSource: (0, asyncify_helpers_1.maybeAsyncFn)(this, function* (awaited, rt, ctx, moduleName) {
-                const moduleLoader = this.moduleLoader;
-                if (!moduleLoader) {
-                    throw new Error("Runtime has no module loader");
-                }
-                if (rt !== this.rt.value) {
-                    throw new Error("Runtime pointer mismatch");
-                }
-                const context = this.contextMap.get(ctx) ??
-                    this.newContext({
-                        contextPointer: ctx,
-                    });
-                try {
-                    const result = yield* awaited(moduleLoader(moduleName, context));
-                    if (typeof result === "object" && "error" in result && result.error) {
-                        (0, debug_1.debugLog)("cToHostLoadModule: loader returned error", result.error);
-                        throw result.error;
-                    }
-                    const moduleSource = typeof result === "string" ? result : "value" in result ? result.value : result;
-                    return this.memory.newHeapCharPointer(moduleSource).value;
-                }
-                catch (error) {
-                    (0, debug_1.debugLog)("cToHostLoadModule: caught error", error);
-                    context.throw(error);
-                    return 0;
-                }
-            }),
-            normalizeModule: (0, asyncify_helpers_1.maybeAsyncFn)(this, function* (awaited, rt, ctx, baseModuleName, moduleNameRequest) {
-                const moduleNormalizer = this.moduleNormalizer;
-                if (!moduleNormalizer) {
-                    throw new Error("Runtime has no module normalizer");
-                }
-                if (rt !== this.rt.value) {
-                    throw new Error("Runtime pointer mismatch");
-                }
-                const context = this.contextMap.get(ctx) ??
-                    this.newContext({
-                        /* TODO: Does this happen? Are we responsible for disposing? I don't think so */
-                        contextPointer: ctx,
-                    });
-                try {
-                    const result = yield* awaited(moduleNormalizer(baseModuleName, moduleNameRequest, context));
-                    if (typeof result === "object" && "error" in result && result.error) {
-                        (0, debug_1.debugLog)("cToHostNormalizeModule: normalizer returned error", result.error);
-                        throw result.error;
-                    }
-                    const name = typeof result === "string" ? result : result.value;
-                    return context.getMemory(this.rt.value).newHeapCharPointer(name).value;
-                }
-                catch (error) {
-                    (0, debug_1.debugLog)("normalizeModule: caught error", error);
-                    context.throw(error);
-                    return 0;
-                }
-            }),
-        };
-        args.ownedLifetimes?.forEach((lifetime) => this.scope.manage(lifetime));
-        this.module = args.module;
-        this.memory = new memory_1.ModuleMemory(this.module);
-        this.ffi = args.ffi;
-        this.rt = args.rt;
-        this.callbacks = args.callbacks;
-        this.scope.manage(this.rt);
-        this.callbacks.setRuntimeCallbacks(this.rt.value, this.cToHostCallbacks);
-        this.executePendingJobs = this.executePendingJobs.bind(this);
-    }
-    get alive() {
-        return this.scope.alive;
-    }
-    dispose() {
-        return this.scope.dispose();
-    }
-    newContext(options = {}) {
-        if (options.intrinsics && options.intrinsics !== types_1.DefaultIntrinsics) {
-            throw new Error("TODO: Custom intrinsics are not supported yet");
-        }
-        const ctx = new lifetime_1.Lifetime(options.contextPointer || this.ffi.QTS_NewContext(this.rt.value), undefined, (ctx_ptr) => {
-            this.contextMap.delete(ctx_ptr);
-            this.callbacks.deleteContext(ctx_ptr);
-            this.ffi.QTS_FreeContext(ctx_ptr);
-        });
-        const context = new context_1.QuickJSContext({
-            module: this.module,
-            ctx,
-            ffi: this.ffi,
-            rt: this.rt,
-            ownedLifetimes: options.ownedLifetimes,
-            runtime: this,
-            callbacks: this.callbacks,
-        });
-        this.contextMap.set(ctx.value, context);
-        return context;
-    }
-    /**
-     * Set the loader for EcmaScript modules requested by any context in this
-     * runtime.
-     *
-     * The loader can be removed with [[removeModuleLoader]].
-     */
-    setModuleLoader(moduleLoader, moduleNormalizer) {
-        this.moduleLoader = moduleLoader;
-        this.moduleNormalizer = moduleNormalizer;
-        this.ffi.QTS_RuntimeEnableModuleLoader(this.rt.value, this.moduleNormalizer ? 1 : 0);
-    }
-    /**
-     * Remove the the loader set by [[setModuleLoader]]. This disables module loading.
-     */
-    removeModuleLoader() {
-        this.moduleLoader = undefined;
-        this.ffi.QTS_RuntimeDisableModuleLoader(this.rt.value);
-    }
-    // Runtime management -------------------------------------------------------
-    /**
-     * In QuickJS, promises and async functions create pendingJobs. These do not execute
-     * immediately and need to be run by calling [[executePendingJobs]].
-     *
-     * @return true if there is at least one pendingJob queued up.
-     */
-    hasPendingJob() {
-        return Boolean(this.ffi.QTS_IsJobPending(this.rt.value));
-    }
-    /**
-     * Set a callback which is regularly called by the QuickJS engine when it is
-     * executing code. This callback can be used to implement an execution
-     * timeout.
-     *
-     * The interrupt handler can be removed with [[removeInterruptHandler]].
-     */
-    setInterruptHandler(cb) {
-        const prevInterruptHandler = this.interruptHandler;
-        this.interruptHandler = cb;
-        if (!prevInterruptHandler) {
-            this.ffi.QTS_RuntimeEnableInterruptHandler(this.rt.value);
-        }
-    }
-    /**
-     * Remove the interrupt handler, if any.
-     * See [[setInterruptHandler]].
-     */
-    removeInterruptHandler() {
-        if (this.interruptHandler) {
-            this.ffi.QTS_RuntimeDisableInterruptHandler(this.rt.value);
-            this.interruptHandler = undefined;
-        }
-    }
-    /**
-     * Execute pendingJobs on the runtime until `maxJobsToExecute` jobs are
-     * executed (default all pendingJobs), the queue is exhausted, or the runtime
-     * encounters an exception.
-     *
-     * In QuickJS, promises and async functions *inside the runtime* create
-     * pendingJobs. These do not execute immediately and need to triggered to run.
-     *
-     * @param maxJobsToExecute - When negative, run all pending jobs. Otherwise execute
-     * at most `maxJobsToExecute` before returning.
-     *
-     * @return On success, the number of executed jobs. On error, the exception
-     * that stopped execution, and the context it occurred in. Note that
-     * executePendingJobs will not normally return errors thrown inside async
-     * functions or rejected promises. Those errors are available by calling
-     * [[resolvePromise]] on the promise handle returned by the async function.
-     */
-    executePendingJobs(maxJobsToExecute = -1) {
-        const ctxPtrOut = this.memory.newMutablePointerArray(1);
-        const valuePtr = this.ffi.QTS_ExecutePendingJob(this.rt.value, maxJobsToExecute ?? -1, ctxPtrOut.value.ptr);
-        const ctxPtr = ctxPtrOut.value.typedArray[0];
-        ctxPtrOut.dispose();
-        if (ctxPtr === 0) {
-            // No jobs executed.
-            this.ffi.QTS_FreeValuePointerRuntime(this.rt.value, valuePtr);
-            return { value: 0 };
-        }
-        const context = this.contextMap.get(ctxPtr) ??
-            this.newContext({
-                contextPointer: ctxPtr,
-            });
-        const resultValue = context.getMemory(this.rt.value).heapValueHandle(valuePtr);
-        const typeOfRet = context.typeof(resultValue);
-        if (typeOfRet === "number") {
-            const executedJobs = context.getNumber(resultValue);
-            resultValue.dispose();
-            return { value: executedJobs };
-        }
-        else {
-            const error = Object.assign(resultValue, { context });
-            return {
-                error,
-            };
-        }
-    }
-    /**
-     * Set the max memory this runtime can allocate.
-     * To remove the limit, set to `-1`.
-     */
-    setMemoryLimit(limitBytes) {
-        if (limitBytes < 0 && limitBytes !== -1) {
-            throw new Error("Cannot set memory limit to negative number. To unset, pass -1");
-        }
-        this.ffi.QTS_RuntimeSetMemoryLimit(this.rt.value, limitBytes);
-    }
-    /**
-     * Compute memory usage for this runtime. Returns the result as a handle to a
-     * JSValue object. Use [[QuickJSContext.dump]] to convert to a native object.
-     * Calling this method will allocate more memory inside the runtime. The information
-     * is accurate as of just before the call to `computeMemoryUsage`.
-     * For a human-digestible representation, see [[dumpMemoryUsage]].
-     */
-    computeMemoryUsage() {
-        const serviceContextMemory = this.getSystemContext().getMemory(this.rt.value);
-        return serviceContextMemory.heapValueHandle(this.ffi.QTS_RuntimeComputeMemoryUsage(this.rt.value, serviceContextMemory.ctx.value));
-    }
-    /**
-     * @returns a human-readable description of memory usage in this runtime.
-     * For programmatic access to this information, see [[computeMemoryUsage]].
-     */
-    dumpMemoryUsage() {
-        return this.memory.consumeHeapCharPointer(this.ffi.QTS_RuntimeDumpMemoryUsage(this.rt.value));
-    }
-    /**
-     * Set the max stack size for this runtime, in bytes.
-     * To remove the limit, set to `0`.
-     */
-    setMaxStackSize(stackSize) {
-        if (stackSize < 0) {
-            throw new Error("Cannot set memory limit to negative number. To unset, pass 0.");
-        }
-        this.ffi.QTS_RuntimeSetMaxStackSize(this.rt.value, stackSize);
-    }
-    /**
-     * Assert that `handle` is owned by this runtime.
-     * @throws QuickJSWrongOwner if owned by a different runtime.
-     */
-    assertOwned(handle) {
-        if (handle.owner && handle.owner.rt !== this.rt) {
-            throw new errors_1.QuickJSWrongOwner(`Handle is not owned by this runtime: ${handle.owner.rt.value} != ${this.rt.value}`);
-        }
-    }
-    getSystemContext() {
-        if (!this.context) {
-            // We own this context and should dispose of it.
-            this.context = this.scope.manage(this.newContext());
-        }
-        return this.context;
-    }
-}
-exports.QuickJSRuntime = QuickJSRuntime;
-//# sourceMappingURL=runtime.js.map

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

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvalFlags = exports.assertSync = void 0;
-function assertSync(fn) {
-    return function mustBeSync(...args) {
-        const result = fn(...args);
-        if (result && typeof result === "object" && result instanceof Promise) {
-            throw new Error("Function unexpectedly returned a Promise");
-        }
-        return result;
-    };
-}
-exports.assertSync = assertSync;
-/** Bitfield options for JS_Eval() C function. */
-exports.EvalFlags = {
-    /** global code (default) */
-    JS_EVAL_TYPE_GLOBAL: 0 << 0,
-    /** module code */
-    JS_EVAL_TYPE_MODULE: 1 << 0,
-    /** direct call (internal use) */
-    JS_EVAL_TYPE_DIRECT: 2 << 0,
-    /** indirect call (internal use) */
-    JS_EVAL_TYPE_INDIRECT: 3 << 0,
-    JS_EVAL_TYPE_MASK: 3 << 0,
-    /** force 'strict' mode */
-    JS_EVAL_FLAG_STRICT: 1 << 3,
-    /** force 'strip' mode */
-    JS_EVAL_FLAG_STRIP: 1 << 4,
-    /**
-     * compile but do not run. The result is an object with a
-     * JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed
-     * with JS_EvalFunction().
-     */
-    JS_EVAL_FLAG_COMPILE_ONLY: 1 << 5,
-    /** don't include the stack frames before this eval in the Error() backtraces */
-    JS_EVAL_FLAG_BACKTRACE_BARRIER: 1 << 6,
-};
-//# sourceMappingURL=types-ffi.js.map