@drocketxx/pm2me 1.1.8 → 1.1.10

package/backend/node_modules/@tootallnate/quickjs-emscripten/dist/types-ffi.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-ffi.js","sourceRoot":"","sources":["../ts/types-ffi.ts"],"names":[],"mappings":";;;AAyGA,SAAgB,UAAU,CAAwB,EAAwB;IACxE,OAAO,SAAS,UAAU,CAAC,GAAG,IAAU;QACtC,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAA;QAC1B,IAAI,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,YAAY,OAAO,EAAE;YACrE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAA;SAC5D;QACD,OAAO,MAAM,CAAA;IACf,CAAC,CAAA;AACH,CAAC;AARD,gCAQC;AAED,iDAAiD;AACpC,QAAA,SAAS,GAAG;IACvB,4BAA4B;IAC5B,mBAAmB,EAAE,CAAC,IAAI,CAAC;IAC3B,kBAAkB;IAClB,mBAAmB,EAAE,CAAC,IAAI,CAAC;IAC3B,iCAAiC;IACjC,mBAAmB,EAAE,CAAC,IAAI,CAAC;IAC3B,mCAAmC;IACnC,qBAAqB,EAAE,CAAC,IAAI,CAAC;IAC7B,iBAAiB,EAAE,CAAC,IAAI,CAAC;IACzB,0BAA0B;IAC1B,mBAAmB,EAAE,CAAC,IAAI,CAAC;IAC3B,yBAAyB;IACzB,kBAAkB,EAAE,CAAC,IAAI,CAAC;IAC1B;;;;OAIG;IACH,yBAAyB,EAAE,CAAC,IAAI,CAAC;IACjC,gFAAgF;IAChF,8BAA8B,EAAE,CAAC,IAAI,CAAC;CACvC,CAAA","sourcesContent":["/**\n * C pointer to type `CType`. Pointer types are used internally for FFI, but\n * are not intended for external use.\n *\n * @unstable This type is considered private and may change.\n */\ntype Pointer<CType extends string> = number & { ctype: CType }\n\ntype Brand<T, B> = T & { brand: B }\n\n/**\n * `JSRuntime*`.\n */\nexport type JSRuntimePointer = Pointer<\"JSRuntime\">\n\n/**\n * `JSContext*`.\n */\nexport type JSContextPointer = Pointer<\"JSContext\">\n\n/**\n * `JSContext**`. Used internally for execute pending jobs.\n */\nexport type JSContextPointerPointer = Pointer<\"JSContext\">\n\n/**\n * `JSModuleDef*`.\n */\nexport type JSModuleDefPointer = Pointer<\"JSModuleDef\">\n\n/**\n * `JSValue*`.\n * See [[JSValue]].\n */\nexport type JSValuePointer = Pointer<\"JSValue\">\n\n/**\n * `JSValueConst*\n * See [[JSValueConst]] and [[StaticJSValue]].\n */\nexport type JSValueConstPointer = Pointer<\"JSValueConst\">\n\n/**\n * Used internally for Javascript-to-C function calls.\n */\nexport type JSValuePointerPointer = Pointer<\"JSValue[]\">\n\n/**\n * Used internally for Javascript-to-C function calls.\n */\nexport type JSValueConstPointerPointer = Pointer<\"JSValueConst[]\">\n\n/**\n * Used internally for C-to-Javascript function calls.\n */\n// type JSCFunctionPointer = Pointer<'JSCFunction'>\n\n/**\n * Used internally for C-to-Javascript function calls.\n */\nexport type QTS_C_To_HostCallbackFuncPointer = Pointer<\"C_To_HostCallbackFunc\">\n\n/**\n * Used internally for C-to-Javascript interrupt handlers.\n */\nexport type QTS_C_To_HostInterruptFuncPointer = Pointer<\"C_To_HostInterruptFunc\">\n\n/**\n * Used internally for C-to-Javascript module loading.\n */\nexport type QTS_C_To_HostLoadModuleFuncPointer = Pointer<\"C_To_HostLoadModuleFunc\">\n\n/**\n * Used internally for Javascript-to-C calls that may contain strings too large\n * for the Emscripten stack.\n */\nexport type BorrowedHeapCharPointer = Pointer<\"const char\" | \"char\" | \"js const char\">\n\n/**\n * Used internally for Javascript-to-C calls that may contain strings too large\n * for the Emscripten stack.\n */\nexport type OwnedHeapCharPointer = Pointer<\"char\">\n\n/**\n * Used internally for Javascript-to-C calls that may contain strings too large\n * for the Emscripten stack.\n */\nexport type JSBorrowedCharPointer = Pointer<\"js const char\">\n\n/**\n * Opaque pointer that was allocated by js_malloc.\n */\nexport type JSVoidPointer = Pointer<any>\n\n/**\n * @private\n */\nexport type EvalFlags = Brand<number, \"EvalFlags\">\n\n/**\n * @private\n */\nexport type EvalDetectModule = Brand<number, \"EvalDetectModule\">\n\nexport function assertSync<Args extends any[], R>(fn: (...args: Args) => R): (...args: Args) => R {\n  return function mustBeSync(...args: Args): R {\n    const result = fn(...args)\n    if (result && typeof result === \"object\" && result instanceof Promise) {\n      throw new Error(\"Function unexpectedly returned a Promise\")\n    }\n    return result\n  }\n}\n\n/** Bitfield options for JS_Eval() C function. */\nexport const EvalFlags = {\n  /** global code (default) */\n  JS_EVAL_TYPE_GLOBAL: 0 << 0,\n  /** module code */\n  JS_EVAL_TYPE_MODULE: 1 << 0,\n  /** direct call (internal use) */\n  JS_EVAL_TYPE_DIRECT: 2 << 0,\n  /** indirect call (internal use) */\n  JS_EVAL_TYPE_INDIRECT: 3 << 0,\n  JS_EVAL_TYPE_MASK: 3 << 0,\n  /** force 'strict' mode */\n  JS_EVAL_FLAG_STRICT: 1 << 3,\n  /** force 'strip' mode */\n  JS_EVAL_FLAG_STRIP: 1 << 4,\n  /**\n   * compile but do not run. The result is an object with a\n   * JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed\n   * with JS_EvalFunction().\n   */\n  JS_EVAL_FLAG_COMPILE_ONLY: 1 << 5,\n  /** don't include the stack frames before this eval in the Error() backtraces */\n  JS_EVAL_FLAG_BACKTRACE_BARRIER: 1 << 6,\n}\n"]}

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

@@ -1,158 +0,0 @@
-import type { QuickJSFFI, QuickJSAsyncFFI } from "./variants";
-import type { QuickJSContext } from "./context";
-import type { SuccessOrFail, VmFunctionImplementation } from "./vm-interface";
-import type { Disposable, Lifetime } from "./lifetime";
-import type { QuickJSAsyncContext } from "./context-asyncify";
-import type { InterruptHandler, QuickJSRuntime } from "./runtime";
-import { JSContextPointer, JSValueConstPointer, JSValuePointer } from "./types-ffi";
-export type EitherFFI = QuickJSFFI | QuickJSAsyncFFI;
-/**
- * A QuickJSHandle to a constant that will never change, and does not need to
- * be disposed.
- */
-export type StaticJSValue = Lifetime<JSValueConstPointer, JSValueConstPointer, QuickJSRuntime>;
-/**
- * A QuickJSHandle to a borrowed value that does not need to be disposed.
- *
- * In QuickJS, a JSValueConst is a "borrowed" reference that isn't owned by the
- * current scope. That means that the current scope should not `JS_FreeValue`
- * it, or retain a reference to it after the scope exits, because it may be
- * freed by its owner.
- *
- * quickjs-emscripten takes care of disposing JSValueConst references.
- */
-export type JSValueConst = Lifetime<JSValueConstPointer, JSValuePointer, QuickJSRuntime>;
-/**
- * A owned QuickJSHandle that should be disposed or returned.
- *
- * The QuickJS interpreter passes Javascript values between functions as
- * `JSValue` structs that references some internal data. Because passing
- * structs cross the Empscripten FFI interfaces is bothersome, we use pointers
- * to these structs instead.
- *
- * A JSValue reference is "owned" in its scope. before exiting the scope, it
- * should be freed,  by calling `JS_FreeValue(ctx, js_value)`) or returned from
- * the scope. We extend that contract - a JSValuePointer (`JSValue*`) must also
- * be `free`d.
- *
- * You can do so from Javascript by calling the .dispose() method.
- */
-export type JSValue = Lifetime<JSValuePointer, JSValuePointer, QuickJSRuntime>;
-/**
- * Wraps a C pointer to a QuickJS JSValue, which represents a Javascript value inside
- * a QuickJS virtual machine.
- *
- * Values must not be shared between QuickJSContext instances.
- * You must dispose of any handles you create by calling the `.dispose()` method.
- */
-export type QuickJSHandle = StaticJSValue | JSValue | JSValueConst;
-export type JSModuleExport = {
-    type: "function";
-    name: string;
-    implementation: (vm: QuickJSContext) => VmFunctionImplementation<QuickJSHandle>;
-} | {
-    type: "value";
-    name: string;
-    value: (vm: QuickJSContext) => QuickJSHandle;
-};
-export interface JSModuleDefinition {
-    name: string;
-    exports: JSModuleExport[];
-}
-export type JSModuleLoadSuccess = string;
-export type JSModuleLoadFailure = Error | QuickJSHandle;
-export type JSModuleLoadResult = JSModuleLoadSuccess | SuccessOrFail<JSModuleLoadSuccess, JSModuleLoadFailure>;
-export interface JSModuleLoaderAsync {
-    /** Load module (async) */
-    (moduleName: string, context: QuickJSAsyncContext): JSModuleLoadResult | Promise<JSModuleLoadResult>;
-}
-export interface JSModuleLoader {
-    /** Load module (sync) */
-    (moduleName: string, context: QuickJSContext): JSModuleLoadResult;
-}
-export type JSModuleNormalizeSuccess = string;
-export type JSModuleNormalizeFailure = Error | QuickJSHandle;
-export type JSModuleNormalizeResult = JSModuleNormalizeSuccess | SuccessOrFail<JSModuleNormalizeSuccess, JSModuleNormalizeFailure>;
-export interface JSModuleNormalizerAsync {
-    (baseModuleName: string, requestedName: string, vm: QuickJSAsyncContext): JSModuleNormalizeResult | Promise<JSModuleNormalizeResult>;
-}
-export interface JSModuleNormalizer extends JSModuleNormalizerAsync {
-    (baseModuleName: string, requestedName: string, vm: QuickJSContext): JSModuleNormalizeResult;
-}
-type TODO<hint extends string = "?", typeHint = unknown> = never;
-declare const UnstableSymbol: unique symbol;
-export type PartiallyImplemented<T> = never & T & {
-    [UnstableSymbol]: "This feature may unimplemented, broken, throw errors, etc.";
-};
-export interface RuntimeOptionsBase {
-    interruptHandler?: InterruptHandler;
-    maxStackSizeBytes?: number;
-    memoryLimitBytes?: number;
-    promiseRejectionHandler?: TODO<"JSHostPromiseRejectionTracker">;
-    runtimeInfo?: TODO<"JS_SetRuntimeInfo", string>;
-    gcThreshold?: TODO<"JS_SetGCThreshold", number>;
-    sharedArrayBufferFunctions?: TODO<"JS_SetJSSharedArrayBufferFunctions", {
-        sab_alloc: TODO;
-        sab_free: TODO;
-        sab_dup: TODO;
-        sab_opaque: TODO;
-    }>;
-    /**
-     * Extra lifetimes the runtime should dispose of after it is destroyed.
-     * @private
-     */
-    ownedLifetimes?: Disposable[];
-}
-export interface RuntimeOptions extends RuntimeOptionsBase {
-    moduleLoader?: JSModuleLoader;
-}
-export interface AsyncRuntimeOptions extends RuntimeOptionsBase {
-    moduleLoader?: JSModuleLoaderAsync | JSModuleLoader;
-}
-/**
- * Work in progress.
- */
-export type Intrinsic = "BaseObjects" | "Date" | "Eval" | "StringNormalize" | "RegExp" | "RegExpCompiler" | "JSON" | "Proxy" | "MapSet" | "TypedArrays" | "Promise" | "BigInt" | "BigFloat" | "BigDecimal" | "OperatorOverloading" | "BignumExt";
-/**
- * Work in progress.
- */
-export declare const DefaultIntrinsics: unique symbol;
-export interface ContextOptions {
-    /**
-     * What built-in objects and language features to enable?
-     * If unset, the default intrinsics will be used.
-     * To omit all intrinsics, pass an empty array.
-     */
-    intrinsics?: PartiallyImplemented<Intrinsic[]> | typeof DefaultIntrinsics;
-    /**
-     * Wrap the provided context instead of constructing a new one.
-     * @private
-     */
-    contextPointer?: JSContextPointer;
-    /**
-     * Extra lifetimes the context should dispose of after it is destroyed.
-     * @private
-     */
-    ownedLifetimes?: Disposable[];
-}
-export interface ContextEvalOptions {
-    /** Global code (default) */
-    type?: "global" | "module";
-    /** Force "strict" mode */
-    strict?: boolean;
-    /** Force "strip" mode */
-    strip?: boolean;
-    /**
-     * 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().
-     */
-    compileOnly?: boolean;
-    /** don't include the stack frames before this eval in the Error() backtraces */
-    backtraceBarrier?: boolean;
-}
-/** Convert [[ContextEvalOptions]] to a bitfield flags */
-export declare function evalOptionsToFlags(evalOptions: ContextEvalOptions | number | undefined): number;
-export type PromiseExecutor<ResolveT, RejectT> = (resolve: (value: ResolveT | PromiseLike<ResolveT>) => void, reject: (reason: RejectT) => void) => void;
-export declare function concat<T>(...values: Array<T[] | T | undefined>): T[];
-export {};

package/backend/node_modules/@tootallnate/quickjs-emscripten/dist/types.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.concat = exports.evalOptionsToFlags = exports.DefaultIntrinsics = void 0;
-const types_ffi_1 = require("./types-ffi");
-const UnstableSymbol = Symbol("Unstable");
-// For informational purposes
-const DefaultIntrinsicsList = [
-    "BaseObjects",
-    "Date",
-    "Eval",
-    "StringNormalize",
-    "RegExp",
-    "JSON",
-    "Proxy",
-    "MapSet",
-    "TypedArrays",
-    "Promise",
-];
-/**
- * Work in progress.
- */
-exports.DefaultIntrinsics = Symbol("DefaultIntrinsics");
-/** Convert [[ContextEvalOptions]] to a bitfield flags */
-function evalOptionsToFlags(evalOptions) {
-    if (typeof evalOptions === "number") {
-        return evalOptions;
-    }
-    if (evalOptions === undefined) {
-        return 0;
-    }
-    const { type, strict, strip, compileOnly, backtraceBarrier } = evalOptions;
-    let flags = 0;
-    if (type === "global")
-        flags |= types_ffi_1.EvalFlags.JS_EVAL_TYPE_GLOBAL;
-    if (type === "module")
-        flags |= types_ffi_1.EvalFlags.JS_EVAL_TYPE_MODULE;
-    if (strict)
-        flags |= types_ffi_1.EvalFlags.JS_EVAL_FLAG_STRICT;
-    if (strip)
-        flags |= types_ffi_1.EvalFlags.JS_EVAL_FLAG_STRIP;
-    if (compileOnly)
-        flags |= types_ffi_1.EvalFlags.JS_EVAL_FLAG_COMPILE_ONLY;
-    if (backtraceBarrier)
-        flags |= types_ffi_1.EvalFlags.JS_EVAL_FLAG_BACKTRACE_BARRIER;
-    return flags;
-}
-exports.evalOptionsToFlags = evalOptionsToFlags;
-function concat(...values) {
-    let result = [];
-    for (const value of values) {
-        if (value !== undefined) {
-            result = result.concat(value);
-        }
-    }
-    return result;
-}
-exports.concat = concat;
-//# sourceMappingURL=types.js.map

package/backend/node_modules/@tootallnate/quickjs-emscripten/dist/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../ts/types.ts"],"names":[],"mappings":";;;AAMA,2CAA8F;AA+F9F,MAAM,cAAc,GAAG,MAAM,CAAC,UAAU,CAAC,CAAA;AAwDzC,6BAA6B;AAC7B,MAAM,qBAAqB,GAAG;IAC5B,aAAa;IACb,MAAM;IACN,MAAM;IACN,iBAAiB;IACjB,QAAQ;IACR,MAAM;IACN,OAAO;IACP,QAAQ;IACR,aAAa;IACb,SAAS;CACD,CAAA;AAEV;;GAEG;AACU,QAAA,iBAAiB,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAA;AAwC5D,yDAAyD;AACzD,SAAgB,kBAAkB,CAAC,WAAoD;IACrF,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE;QACnC,OAAO,WAAW,CAAA;KACnB;IAED,IAAI,WAAW,KAAK,SAAS,EAAE;QAC7B,OAAO,CAAC,CAAA;KACT;IAED,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,GAAG,WAAW,CAAA;IAC1E,IAAI,KAAK,GAAG,CAAC,CAAA;IACb,IAAI,IAAI,KAAK,QAAQ;QAAE,KAAK,IAAI,qBAAS,CAAC,mBAAmB,CAAA;IAC7D,IAAI,IAAI,KAAK,QAAQ;QAAE,KAAK,IAAI,qBAAS,CAAC,mBAAmB,CAAA;IAC7D,IAAI,MAAM;QAAE,KAAK,IAAI,qBAAS,CAAC,mBAAmB,CAAA;IAClD,IAAI,KAAK;QAAE,KAAK,IAAI,qBAAS,CAAC,kBAAkB,CAAA;IAChD,IAAI,WAAW;QAAE,KAAK,IAAI,qBAAS,CAAC,yBAAyB,CAAA;IAC7D,IAAI,gBAAgB;QAAE,KAAK,IAAI,qBAAS,CAAC,8BAA8B,CAAA;IACvE,OAAO,KAAK,CAAA;AACd,CAAC;AAlBD,gDAkBC;AAOD,SAAgB,MAAM,CAAI,GAAG,MAAkC;IAC7D,IAAI,MAAM,GAAQ,EAAE,CAAA;IACpB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;QAC1B,IAAI,KAAK,KAAK,SAAS,EAAE;YACvB,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;SAC9B;KACF;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AARD,wBAQC","sourcesContent":["import type { QuickJSFFI, QuickJSAsyncFFI } from \"./variants\"\nimport type { QuickJSContext } from \"./context\"\nimport type { SuccessOrFail, VmFunctionImplementation } from \"./vm-interface\"\nimport type { Disposable, Lifetime } from \"./lifetime\"\nimport type { QuickJSAsyncContext } from \"./context-asyncify\"\nimport type { InterruptHandler, QuickJSRuntime } from \"./runtime\"\nimport { EvalFlags, JSContextPointer, JSValueConstPointer, JSValuePointer } from \"./types-ffi\"\n\nexport type EitherFFI = QuickJSFFI | QuickJSAsyncFFI\n\n/**\n * A QuickJSHandle to a constant that will never change, and does not need to\n * be disposed.\n */\nexport type StaticJSValue = Lifetime<JSValueConstPointer, JSValueConstPointer, QuickJSRuntime>\n\n/**\n * A QuickJSHandle to a borrowed value that does not need to be disposed.\n *\n * In QuickJS, a JSValueConst is a \"borrowed\" reference that isn't owned by the\n * current scope. That means that the current scope should not `JS_FreeValue`\n * it, or retain a reference to it after the scope exits, because it may be\n * freed by its owner.\n *\n * quickjs-emscripten takes care of disposing JSValueConst references.\n */\nexport type JSValueConst = Lifetime<JSValueConstPointer, JSValuePointer, QuickJSRuntime>\n\n/**\n * A owned QuickJSHandle that should be disposed or returned.\n *\n * The QuickJS interpreter passes Javascript values between functions as\n * `JSValue` structs that references some internal data. Because passing\n * structs cross the Empscripten FFI interfaces is bothersome, we use pointers\n * to these structs instead.\n *\n * A JSValue reference is \"owned\" in its scope. before exiting the scope, it\n * should be freed,  by calling `JS_FreeValue(ctx, js_value)`) or returned from\n * the scope. We extend that contract - a JSValuePointer (`JSValue*`) must also\n * be `free`d.\n *\n * You can do so from Javascript by calling the .dispose() method.\n */\nexport type JSValue = Lifetime<JSValuePointer, JSValuePointer, QuickJSRuntime>\n\n/**\n * Wraps a C pointer to a QuickJS JSValue, which represents a Javascript value inside\n * a QuickJS virtual machine.\n *\n * Values must not be shared between QuickJSContext instances.\n * You must dispose of any handles you create by calling the `.dispose()` method.\n */\nexport type QuickJSHandle = StaticJSValue | JSValue | JSValueConst\n\nexport type JSModuleExport =\n  | {\n      type: \"function\"\n      name: string\n      implementation: (vm: QuickJSContext) => VmFunctionImplementation<QuickJSHandle>\n    }\n  | { type: \"value\"; name: string; value: (vm: QuickJSContext) => QuickJSHandle }\n\nexport interface JSModuleDefinition {\n  name: string\n  exports: JSModuleExport[]\n}\n\nexport type JSModuleLoadSuccess = string\nexport type JSModuleLoadFailure = Error | QuickJSHandle\nexport type JSModuleLoadResult =\n  | JSModuleLoadSuccess\n  | SuccessOrFail<JSModuleLoadSuccess, JSModuleLoadFailure>\n\nexport interface JSModuleLoaderAsync {\n  /** Load module (async) */\n  (moduleName: string, context: QuickJSAsyncContext):\n    | JSModuleLoadResult\n    | Promise<JSModuleLoadResult>\n}\nexport interface JSModuleLoader {\n  /** Load module (sync) */\n  (moduleName: string, context: QuickJSContext): JSModuleLoadResult\n}\n\nexport type JSModuleNormalizeSuccess = string\nexport type JSModuleNormalizeFailure = Error | QuickJSHandle\nexport type JSModuleNormalizeResult =\n  | JSModuleNormalizeSuccess\n  | SuccessOrFail<JSModuleNormalizeSuccess, JSModuleNormalizeFailure>\n\nexport interface JSModuleNormalizerAsync {\n  (baseModuleName: string, requestedName: string, vm: QuickJSAsyncContext):\n    | JSModuleNormalizeResult\n    | Promise<JSModuleNormalizeResult>\n}\nexport interface JSModuleNormalizer extends JSModuleNormalizerAsync {\n  (baseModuleName: string, requestedName: string, vm: QuickJSContext): JSModuleNormalizeResult\n}\n\ntype TODO<hint extends string = \"?\", typeHint = unknown> = never\n\nconst UnstableSymbol = Symbol(\"Unstable\")\n\nexport type PartiallyImplemented<T> = never &\n  T & {\n    [UnstableSymbol]: \"This feature may unimplemented, broken, throw errors, etc.\"\n  }\n\nexport interface RuntimeOptionsBase {\n  interruptHandler?: InterruptHandler\n  maxStackSizeBytes?: number\n  memoryLimitBytes?: number\n\n  promiseRejectionHandler?: TODO<\"JSHostPromiseRejectionTracker\">\n  runtimeInfo?: TODO<\"JS_SetRuntimeInfo\", string>\n  gcThreshold?: TODO<\"JS_SetGCThreshold\", number>\n  sharedArrayBufferFunctions?: TODO<\n    \"JS_SetJSSharedArrayBufferFunctions\",\n    { sab_alloc: TODO; sab_free: TODO; sab_dup: TODO; sab_opaque: TODO }\n  >\n\n  /**\n   * Extra lifetimes the runtime should dispose of after it is destroyed.\n   * @private\n   */\n  ownedLifetimes?: Disposable[]\n}\n\nexport interface RuntimeOptions extends RuntimeOptionsBase {\n  moduleLoader?: JSModuleLoader\n}\n\nexport interface AsyncRuntimeOptions extends RuntimeOptionsBase {\n  moduleLoader?: JSModuleLoaderAsync | JSModuleLoader\n}\n\n/**\n * Work in progress.\n */\nexport type Intrinsic =\n  | \"BaseObjects\"\n  | \"Date\"\n  | \"Eval\"\n  | \"StringNormalize\"\n  | \"RegExp\"\n  | \"RegExpCompiler\"\n  | \"JSON\"\n  | \"Proxy\"\n  | \"MapSet\"\n  | \"TypedArrays\"\n  | \"Promise\"\n  | \"BigInt\"\n  | \"BigFloat\"\n  | \"BigDecimal\"\n  | \"OperatorOverloading\"\n  | \"BignumExt\"\n\n// For informational purposes\nconst DefaultIntrinsicsList = [\n  \"BaseObjects\",\n  \"Date\",\n  \"Eval\",\n  \"StringNormalize\",\n  \"RegExp\",\n  \"JSON\",\n  \"Proxy\",\n  \"MapSet\",\n  \"TypedArrays\",\n  \"Promise\",\n] as const\n\n/**\n * Work in progress.\n */\nexport const DefaultIntrinsics = Symbol(\"DefaultIntrinsics\")\n\nexport interface ContextOptions {\n  /**\n   * What built-in objects and language features to enable?\n   * If unset, the default intrinsics will be used.\n   * To omit all intrinsics, pass an empty array.\n   */\n  intrinsics?: PartiallyImplemented<Intrinsic[]> | typeof DefaultIntrinsics\n\n  /**\n   * Wrap the provided context instead of constructing a new one.\n   * @private\n   */\n  contextPointer?: JSContextPointer\n\n  /**\n   * Extra lifetimes the context should dispose of after it is destroyed.\n   * @private\n   */\n  ownedLifetimes?: Disposable[]\n}\n\nexport interface ContextEvalOptions {\n  /** Global code (default) */\n  type?: \"global\" | \"module\"\n  /** Force \"strict\" mode */\n  strict?: boolean\n  /** Force \"strip\" mode */\n  strip?: boolean\n  /**\n   * compile but do not run. The result is an object with a\n   * JS_TAG_FUNCTION_BYTECODE or JS_TAG_MODULE tag. It can be executed\n   * with JS_EvalFunction().\n   */\n  compileOnly?: boolean\n  /** don't include the stack frames before this eval in the Error() backtraces */\n  backtraceBarrier?: boolean\n}\n\n/** Convert [[ContextEvalOptions]] to a bitfield flags */\nexport function evalOptionsToFlags(evalOptions: ContextEvalOptions | number | undefined): number {\n  if (typeof evalOptions === \"number\") {\n    return evalOptions\n  }\n\n  if (evalOptions === undefined) {\n    return 0\n  }\n\n  const { type, strict, strip, compileOnly, backtraceBarrier } = evalOptions\n  let flags = 0\n  if (type === \"global\") flags |= EvalFlags.JS_EVAL_TYPE_GLOBAL\n  if (type === \"module\") flags |= EvalFlags.JS_EVAL_TYPE_MODULE\n  if (strict) flags |= EvalFlags.JS_EVAL_FLAG_STRICT\n  if (strip) flags |= EvalFlags.JS_EVAL_FLAG_STRIP\n  if (compileOnly) flags |= EvalFlags.JS_EVAL_FLAG_COMPILE_ONLY\n  if (backtraceBarrier) flags |= EvalFlags.JS_EVAL_FLAG_BACKTRACE_BARRIER\n  return flags\n}\n\nexport type PromiseExecutor<ResolveT, RejectT> = (\n  resolve: (value: ResolveT | PromiseLike<ResolveT>) => void,\n  reject: (reason: RejectT) => void\n) => void\n\nexport function concat<T>(...values: Array<T[] | T | undefined>): T[] {\n  let result: T[] = []\n  for (const value of values) {\n    if (value !== undefined) {\n      result = result.concat(value)\n    }\n  }\n  return result\n}\n"]}

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

@@ -1,113 +0,0 @@
-import type { QuickJSFFI as ReleaseSyncFFI } from "./generated/ffi.WASM_RELEASE_SYNC";
-import type { EmscriptenModuleLoader, QuickJSEmscriptenModule, QuickJSAsyncEmscriptenModule } from "./emscripten-types";
-import type { QuickJSWASMModule } from "./module";
-import type { QuickJSAsyncWASMModule } from "./module-asyncify";
-/** @private */
-export type QuickJSFFI = ReleaseSyncFFI;
-/** @private */
-export type QuickJSFFIConstructor = typeof ReleaseSyncFFI;
-/** @private */
-export type QuickJSAsyncFFI = any;
-/** @private */
-export type QuickJSAsyncFFIConstructor = any;
-/**
- * quickjs-emscripten provides multiple build variants of the core WebAssembly
- * module. These variants are each intended for a different use case.
- *
- * To create an instance of the library using a specific build variant, pass the
- * build variant to {@link newQuickJSWASMModule} or {@link newQuickJSAsyncWASMModule}.
- *
- * Synchronous build variants:
- *
- * - {@link RELEASE_SYNC} - This is the default synchronous variant, for general purpose use.
- * - {@link DEBUG_SYNC} - Synchronous build variant for debugging memory leaks.
- */
-export interface SyncBuildVariant {
-    type: "sync";
-    importFFI: () => Promise<QuickJSFFIConstructor>;
-    importModuleLoader: () => Promise<EmscriptenModuleLoader<QuickJSEmscriptenModule>>;
-}
-/**
- * quickjs-emscripten provides multiple build variants of the core WebAssembly
- * module. These variants are each intended for a different use case.
- *
- * To create an instance of the library using a specific build variant, pass the
- * build variant to {@link newQuickJSWASMModule} or {@link newQuickJSAsyncWASMModule}.
- *
- * Asyncified build variants:
- *
- * - {@link RELEASE_ASYNC} - This is the default asyncified build variant, for general purpose use.
- * - {@link DEBUG_ASYNC} - Asyncified build variant with debug logging.
- */
-export interface AsyncBuildVariant {
-    type: "async";
-    importFFI: () => Promise<QuickJSAsyncFFIConstructor>;
-    importModuleLoader: () => Promise<EmscriptenModuleLoader<QuickJSAsyncEmscriptenModule>>;
-}
-/**
- * Create a new, completely isolated WebAssembly module containing the QuickJS library.
- * See the documentation on [[QuickJSWASMModule]].
- *
- * 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
- */
-export declare function newQuickJSWASMModule(
-/**
- * Optionally, pass a {@link SyncBuildVariant} to construct a different WebAssembly module.
- */
-variant?: SyncBuildVariant): Promise<QuickJSWASMModule>;
-/**
- * Create a new, completely isolated WebAssembly module containing a version of the QuickJS library
- * compiled with Emscripten's [ASYNCIFY](https://emscripten.org/docs/porting/asyncify.html) transform.
- *
- * This version of the library offers features that enable synchronous code
- * inside the VM to interact with asynchronous code in the host environment.
- * See the documentation on [[QuickJSAsyncWASMModule]], [[QuickJSAsyncRuntime]],
- * and [[QuickJSAsyncContext]].
- *
- * 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
- */
-export declare function newQuickJSAsyncWASMModule(
-/**
- * Optionally, pass a {@link AsyncBuildVariant} to construct a different WebAssembly module.
- */
-variant?: AsyncBuildVariant): Promise<QuickJSAsyncWASMModule>;
-/**
- * Helper intended to memoize the creation of a WebAssembly module.
- * ```typescript
- * const getDebugModule = memoizePromiseFactory(() => newQuickJSWASMModule(DEBUG_SYNC))
- * ```
- */
-export declare function memoizePromiseFactory<T>(fn: () => Promise<T>): () => Promise<T>;
-/**
- * This build variant is compiled with `-fsanitize=leak`. It instruments all
- * memory allocations and when combined with sourcemaps, can present stack trace
- * locations where memory leaks occur.
- *
- * See [[TestQuickJSWASMModule]] which provides access to the leak sanitizer via
- * {@link TestQuickJSWASMModule.assertNoMemoryAllocated}.
- *
- * The downside is that it's 100-1000x slower than the other variants.
- * Suggested use case: automated testing, regression testing, and interactive
- * debugging.
- */
-export declare const DEBUG_SYNC: SyncBuildVariant;
-/**
- * This is the default (synchronous) build variant.
- * {@link getQuickJS} returns a memoized instance of this build variant.
- */
-export declare const RELEASE_SYNC: SyncBuildVariant;
-/**
- * The async debug build variant may or may not have the sanitizer enabled.
- * It does print a lot of debug logs.
- *
- * Suggested use case: interactive debugging only.
- */
-export declare const DEBUG_ASYNC: AsyncBuildVariant;
-/**
- * This is the default asyncified build variant.
- */
-export declare const RELEASE_ASYNC: AsyncBuildVariant;

package/backend/node_modules/@tootallnate/quickjs-emscripten/dist/variants.js

@@ -1,169 +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 __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.RELEASE_ASYNC = exports.DEBUG_ASYNC = exports.RELEASE_SYNC = exports.DEBUG_SYNC = exports.memoizePromiseFactory = exports.newQuickJSAsyncWASMModule = exports.newQuickJSWASMModule = void 0;
-const esmHelpers_1 = require("./esmHelpers");
-/**
- * Create a new, completely isolated WebAssembly module containing the QuickJS library.
- * See the documentation on [[QuickJSWASMModule]].
- *
- * 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 newQuickJSWASMModule(
-/**
- * Optionally, pass a {@link SyncBuildVariant} to construct a different WebAssembly module.
- */
-variant = exports.RELEASE_SYNC) {
-    const [wasmModuleLoader, QuickJSFFI, { QuickJSWASMModule }] = await Promise.all([
-        variant.importModuleLoader(),
-        variant.importFFI(),
-        Promise.resolve().then(() => __importStar(require("./module.js"))).then(esmHelpers_1.unwrapTypescript),
-    ]);
-    const wasmModule = await wasmModuleLoader();
-    wasmModule.type = "sync";
-    const ffi = new QuickJSFFI(wasmModule);
-    return new QuickJSWASMModule(wasmModule, ffi);
-}
-exports.newQuickJSWASMModule = newQuickJSWASMModule;
-/**
- * Create a new, completely isolated WebAssembly module containing a version of the QuickJS library
- * compiled with Emscripten's [ASYNCIFY](https://emscripten.org/docs/porting/asyncify.html) transform.
- *
- * This version of the library offers features that enable synchronous code
- * inside the VM to interact with asynchronous code in the host environment.
- * See the documentation on [[QuickJSAsyncWASMModule]], [[QuickJSAsyncRuntime]],
- * and [[QuickJSAsyncContext]].
- *
- * 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 newQuickJSAsyncWASMModule(
-/**
- * Optionally, pass a {@link AsyncBuildVariant} to construct a different WebAssembly module.
- */
-variant = exports.RELEASE_ASYNC) {
-    const [wasmModuleLoader, QuickJSAsyncFFI, { QuickJSAsyncWASMModule }] = await Promise.all([
-        variant.importModuleLoader(),
-        variant.importFFI(),
-        Promise.resolve().then(() => __importStar(require("./module-asyncify.js"))).then(esmHelpers_1.unwrapTypescript),
-    ]);
-    const wasmModule = await wasmModuleLoader();
-    wasmModule.type = "async";
-    const ffi = new QuickJSAsyncFFI(wasmModule);
-    return new QuickJSAsyncWASMModule(wasmModule, ffi);
-}
-exports.newQuickJSAsyncWASMModule = newQuickJSAsyncWASMModule;
-/**
- * Helper intended to memoize the creation of a WebAssembly module.
- * ```typescript
- * const getDebugModule = memoizePromiseFactory(() => newQuickJSWASMModule(DEBUG_SYNC))
- * ```
- */
-function memoizePromiseFactory(fn) {
-    let promise;
-    return () => {
-        return (promise ?? (promise = fn()));
-    };
-}
-exports.memoizePromiseFactory = memoizePromiseFactory;
-/**
- * This build variant is compiled with `-fsanitize=leak`. It instruments all
- * memory allocations and when combined with sourcemaps, can present stack trace
- * locations where memory leaks occur.
- *
- * See [[TestQuickJSWASMModule]] which provides access to the leak sanitizer via
- * {@link TestQuickJSWASMModule.assertNoMemoryAllocated}.
- *
- * The downside is that it's 100-1000x slower than the other variants.
- * Suggested use case: automated testing, regression testing, and interactive
- * debugging.
- */
-exports.DEBUG_SYNC = {
-    type: "sync",
-    async importFFI() {
-        throw new Error("not implemented");
-        // const mod = await import("./generated/ffi.WASM_DEBUG_SYNC.js")
-        // return unwrapTypescript(mod).QuickJSFFI
-    },
-    async importModuleLoader() {
-        throw new Error("not implemented");
-        // const mod = await import("./generated/emscripten-module.WASM_DEBUG_SYNC.js")
-        // return unwrapJavascript(mod).default
-    },
-};
-/**
- * This is the default (synchronous) build variant.
- * {@link getQuickJS} returns a memoized instance of this build variant.
- */
-exports.RELEASE_SYNC = {
-    type: "sync",
-    async importFFI() {
-        const mod = await Promise.resolve().then(() => __importStar(require("./generated/ffi.WASM_RELEASE_SYNC.js")));
-        return (0, esmHelpers_1.unwrapTypescript)(mod).QuickJSFFI;
-    },
-    async importModuleLoader() {
-        const mod = await Promise.resolve().then(() => __importStar(require("./generated/emscripten-module.WASM_RELEASE_SYNC.js")));
-        return (0, esmHelpers_1.unwrapJavascript)(mod);
-    },
-};
-/**
- * The async debug build variant may or may not have the sanitizer enabled.
- * It does print a lot of debug logs.
- *
- * Suggested use case: interactive debugging only.
- */
-exports.DEBUG_ASYNC = {
-    type: "async",
-    async importFFI() {
-        throw new Error("not implemented");
-        // const mod = await import("./generated/ffi.WASM_DEBUG_ASYNCIFY.js")
-        // return unwrapTypescript(mod).QuickJSAsyncFFI
-    },
-    async importModuleLoader() {
-        throw new Error("not implemented");
-        // const mod = await import("./generated/emscripten-module.WASM_DEBUG_ASYNCIFY.js")
-        // return unwrapJavascript(mod).default
-    },
-};
-/**
- * This is the default asyncified build variant.
- */
-exports.RELEASE_ASYNC = {
-    type: "async",
-    async importFFI() {
-        throw new Error("not implemented");
-        // const mod = await import("./generated/ffi.WASM_RELEASE_ASYNCIFY.js")
-        // return unwrapTypescript(mod).QuickJSAsyncFFI
-    },
-    async importModuleLoader() {
-        throw new Error("not implemented");
-        // const mod = await import("./generated/emscripten-module.WASM_RELEASE_ASYNCIFY.js")
-        // return unwrapJavascript(mod).default
-    },
-};
-//# sourceMappingURL=variants.js.map

package/backend/node_modules/@tootallnate/quickjs-emscripten/dist/variants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"variants.js","sourceRoot":"","sources":["../ts/variants.ts"],"names":[],"mappings":"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","sourcesContent":["//import type { QuickJSAsyncFFI as DebugAsyncifyFFI } from \"./generated/ffi.WASM_DEBUG_ASYNCIFY\"\n//import type { QuickJSAsyncFFI as ReleaseAsyncifyFFI } from \"./generated/ffi.WASM_RELEASE_ASYNCIFY\"\n//import type { QuickJSFFI as DebugSyncFFI } from \"./generated/ffi.WASM_DEBUG_SYNC\"\nimport type { QuickJSFFI as ReleaseSyncFFI } from \"./generated/ffi.WASM_RELEASE_SYNC\"\nimport type {\n  EmscriptenModuleLoader,\n  QuickJSEmscriptenModule,\n  QuickJSAsyncEmscriptenModule,\n} from \"./emscripten-types\"\nimport type { QuickJSWASMModule } from \"./module\"\nimport type { QuickJSAsyncWASMModule } from \"./module-asyncify\"\nimport { unwrapTypescript, unwrapJavascript } from \"./esmHelpers\"\n\n/** @private */\nexport type QuickJSFFI = ReleaseSyncFFI\n/** @private */\nexport type QuickJSFFIConstructor = typeof ReleaseSyncFFI\n/** @private */\nexport type QuickJSAsyncFFI = any\n/** @private */\nexport type QuickJSAsyncFFIConstructor = any\n\n/**\n * quickjs-emscripten provides multiple build variants of the core WebAssembly\n * module. These variants are each intended for a different use case.\n *\n * To create an instance of the library using a specific build variant, pass the\n * build variant to {@link newQuickJSWASMModule} or {@link newQuickJSAsyncWASMModule}.\n *\n * Synchronous build variants:\n *\n * - {@link RELEASE_SYNC} - This is the default synchronous variant, for general purpose use.\n * - {@link DEBUG_SYNC} - Synchronous build variant for debugging memory leaks.\n */\nexport interface SyncBuildVariant {\n  type: \"sync\"\n  importFFI: () => Promise<QuickJSFFIConstructor>\n  importModuleLoader: () => Promise<EmscriptenModuleLoader<QuickJSEmscriptenModule>>\n}\n\n/**\n * quickjs-emscripten provides multiple build variants of the core WebAssembly\n * module. These variants are each intended for a different use case.\n *\n * To create an instance of the library using a specific build variant, pass the\n * build variant to {@link newQuickJSWASMModule} or {@link newQuickJSAsyncWASMModule}.\n *\n * Asyncified build variants:\n *\n * - {@link RELEASE_ASYNC} - This is the default asyncified build variant, for general purpose use.\n * - {@link DEBUG_ASYNC} - Asyncified build variant with debug logging.\n */\nexport interface AsyncBuildVariant {\n  type: \"async\"\n  importFFI: () => Promise<QuickJSAsyncFFIConstructor>\n  importModuleLoader: () => Promise<EmscriptenModuleLoader<QuickJSAsyncEmscriptenModule>>\n}\n\n/**\n * Create a new, completely isolated WebAssembly module containing the QuickJS library.\n * See the documentation on [[QuickJSWASMModule]].\n *\n * Note that there is a hard limit on the number of WebAssembly modules in older\n * versions of v8:\n * https://bugs.chromium.org/p/v8/issues/detail?id=12076\n */\nexport async function newQuickJSWASMModule(\n  /**\n   * Optionally, pass a {@link SyncBuildVariant} to construct a different WebAssembly module.\n   */\n  variant: SyncBuildVariant = RELEASE_SYNC\n): Promise<QuickJSWASMModule> {\n  const [wasmModuleLoader, QuickJSFFI, { QuickJSWASMModule }] = await Promise.all([\n    variant.importModuleLoader(),\n    variant.importFFI(),\n    import(\"./module.js\").then(unwrapTypescript),\n  ])\n  const wasmModule = await wasmModuleLoader()\n  wasmModule.type = \"sync\"\n  const ffi = new QuickJSFFI(wasmModule)\n  return new QuickJSWASMModule(wasmModule, ffi)\n}\n\n/**\n * Create a new, completely isolated WebAssembly module containing a version of the QuickJS library\n * compiled with Emscripten's [ASYNCIFY](https://emscripten.org/docs/porting/asyncify.html) transform.\n *\n * This version of the library offers features that enable synchronous code\n * inside the VM to interact with asynchronous code in the host environment.\n * See the documentation on [[QuickJSAsyncWASMModule]], [[QuickJSAsyncRuntime]],\n * and [[QuickJSAsyncContext]].\n *\n * Note that there is a hard limit on the number of WebAssembly modules in older\n * versions of v8:\n * https://bugs.chromium.org/p/v8/issues/detail?id=12076\n */\nexport async function newQuickJSAsyncWASMModule(\n  /**\n   * Optionally, pass a {@link AsyncBuildVariant} to construct a different WebAssembly module.\n   */\n  variant: AsyncBuildVariant = RELEASE_ASYNC\n): Promise<QuickJSAsyncWASMModule> {\n  const [wasmModuleLoader, QuickJSAsyncFFI, { QuickJSAsyncWASMModule }] = await Promise.all([\n    variant.importModuleLoader(),\n    variant.importFFI(),\n    import(\"./module-asyncify.js\").then(unwrapTypescript),\n  ])\n  const wasmModule = await wasmModuleLoader()\n  wasmModule.type = \"async\"\n  const ffi = new QuickJSAsyncFFI(wasmModule)\n  return new QuickJSAsyncWASMModule(wasmModule, ffi)\n}\n\n/**\n * Helper intended to memoize the creation of a WebAssembly module.\n * ```typescript\n * const getDebugModule = memoizePromiseFactory(() => newQuickJSWASMModule(DEBUG_SYNC))\n * ```\n */\nexport function memoizePromiseFactory<T>(fn: () => Promise<T>): () => Promise<T> {\n  let promise: Promise<T> | undefined\n  return () => {\n    return (promise ??= fn())\n  }\n}\n\n/**\n * This build variant is compiled with `-fsanitize=leak`. It instruments all\n * memory allocations and when combined with sourcemaps, can present stack trace\n * locations where memory leaks occur.\n *\n * See [[TestQuickJSWASMModule]] which provides access to the leak sanitizer via\n * {@link TestQuickJSWASMModule.assertNoMemoryAllocated}.\n *\n * The downside is that it's 100-1000x slower than the other variants.\n * Suggested use case: automated testing, regression testing, and interactive\n * debugging.\n */\nexport const DEBUG_SYNC: SyncBuildVariant = {\n  type: \"sync\",\n  async importFFI() {\n    throw new Error(\"not implemented\")\n    // const mod = await import(\"./generated/ffi.WASM_DEBUG_SYNC.js\")\n    // return unwrapTypescript(mod).QuickJSFFI\n  },\n  async importModuleLoader() {\n    throw new Error(\"not implemented\")\n    // const mod = await import(\"./generated/emscripten-module.WASM_DEBUG_SYNC.js\")\n    // return unwrapJavascript(mod).default\n  },\n}\n\n/**\n * This is the default (synchronous) build variant.\n * {@link getQuickJS} returns a memoized instance of this build variant.\n */\nexport const RELEASE_SYNC: SyncBuildVariant = {\n  type: \"sync\",\n  async importFFI() {\n    const mod = await import(\"./generated/ffi.WASM_RELEASE_SYNC.js\")\n    return unwrapTypescript(mod).QuickJSFFI\n  },\n  async importModuleLoader() {\n    const mod = await import(\"./generated/emscripten-module.WASM_RELEASE_SYNC.js\")\n    return unwrapJavascript(mod)\n  },\n}\n\n/**\n * The async debug build variant may or may not have the sanitizer enabled.\n * It does print a lot of debug logs.\n *\n * Suggested use case: interactive debugging only.\n */\nexport const DEBUG_ASYNC: AsyncBuildVariant = {\n  type: \"async\",\n  async importFFI() {\n    throw new Error(\"not implemented\")\n    // const mod = await import(\"./generated/ffi.WASM_DEBUG_ASYNCIFY.js\")\n    // return unwrapTypescript(mod).QuickJSAsyncFFI\n  },\n  async importModuleLoader() {\n    throw new Error(\"not implemented\")\n    // const mod = await import(\"./generated/emscripten-module.WASM_DEBUG_ASYNCIFY.js\")\n    // return unwrapJavascript(mod).default\n  },\n}\n\n/**\n * This is the default asyncified build variant.\n */\nexport const RELEASE_ASYNC: AsyncBuildVariant = {\n  type: \"async\",\n  async importFFI() {\n    throw new Error(\"not implemented\")\n    // const mod = await import(\"./generated/ffi.WASM_RELEASE_ASYNCIFY.js\")\n    // return unwrapTypescript(mod).QuickJSAsyncFFI\n  },\n  async importModuleLoader() {\n    throw new Error(\"not implemented\")\n    // const mod = await import(\"./generated/emscripten-module.WASM_RELEASE_ASYNCIFY.js\")\n    // return unwrapJavascript(mod).default\n  },\n}\n"]}

package/backend/node_modules/@tootallnate/quickjs-emscripten/dist/vm-interface.d.ts

@@ -1,68 +0,0 @@
-/**
- * Used as an optional.
- * `{ value: S } | { error: E }`.
- */
-export type SuccessOrFail<S, F> = {
-    value: S;
-    error?: undefined;
-} | {
-    error: F;
-};
-export declare function isSuccess<S, F>(successOrFail: SuccessOrFail<S, F>): successOrFail is {
-    value: S;
-};
-export declare function isFail<S, F>(successOrFail: SuccessOrFail<S, F>): successOrFail is {
-    error: F;
-};
-/**
- * Used as an optional for results of a Vm call.
- * `{ value: VmHandle } | { error: VmHandle }`.
- */
-export type VmCallResult<VmHandle> = SuccessOrFail<VmHandle, VmHandle>;
-/**
- * A VmFunctionImplementation takes handles as arguments.
- * It should return a handle, or be void.
- *
- * To indicate an exception, a VMs can throw either a handle (transferred
- * directly) or any other Javascript value (only the poperties `name` and
- * `message` will be transferred). Or, the VmFunctionImplementation may return
- * a VmCallResult's `{ error: handle }` error variant.
- *
- * VmFunctionImplementation should not free its arguments or its return value.
- * It should not retain a reference to its return value or thrown error.
- */
-export type VmFunctionImplementation<VmHandle> = (this: VmHandle, ...args: VmHandle[]) => VmHandle | VmCallResult<VmHandle> | void;
-/**
- * A minimal interface to a Javascript execution environment.
- *
- * Higher-level tools should build over the LowLevelJavascriptVm interface to
- * share as much as possible between executors.
- *
- * From https://www.figma.com/blog/how-we-built-the-figma-plugin-system/
- */
-export interface LowLevelJavascriptVm<VmHandle> {
-    global: VmHandle;
-    undefined: VmHandle;
-    typeof(handle: VmHandle): string;
-    getNumber(handle: VmHandle): number;
-    getString(handle: VmHandle): string;
-    newNumber(value: number): VmHandle;
-    newString(value: string): VmHandle;
-    newObject(prototype?: VmHandle): VmHandle;
-    newFunction(name: string, value: VmFunctionImplementation<VmHandle>): VmHandle;
-    getProp(handle: VmHandle, key: string | VmHandle): VmHandle;
-    setProp(handle: VmHandle, key: string | VmHandle, value: VmHandle): void;
-    defineProp(handle: VmHandle, key: string | VmHandle, descriptor: VmPropertyDescriptor<VmHandle>): void;
-    callFunction(func: VmHandle, thisVal: VmHandle, ...args: VmHandle[]): VmCallResult<VmHandle>;
-    evalCode(code: string, filename?: string): VmCallResult<VmHandle>;
-}
-/**
- * From https://www.figma.com/blog/how-we-built-the-figma-plugin-system/
- */
-export interface VmPropertyDescriptor<VmHandle> {
-    value?: VmHandle;
-    configurable?: boolean;
-    enumerable?: boolean;
-    get?: (this: VmHandle) => VmHandle;
-    set?: (this: VmHandle, value: VmHandle) => void;
-}

package/backend/node_modules/@tootallnate/quickjs-emscripten/dist/vm-interface.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFail = exports.isSuccess = void 0;
-function isSuccess(successOrFail) {
-    return "error" in successOrFail === false;
-}
-exports.isSuccess = isSuccess;
-function isFail(successOrFail) {
-    return "error" in successOrFail === true;
-}
-exports.isFail = isFail;
-//# sourceMappingURL=vm-interface.js.map

package/backend/node_modules/@tootallnate/quickjs-emscripten/dist/vm-interface.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"vm-interface.js","sourceRoot":"","sources":["../ts/vm-interface.ts"],"names":[],"mappings":";;;AAaA,SAAgB,SAAS,CAAO,aAAkC;IAChE,OAAO,OAAO,IAAI,aAAa,KAAK,KAAK,CAAA;AAC3C,CAAC;AAFD,8BAEC;AAED,SAAgB,MAAM,CAAO,aAAkC;IAC7D,OAAO,OAAO,IAAI,aAAa,KAAK,IAAI,CAAA;AAC1C,CAAC;AAFD,wBAEC","sourcesContent":["/**\n * Used as an optional.\n * `{ value: S } | { error: E }`.\n */\nexport type SuccessOrFail<S, F> =\n  | {\n      value: S\n      error?: undefined\n    }\n  | {\n      error: F\n    }\n\nexport function isSuccess<S, F>(successOrFail: SuccessOrFail<S, F>): successOrFail is { value: S } {\n  return \"error\" in successOrFail === false\n}\n\nexport function isFail<S, F>(successOrFail: SuccessOrFail<S, F>): successOrFail is { error: F } {\n  return \"error\" in successOrFail === true\n}\n\n/**\n * Used as an optional for results of a Vm call.\n * `{ value: VmHandle } | { error: VmHandle }`.\n */\nexport type VmCallResult<VmHandle> = SuccessOrFail<VmHandle, VmHandle>\n\n/**\n * A VmFunctionImplementation takes handles as arguments.\n * It should return a handle, or be void.\n *\n * To indicate an exception, a VMs can throw either a handle (transferred\n * directly) or any other Javascript value (only the poperties `name` and\n * `message` will be transferred). Or, the VmFunctionImplementation may return\n * a VmCallResult's `{ error: handle }` error variant.\n *\n * VmFunctionImplementation should not free its arguments or its return value.\n * It should not retain a reference to its return value or thrown error.\n */\nexport type VmFunctionImplementation<VmHandle> = (\n  this: VmHandle,\n  ...args: VmHandle[]\n) => VmHandle | VmCallResult<VmHandle> | void\n\n/**\n * A minimal interface to a Javascript execution environment.\n *\n * Higher-level tools should build over the LowLevelJavascriptVm interface to\n * share as much as possible between executors.\n *\n * From https://www.figma.com/blog/how-we-built-the-figma-plugin-system/\n */\nexport interface LowLevelJavascriptVm<VmHandle> {\n  global: VmHandle\n  undefined: VmHandle\n\n  typeof(handle: VmHandle): string\n\n  getNumber(handle: VmHandle): number\n  getString(handle: VmHandle): string\n\n  newNumber(value: number): VmHandle\n  newString(value: string): VmHandle\n  newObject(prototype?: VmHandle): VmHandle\n  newFunction(name: string, value: VmFunctionImplementation<VmHandle>): VmHandle\n\n  // For accessing properties of objects\n  getProp(handle: VmHandle, key: string | VmHandle): VmHandle\n  setProp(handle: VmHandle, key: string | VmHandle, value: VmHandle): void\n  defineProp(\n    handle: VmHandle,\n    key: string | VmHandle,\n    descriptor: VmPropertyDescriptor<VmHandle>\n  ): void\n\n  callFunction(func: VmHandle, thisVal: VmHandle, ...args: VmHandle[]): VmCallResult<VmHandle>\n  evalCode(code: string, filename?: string): VmCallResult<VmHandle>\n}\n\n/**\n * From https://www.figma.com/blog/how-we-built-the-figma-plugin-system/\n */\nexport interface VmPropertyDescriptor<VmHandle> {\n  value?: VmHandle\n  configurable?: boolean\n  enumerable?: boolean\n  get?: (this: VmHandle) => VmHandle\n  set?: (this: VmHandle, value: VmHandle) => void\n}\n"]}