@psnext/slingcli 2.4.20260520-2 → 2.4.20260520-4

package/node_modules/@tootallnate/quickjs-emscripten/dist/asyncify-helpers.d.ts

@@ -1,24 +0,0 @@
-declare function awaitYield<T>(value: T | Promise<T>): Generator<T | Promise<T>, T, T>;
-declare function awaitYieldOf<T, Yielded>(generator: Generator<Yielded | Promise<Yielded>, T, Yielded>): Generator<T | Promise<T>, T, T>;
-export type AwaitYield = typeof awaitYield & {
-    of: typeof awaitYieldOf;
-};
-/**
- * Create a function that may or may not be async, using a generator
- *
- * Within the generator, call `yield* awaited(maybePromise)` to await a value
- * that may or may not be a promise.
- *
- * If the inner function never yields a promise, it will return synchronously.
- */
-export declare function maybeAsyncFn<
-/** Function arguments */
-Args extends any[], This, 
-/** Function return type */
-Return, 
-/** Yields to unwrap */
-Yielded>(that: This, fn: (this: This, awaited: AwaitYield, ...args: Args) => Generator<Yielded | Promise<Yielded>, Return, Yielded>): (...args: Args) => Return | Promise<Return>;
-export type MaybeAsyncBlock<Return, This, Yielded, Args extends any[] = []> = (this: This, awaited: AwaitYield, ...args: Args) => Generator<Yielded | Promise<Yielded>, Return, Yielded>;
-export declare function maybeAsync<Return, This, Yielded>(that: This, startGenerator: (this: This, await: AwaitYield) => Generator<Yielded | Promise<Yielded>, Return, Yielded>): Return | Promise<Return>;
-export declare function awaitEachYieldedPromise<Yielded, Returned>(gen: Generator<Yielded | Promise<Yielded>, Returned, Yielded>): Returned | Promise<Returned>;
-export {};

package/node_modules/@tootallnate/quickjs-emscripten/dist/asyncify-helpers.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.awaitEachYieldedPromise = exports.maybeAsync = exports.maybeAsyncFn = void 0;
-function* awaitYield(value) {
-    return (yield value);
-}
-function awaitYieldOf(generator) {
-    return awaitYield(awaitEachYieldedPromise(generator));
-}
-const AwaitYield = awaitYield;
-AwaitYield.of = awaitYieldOf;
-/**
- * Create a function that may or may not be async, using a generator
- *
- * Within the generator, call `yield* awaited(maybePromise)` to await a value
- * that may or may not be a promise.
- *
- * If the inner function never yields a promise, it will return synchronously.
- */
-function maybeAsyncFn(that, fn) {
-    return (...args) => {
-        const generator = fn.call(that, AwaitYield, ...args);
-        return awaitEachYieldedPromise(generator);
-    };
-}
-exports.maybeAsyncFn = maybeAsyncFn;
-class Example {
-    constructor() {
-        this.maybeAsyncMethod = maybeAsyncFn(this, function* (awaited, a) {
-            yield* awaited(new Promise((resolve) => setTimeout(resolve, a)));
-            return 5;
-        });
-    }
-}
-function maybeAsync(that, startGenerator) {
-    const generator = startGenerator.call(that, AwaitYield);
-    return awaitEachYieldedPromise(generator);
-}
-exports.maybeAsync = maybeAsync;
-function awaitEachYieldedPromise(gen) {
-    function handleNextStep(step) {
-        if (step.done) {
-            return step.value;
-        }
-        if (step.value instanceof Promise) {
-            return step.value.then((value) => handleNextStep(gen.next(value)), (error) => handleNextStep(gen.throw(error)));
-        }
-        return handleNextStep(gen.next(step.value));
-    }
-    return handleNextStep(gen.next());
-}
-exports.awaitEachYieldedPromise = awaitEachYieldedPromise;
-//# sourceMappingURL=asyncify-helpers.js.map

package/node_modules/@tootallnate/quickjs-emscripten/dist/asyncify-helpers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncify-helpers.js","sourceRoot":"","sources":["../ts/asyncify-helpers.ts"],"names":[],"mappings":";;;AAAA,QAAQ,CAAC,CAAC,UAAU,CAAI,KAAqB;IAC3C,OAAO,CAAC,MAAM,KAAK,CAAM,CAAA;AAC3B,CAAC;AAED,SAAS,YAAY,CACnB,SAA4D;IAE5D,OAAO,UAAU,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC,CAAA;AACvD,CAAC;AAMD,MAAM,UAAU,GAAe,UAAwB,CAAA;AACvD,UAAU,CAAC,EAAE,GAAG,YAAY,CAAA;AAE5B;;;;;;;GAOG;AACH,SAAgB,YAAY,CAS1B,IAAU,EACV,EAI2D;IAE3D,OAAO,CAAC,GAAG,IAAU,EAAE,EAAE;QACvB,MAAM,SAAS,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,CAAA;QACpD,OAAO,uBAAuB,CAAC,SAAS,CAAC,CAAA;IAC3C,CAAC,CAAA;AACH,CAAC;AApBD,oCAoBC;AAED,MAAM,OAAO;IAAb;QACU,qBAAgB,GAAG,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAS;YACzE,KAAK,CAAC,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;YAChE,OAAO,CAAC,CAAA;QACV,CAAC,CAAC,CAAA;IACJ,CAAC;CAAA;AAQD,SAAgB,UAAU,CACxB,IAAU,EACV,cAG2D;IAE3D,MAAM,SAAS,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;IACvD,OAAO,uBAAuB,CAAC,SAAS,CAAC,CAAA;AAC3C,CAAC;AATD,gCASC;AAED,SAAgB,uBAAuB,CACrC,GAA6D;IAI7D,SAAS,cAAc,CAAC,IAAgB;QACtC,IAAI,IAAI,CAAC,IAAI,EAAE;YACb,OAAO,IAAI,CAAC,KAAK,CAAA;SAClB;QAED,IAAI,IAAI,CAAC,KAAK,YAAY,OAAO,EAAE;YACjC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CACpB,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAC1C,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAC5C,CAAA;SACF;QAED,OAAO,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;IAC7C,CAAC;IAED,OAAO,cAAc,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAA;AACnC,CAAC;AArBD,0DAqBC","sourcesContent":["function* awaitYield<T>(value: T | Promise<T>) {\n  return (yield value) as T\n}\n\nfunction awaitYieldOf<T, Yielded>(\n  generator: Generator<Yielded | Promise<Yielded>, T, Yielded>\n): Generator<T | Promise<T>, T, T> {\n  return awaitYield(awaitEachYieldedPromise(generator))\n}\n\nexport type AwaitYield = typeof awaitYield & {\n  of: typeof awaitYieldOf\n}\n\nconst AwaitYield: AwaitYield = awaitYield as AwaitYield\nAwaitYield.of = awaitYieldOf\n\n/**\n * Create a function that may or may not be async, using a generator\n *\n * Within the generator, call `yield* awaited(maybePromise)` to await a value\n * that may or may not be a promise.\n *\n * If the inner function never yields a promise, it will return synchronously.\n */\nexport function maybeAsyncFn<\n  /** Function arguments */\n  Args extends any[],\n  This,\n  /** Function return type */\n  Return,\n  /** Yields to unwrap */\n  Yielded\n>(\n  that: This,\n  fn: (\n    this: This,\n    awaited: AwaitYield,\n    ...args: Args\n  ) => Generator<Yielded | Promise<Yielded>, Return, Yielded>\n): (...args: Args) => Return | Promise<Return> {\n  return (...args: Args) => {\n    const generator = fn.call(that, AwaitYield, ...args)\n    return awaitEachYieldedPromise(generator)\n  }\n}\n\nclass Example {\n  private maybeAsyncMethod = maybeAsyncFn(this, function* (awaited, a: number) {\n    yield* awaited(new Promise((resolve) => setTimeout(resolve, a)))\n    return 5\n  })\n}\n\nexport type MaybeAsyncBlock<Return, This, Yielded, Args extends any[] = []> = (\n  this: This,\n  awaited: AwaitYield,\n  ...args: Args\n) => Generator<Yielded | Promise<Yielded>, Return, Yielded>\n\nexport function maybeAsync<Return, This, Yielded>(\n  that: This,\n  startGenerator: (\n    this: This,\n    await: AwaitYield\n  ) => Generator<Yielded | Promise<Yielded>, Return, Yielded>\n): Return | Promise<Return> {\n  const generator = startGenerator.call(that, AwaitYield)\n  return awaitEachYieldedPromise(generator)\n}\n\nexport function awaitEachYieldedPromise<Yielded, Returned>(\n  gen: Generator<Yielded | Promise<Yielded>, Returned, Yielded>\n): Returned | Promise<Returned> {\n  type NextResult = ReturnType<typeof gen.next>\n\n  function handleNextStep(step: NextResult): Returned | Promise<Returned> {\n    if (step.done) {\n      return step.value\n    }\n\n    if (step.value instanceof Promise) {\n      return step.value.then(\n        (value) => handleNextStep(gen.next(value)),\n        (error) => handleNextStep(gen.throw(error))\n      )\n    }\n\n    return handleNextStep(gen.next(step.value))\n  }\n\n  return handleNextStep(gen.next())\n}\n"]}

package/node_modules/@tootallnate/quickjs-emscripten/dist/context-asyncify.d.ts

@@ -1,48 +0,0 @@
-import { QuickJSContext } from "./context";
-import { QuickJSAsyncEmscriptenModule } from "./emscripten-types";
-import { QuickJSAsyncFFI } from "./variants";
-import { JSRuntimePointer } from "./types-ffi";
-import { Lifetime } from "./lifetime";
-import { QuickJSModuleCallbacks } from "./module";
-import { QuickJSAsyncRuntime } from "./runtime-asyncify";
-import { ContextEvalOptions, QuickJSHandle } from "./types";
-import { VmCallResult } from "./vm-interface";
-export type AsyncFunctionImplementation = (this: QuickJSHandle, ...args: QuickJSHandle[]) => Promise<QuickJSHandle | VmCallResult<QuickJSHandle> | void>;
-/**
- * Asyncified version of [[QuickJSContext]].
- *
- * *Asyncify* allows normally synchronous code to wait for asynchronous Promises
- * or callbacks. The asyncified version of QuickJSContext can wait for async
- * host functions as though they were synchronous.
- */
-export declare class QuickJSAsyncContext extends QuickJSContext {
-    runtime: QuickJSAsyncRuntime;
-    /** @private */
-    protected module: QuickJSAsyncEmscriptenModule;
-    /** @private */
-    protected ffi: QuickJSAsyncFFI;
-    /** @private */
-    protected rt: Lifetime<JSRuntimePointer>;
-    /** @private */
-    protected callbacks: QuickJSModuleCallbacks;
-    /**
-     * Asyncified version of [[evalCode]].
-     */
-    evalCodeAsync(code: string, filename?: string, 
-    /** See [[EvalFlags]] for number semantics */
-    options?: number | ContextEvalOptions): Promise<VmCallResult<QuickJSHandle>>;
-    /**
-     * Similar to [[newFunction]].
-     * Convert an async host Javascript function into a synchronous QuickJS function value.
-     *
-     * Whenever QuickJS calls this function, the VM's stack will be unwound while
-     * waiting the async function to complete, and then restored when the returned
-     * promise resolves.
-     *
-     * Asyncified functions must never call other asyncified functions or
-     * `import`, even indirectly, because the stack cannot be unwound twice.
-     *
-     * See [Emscripten's docs on Asyncify](https://emscripten.org/docs/porting/asyncify.html).
-     */
-    newAsyncifiedFunction(name: string, fn: AsyncFunctionImplementation): QuickJSHandle;
-}

package/node_modules/@tootallnate/quickjs-emscripten/dist/context-asyncify.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuickJSAsyncContext = void 0;
-const context_1 = require("./context");
-const debug_1 = require("./debug");
-const types_1 = require("./types");
-/**
- * Asyncified version of [[QuickJSContext]].
- *
- * *Asyncify* allows normally synchronous code to wait for asynchronous Promises
- * or callbacks. The asyncified version of QuickJSContext can wait for async
- * host functions as though they were synchronous.
- */
-class QuickJSAsyncContext extends context_1.QuickJSContext {
-    /**
-     * Asyncified version of [[evalCode]].
-     */
-    async evalCodeAsync(code, filename = "eval.js", 
-    /** See [[EvalFlags]] for number semantics */
-    options) {
-        const detectModule = (options === undefined ? 1 : 0);
-        const flags = (0, types_1.evalOptionsToFlags)(options);
-        let resultPtr = 0;
-        try {
-            resultPtr = await this.memory
-                .newHeapCharPointer(code)
-                .consume((charHandle) => this.ffi.QTS_Eval_MaybeAsync(this.ctx.value, charHandle.value, filename, detectModule, flags));
-        }
-        catch (error) {
-            (0, debug_1.debugLog)("QTS_Eval_MaybeAsync threw", error);
-            throw error;
-        }
-        const errorPtr = this.ffi.QTS_ResolveException(this.ctx.value, resultPtr);
-        if (errorPtr) {
-            this.ffi.QTS_FreeValuePointer(this.ctx.value, resultPtr);
-            return { error: this.memory.heapValueHandle(errorPtr) };
-        }
-        return { value: this.memory.heapValueHandle(resultPtr) };
-    }
-    /**
-     * Similar to [[newFunction]].
-     * Convert an async host Javascript function into a synchronous QuickJS function value.
-     *
-     * Whenever QuickJS calls this function, the VM's stack will be unwound while
-     * waiting the async function to complete, and then restored when the returned
-     * promise resolves.
-     *
-     * Asyncified functions must never call other asyncified functions or
-     * `import`, even indirectly, because the stack cannot be unwound twice.
-     *
-     * See [Emscripten's docs on Asyncify](https://emscripten.org/docs/porting/asyncify.html).
-     */
-    newAsyncifiedFunction(name, fn) {
-        return this.newFunction(name, fn);
-    }
-}
-exports.QuickJSAsyncContext = QuickJSAsyncContext;
-//# sourceMappingURL=context-asyncify.js.map

package/node_modules/@tootallnate/quickjs-emscripten/dist/context-asyncify.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-asyncify.js","sourceRoot":"","sources":["../ts/context-asyncify.ts"],"names":[],"mappings":";;;AAAA,uCAA0C;AAC1C,mCAAkC;AAOlC,mCAA+E;AAQ/E;;;;;;GAMG;AACH,MAAa,mBAAoB,SAAQ,wBAAc;IAWrD;;OAEG;IACH,KAAK,CAAC,aAAa,CACjB,IAAY,EACZ,WAAmB,SAAS;IAC5B,6CAA6C;IAC7C,OAAqC;QAErC,MAAM,YAAY,GAAG,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAqB,CAAA;QACxE,MAAM,KAAK,GAAG,IAAA,0BAAkB,EAAC,OAAO,CAAc,CAAA;QACtD,IAAI,SAAS,GAAG,CAAmB,CAAA;QACnC,IAAI;YACF,SAAS,GAAG,MAAM,IAAI,CAAC,MAAM;iBAC1B,kBAAkB,CAAC,IAAI,CAAC;iBACxB,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE,CACtB,IAAI,CAAC,GAAG,CAAC,mBAAmB,CAC1B,IAAI,CAAC,GAAG,CAAC,KAAK,EACd,UAAU,CAAC,KAAK,EAChB,QAAQ,EACR,YAAY,EACZ,KAAK,CACN,CACF,CAAA;SACJ;QAAC,OAAO,KAAK,EAAE;YACd,IAAA,gBAAQ,EAAC,2BAA2B,EAAE,KAAK,CAAC,CAAA;YAC5C,MAAM,KAAK,CAAA;SACZ;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;QACzE,IAAI,QAAQ,EAAE;YACZ,IAAI,CAAC,GAAG,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;YACxD,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAA;SACxD;QACD,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAA;IAC1D,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,qBAAqB,CAAC,IAAY,EAAE,EAA+B;QACjE,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,EAAS,CAAC,CAAA;IAC1C,CAAC;CACF;AA/DD,kDA+DC","sourcesContent":["import { QuickJSContext } from \"./context\"\nimport { debugLog } from \"./debug\"\nimport { QuickJSAsyncEmscriptenModule } from \"./emscripten-types\"\nimport { QuickJSAsyncFFI } from \"./variants\"\nimport { EvalDetectModule, EvalFlags, JSRuntimePointer, JSValuePointer } from \"./types-ffi\"\nimport { Lifetime } from \"./lifetime\"\nimport { QuickJSModuleCallbacks } from \"./module\"\nimport { QuickJSAsyncRuntime } from \"./runtime-asyncify\"\nimport { ContextEvalOptions, evalOptionsToFlags, QuickJSHandle } from \"./types\"\nimport { VmCallResult } from \"./vm-interface\"\n\nexport type AsyncFunctionImplementation = (\n  this: QuickJSHandle,\n  ...args: QuickJSHandle[]\n) => Promise<QuickJSHandle | VmCallResult<QuickJSHandle> | void>\n\n/**\n * Asyncified version of [[QuickJSContext]].\n *\n * *Asyncify* allows normally synchronous code to wait for asynchronous Promises\n * or callbacks. The asyncified version of QuickJSContext can wait for async\n * host functions as though they were synchronous.\n */\nexport class QuickJSAsyncContext extends QuickJSContext {\n  public declare runtime: QuickJSAsyncRuntime\n  /** @private */\n  protected declare module: QuickJSAsyncEmscriptenModule\n  /** @private */\n  protected declare ffi: QuickJSAsyncFFI\n  /** @private */\n  protected declare rt: Lifetime<JSRuntimePointer>\n  /** @private */\n  protected declare callbacks: QuickJSModuleCallbacks\n\n  /**\n   * Asyncified version of [[evalCode]].\n   */\n  async evalCodeAsync(\n    code: string,\n    filename: string = \"eval.js\",\n    /** See [[EvalFlags]] for number semantics */\n    options?: number | ContextEvalOptions\n  ): Promise<VmCallResult<QuickJSHandle>> {\n    const detectModule = (options === undefined ? 1 : 0) as EvalDetectModule\n    const flags = evalOptionsToFlags(options) as EvalFlags\n    let resultPtr = 0 as JSValuePointer\n    try {\n      resultPtr = await this.memory\n        .newHeapCharPointer(code)\n        .consume((charHandle) =>\n          this.ffi.QTS_Eval_MaybeAsync(\n            this.ctx.value,\n            charHandle.value,\n            filename,\n            detectModule,\n            flags\n          )\n        )\n    } catch (error) {\n      debugLog(\"QTS_Eval_MaybeAsync threw\", error)\n      throw error\n    }\n    const errorPtr = this.ffi.QTS_ResolveException(this.ctx.value, resultPtr)\n    if (errorPtr) {\n      this.ffi.QTS_FreeValuePointer(this.ctx.value, resultPtr)\n      return { error: this.memory.heapValueHandle(errorPtr) }\n    }\n    return { value: this.memory.heapValueHandle(resultPtr) }\n  }\n\n  /**\n   * Similar to [[newFunction]].\n   * Convert an async host Javascript function into a synchronous QuickJS function value.\n   *\n   * Whenever QuickJS calls this function, the VM's stack will be unwound while\n   * waiting the async function to complete, and then restored when the returned\n   * promise resolves.\n   *\n   * Asyncified functions must never call other asyncified functions or\n   * `import`, even indirectly, because the stack cannot be unwound twice.\n   *\n   * See [Emscripten's docs on Asyncify](https://emscripten.org/docs/porting/asyncify.html).\n   */\n  newAsyncifiedFunction(name: string, fn: AsyncFunctionImplementation): QuickJSHandle {\n    return this.newFunction(name, fn as any)\n  }\n}\n"]}

package/node_modules/@tootallnate/quickjs-emscripten/dist/context.d.ts

@@ -1,371 +0,0 @@
-import { QuickJSDeferredPromise } from "./deferred-promise";
-import type { EitherModule } from "./emscripten-types";
-import { JSBorrowedCharPointer, JSContextPointer, JSRuntimePointer, JSValueConstPointer, JSValuePointer } from "./types-ffi";
-import { Disposable, Lifetime, Scope } from "./lifetime";
-import { ModuleMemory } from "./memory";
-import { QuickJSModuleCallbacks } from "./module";
-import { QuickJSRuntime } from "./runtime";
-import { ContextEvalOptions, EitherFFI, JSValue, PromiseExecutor, QuickJSHandle } from "./types";
-import { LowLevelJavascriptVm, SuccessOrFail, VmCallResult, VmFunctionImplementation, VmPropertyDescriptor } from "./vm-interface";
-/**
- * Property key for getting or setting a property on a handle with
- * [[QuickJSContext.getProp]], [[QuickJSContext.setProp]], or [[QuickJSContext.defineProp]].
- */
-export type QuickJSPropertyKey = number | string | QuickJSHandle;
-/**
- * @private
- */
-declare class ContextMemory extends ModuleMemory implements Disposable {
-    readonly owner: QuickJSRuntime;
-    readonly ctx: Lifetime<JSContextPointer>;
-    readonly rt: Lifetime<JSRuntimePointer>;
-    readonly module: EitherModule;
-    readonly ffi: EitherFFI;
-    readonly scope: Scope;
-    /** @private */
-    constructor(args: {
-        owner: QuickJSRuntime;
-        module: EitherModule;
-        ffi: EitherFFI;
-        ctx: Lifetime<JSContextPointer>;
-        rt: Lifetime<JSRuntimePointer>;
-        ownedLifetimes?: Disposable[];
-    });
-    get alive(): boolean;
-    dispose(): void;
-    /**
-     * Track `lifetime` so that it is disposed when this scope is disposed.
-     */
-    manage<T extends Disposable>(lifetime: T): T;
-    copyJSValue: (ptr: JSValuePointer | JSValueConstPointer) => any;
-    freeJSValue: (ptr: JSValuePointer) => void;
-    consumeJSCharPointer(ptr: JSBorrowedCharPointer): string;
-    heapValueHandle(ptr: JSValuePointer): JSValue;
-}
-/**
- * QuickJSContext wraps a QuickJS Javascript context (JSContext*) within a
- * runtime. The contexts within the same runtime may exchange objects freely.
- * 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. The {@link runtime} references the context's runtime.
- *
- * This class's methods return {@link QuickJSHandle}, which wrap C pointers (JSValue*).
- * It's the caller's responsibility to call `.dispose()` on any
- * handles you create to free memory once you're done with the handle.
- *
- * Use {@link QuickJSRuntime.newContext} or {@link QuickJSWASMModule.newContext}
- * to create a new QuickJSContext.
- *
- * Create QuickJS values inside the interpreter with methods like
- * [[newNumber]], [[newString]], [[newArray]], [[newObject]],
- * [[newFunction]], and [[newPromise]].
- *
- * Call [[setProp]] or [[defineProp]] to customize objects. Use those methods
- * with [[global]] to expose the values you create to the interior of the
- * interpreter, so they can be used in [[evalCode]].
- *
- * Use [[evalCode]] or [[callFunction]] to execute Javascript inside the VM. If
- * you're using asynchronous code inside the QuickJSContext, you may need to also
- * call [[executePendingJobs]]. Executing code inside the runtime returns a
- * result object representing successful execution or an error. You must dispose
- * of any such results to avoid leaking memory inside the VM.
- *
- * Implement memory and CPU constraints at the runtime level, using [[runtime]].
- * See {@link QuickJSRuntime} for more information.
- *
- */
-export declare class QuickJSContext implements LowLevelJavascriptVm<QuickJSHandle>, Disposable {
-    /**
-     * The runtime that created this context.
-     */
-    readonly runtime: QuickJSRuntime;
-    /** @private */
-    protected readonly ctx: Lifetime<JSContextPointer>;
-    /** @private */
-    protected readonly rt: Lifetime<JSRuntimePointer>;
-    /** @private */
-    protected readonly module: EitherModule;
-    /** @private */
-    protected readonly ffi: EitherFFI;
-    /** @private */
-    protected memory: ContextMemory;
-    /** @private */
-    protected _undefined: QuickJSHandle | undefined;
-    /** @private */
-    protected _null: QuickJSHandle | undefined;
-    /** @private */
-    protected _false: QuickJSHandle | undefined;
-    /** @private */
-    protected _true: QuickJSHandle | undefined;
-    /** @private */
-    protected _global: QuickJSHandle | undefined;
-    /** @private */
-    protected _BigInt: QuickJSHandle | undefined;
-    /**
-     * Use {@link QuickJS.createVm} to create a QuickJSContext instance.
-     */
-    constructor(args: {
-        module: EitherModule;
-        ffi: EitherFFI;
-        ctx: Lifetime<JSContextPointer>;
-        rt: Lifetime<JSRuntimePointer>;
-        runtime: QuickJSRuntime;
-        ownedLifetimes?: Disposable[];
-        callbacks: QuickJSModuleCallbacks;
-    });
-    get alive(): boolean;
-    /**
-     * Dispose of this VM's underlying resources.
-     *
-     * @throws Calling this method without disposing of all created handles
-     * will result in an error.
-     */
-    dispose(): void;
-    /**
-     * [`undefined`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined).
-     */
-    get undefined(): QuickJSHandle;
-    /**
-     * [`null`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null).
-     */
-    get null(): QuickJSHandle;
-    /**
-     * [`true`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/true).
-     */
-    get true(): QuickJSHandle;
-    /**
-     * [`false`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/false).
-     */
-    get false(): QuickJSHandle;
-    /**
-     * [`global`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects).
-     * A handle to the global object inside the interpreter.
-     * You can set properties to create global variables.
-     */
-    get global(): QuickJSHandle;
-    /**
-     * Converts a Javascript number into a QuickJS value.
-     */
-    newNumber(num: number): QuickJSHandle;
-    /**
-     * Create a QuickJS [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) value.
-     */
-    newString(str: string): QuickJSHandle;
-    /**
-     * Create a QuickJS [symbol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol) value.
-     * No two symbols created with this function will be the same value.
-     */
-    newUniqueSymbol(description: string | symbol): QuickJSHandle;
-    /**
-     * Get a symbol from the [global registry](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol#shared_symbols_in_the_global_symbol_registry) for the given key.
-     * All symbols created with the same key will be the same value.
-     */
-    newSymbolFor(key: string | symbol): QuickJSHandle;
-    /**
-     * Create a QuickJS [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) value.
-     */
-    newBigInt(num: bigint): QuickJSHandle;
-    /**
-     * `{}`.
-     * Create a new QuickJS [object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer).
-     *
-     * @param prototype - Like [`Object.create`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create).
-     */
-    newObject(prototype?: QuickJSHandle): QuickJSHandle;
-    /**
-     * `[]`.
-     * Create a new QuickJS [array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array).
-     */
-    newArray(): QuickJSHandle;
-    /**
-     * Create a new [[QuickJSDeferredPromise]]. Use `deferred.resolve(handle)` and
-     * `deferred.reject(handle)` to fulfill the promise handle available at `deferred.handle`.
-     * Note that you are responsible for calling `deferred.dispose()` to free the underlying
-     * resources; see the documentation on [[QuickJSDeferredPromise]] for details.
-     */
-    newPromise(): QuickJSDeferredPromise;
-    /**
-     * Create a new [[QuickJSDeferredPromise]] that resolves when the
-     * given native Promise<QuickJSHandle> resolves. Rejections will be coerced
-     * to a QuickJS error.
-     *
-     * You can still resolve/reject the created promise "early" using its methods.
-     */
-    newPromise(promise: Promise<QuickJSHandle>): QuickJSDeferredPromise;
-    /**
-     * Construct a new native Promise<QuickJSHandle>, and then convert it into a
-     * [[QuickJSDeferredPromise]].
-     *
-     * You can still resolve/reject the created promise "early" using its methods.
-     */
-    newPromise(newPromiseFn: PromiseExecutor<QuickJSHandle, Error | QuickJSHandle>): QuickJSDeferredPromise;
-    /**
-     * Convert a Javascript function into a QuickJS function value.
-     * See [[VmFunctionImplementation]] for more details.
-     *
-     * A [[VmFunctionImplementation]] should not free its arguments or its return
-     * value. A VmFunctionImplementation should also not retain any references to
-     * its return value.
-     *
-     * To implement an async function, create a promise with [[newPromise]], then
-     * return the deferred promise handle from `deferred.handle` from your
-     * function implementation:
-     *
-     * ```
-     * const deferred = vm.newPromise()
-     * someNativeAsyncFunction().then(deferred.resolve)
-     * return deferred.handle
-     * ```
-     */
-    newFunction(name: string, fn: VmFunctionImplementation<QuickJSHandle>): QuickJSHandle;
-    newError(error: {
-        name: string;
-        message: string;
-    }): QuickJSHandle;
-    newError(message: string): QuickJSHandle;
-    newError(): QuickJSHandle;
-    /**
-     * `typeof` operator. **Not** [standards compliant](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof).
-     *
-     * @remarks
-     * Does not support BigInt values correctly.
-     */
-    typeof(handle: QuickJSHandle): string;
-    /**
-     * Converts `handle` into a Javascript number.
-     * @returns `NaN` on error, otherwise a `number`.
-     */
-    getNumber(handle: QuickJSHandle): number;
-    /**
-     * Converts `handle` to a Javascript string.
-     */
-    getString(handle: QuickJSHandle): string;
-    /**
-     * Converts `handle` into a Javascript symbol. If the symbol is in the global
-     * registry in the guest, it will be created with Symbol.for on the host.
-     */
-    getSymbol(handle: QuickJSHandle): symbol;
-    /**
-     * Converts `handle` to a Javascript bigint.
-     */
-    getBigInt(handle: QuickJSHandle): bigint;
-    /**
-     * `Promise.resolve(value)`.
-     * Convert a handle containing a Promise-like value inside the VM into an
-     * actual promise on the host.
-     *
-     * @remarks
-     * You may need to call [[executePendingJobs]] to ensure that the promise is resolved.
-     *
-     * @param promiseLikeHandle - A handle to a Promise-like value with a `.then(onSuccess, onError)` method.
-     */
-    resolvePromise(promiseLikeHandle: QuickJSHandle): Promise<VmCallResult<QuickJSHandle>>;
-    /**
-     * `handle[key]`.
-     * Get a property from a JSValue.
-     *
-     * @param key - The property may be specified as a JSValue handle, or as a
-     * Javascript string (which will be converted automatically).
-     */
-    getProp(handle: QuickJSHandle, key: QuickJSPropertyKey): QuickJSHandle;
-    /**
-     * `handle[key] = value`.
-     * Set a property on a JSValue.
-     *
-     * @remarks
-     * Note that the QuickJS authors recommend using [[defineProp]] to define new
-     * properties.
-     *
-     * @param key - The property may be specified as a JSValue handle, or as a
-     * Javascript string or number (which will be converted automatically to a JSValue).
-     */
-    setProp(handle: QuickJSHandle, key: QuickJSPropertyKey, value: QuickJSHandle): void;
-    /**
-     * [`Object.defineProperty(handle, key, descriptor)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty).
-     *
-     * @param key - The property may be specified as a JSValue handle, or as a
-     * Javascript string or number (which will be converted automatically to a JSValue).
-     */
-    defineProp(handle: QuickJSHandle, key: QuickJSPropertyKey, descriptor: VmPropertyDescriptor<QuickJSHandle>): void;
-    /**
-     * [`func.call(thisVal, ...args)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call).
-     * Call a JSValue as a function.
-     *
-     * See [[unwrapResult]], which will throw if the function returned an error, or
-     * return the result handle directly. If evaluation returned a handle containing
-     * a promise, use [[resolvePromise]] to convert it to a native promise and
-     * [[executePendingJobs]] to finish evaluating the promise.
-     *
-     * @returns A result. If the function threw synchronously, `result.error` be a
-     * handle to the exception. Otherwise `result.value` will be a handle to the
-     * value.
-     */
-    callFunction(func: QuickJSHandle, thisVal: QuickJSHandle, ...args: QuickJSHandle[]): VmCallResult<QuickJSHandle>;
-    /**
-     * Like [`eval(code)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval#Description).
-     * Evaluates the Javascript source `code` in the global scope of this VM.
-     * When working with async code, you many need to call [[executePendingJobs]]
-     * to execute callbacks pending after synchronous evaluation returns.
-     *
-     * See [[unwrapResult]], which will throw if the function returned an error, or
-     * return the result handle directly. If evaluation returned a handle containing
-     * a promise, use [[resolvePromise]] to convert it to a native promise and
-     * [[executePendingJobs]] to finish evaluating the promise.
-     *
-     * *Note*: to protect against infinite loops, provide an interrupt handler to
-     * [[setInterruptHandler]]. You can use [[shouldInterruptAfterDeadline]] to
-     * create a time-based deadline.
-     *
-     * @returns The last statement's value. If the code threw synchronously,
-     * `result.error` will be a handle to the exception. If execution was
-     * interrupted, the error will have name `InternalError` and message
-     * `interrupted`.
-     */
-    evalCode(code: string, filename?: string, 
-    /**
-     * If no options are passed, a heuristic will be used to detect if `code` is
-     * an ES module.
-     *
-     * See [[EvalFlags]] for number semantics.
-     */
-    options?: number | ContextEvalOptions): VmCallResult<QuickJSHandle>;
-    /**
-     * Throw an error in the VM, interrupted whatever current execution is in progress when execution resumes.
-     * @experimental
-     */
-    throw(error: Error | QuickJSHandle): any;
-    /**
-     * @private
-     */
-    protected borrowPropertyKey(key: QuickJSPropertyKey): QuickJSHandle;
-    /**
-     * @private
-     */
-    getMemory(rt: JSRuntimePointer): ContextMemory;
-    /**
-     * Dump a JSValue to Javascript in a best-effort fashion.
-     * Returns `handle.toString()` if it cannot be serialized to JSON.
-     */
-    dump(handle: QuickJSHandle): any;
-    /**
-     * Unwrap a SuccessOrFail result such as a [[VmCallResult]] or a
-     * [[ExecutePendingJobsResult]], where the fail branch contains a handle to a QuickJS error value.
-     * If the result is a success, returns the value.
-     * If the result is an error, converts the error to a native object and throws the error.
-     */
-    unwrapResult<T>(result: SuccessOrFail<T, QuickJSHandle>): T;
-    /** @private */
-    protected fnNextId: number;
-    /** @private */
-    protected fnMaps: Map<number, Map<number, VmFunctionImplementation<QuickJSHandle>>>;
-    /** @private */
-    protected getFunction(fn_id: number): VmFunctionImplementation<QuickJSHandle> | undefined;
-    /** @private */
-    protected setFunction(fn_id: number, handle: VmFunctionImplementation<QuickJSHandle>): Map<number, VmFunctionImplementation<QuickJSHandle>>;
-    /**
-     * @hidden
-     */
-    private cToHostCallbacks;
-    private errorToHandle;
-}
-export {};