Tons of Solutions Engineering work done today for the rest of the CS team! Headway, Howard Hanna, Engels, Brighton, etc. Also completed Datasnippers auth flow and worked on Anthology's script. Cloned Anthology's courses (900..) and will clone Full Story on Monday.

Scripts/node_modules/@tootallnate/quickjs-emscripten/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+quickjs-emscripten copyright (c) 2019 Jake Teton-Landis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Scripts/node_modules/@tootallnate/quickjs-emscripten/README.md

@@ -0,0 +1,597 @@
+# quickjs-emscripten
+
+Javascript/Typescript bindings for QuickJS, a modern Javascript interpreter,
+compiled to WebAssembly.
+
+- Safely evaluate untrusted Javascript (up to ES2020).
+- Create and manipulate values inside the QuickJS runtime ([more][values]).
+- Expose host functions to the QuickJS runtime ([more][functions]).
+- Execute synchronous code that uses asynchronous functions, with [asyncify][asyncify].
+
+[Github] | [NPM] | [API Documentation][api] | [Examples][tests]
+
+```typescript
+import { getQuickJS } from "quickjs-emscripten"
+
+async function main() {
+  const QuickJS = await getQuickJS()
+  const vm = QuickJS.newContext()
+
+  const world = vm.newString("world")
+  vm.setProp(vm.global, "NAME", world)
+  world.dispose()
+
+  const result = vm.evalCode(`"Hello " + NAME + "!"`)
+  if (result.error) {
+    console.log("Execution failed:", vm.dump(result.error))
+    result.error.dispose()
+  } else {
+    console.log("Success:", vm.dump(result.value))
+    result.value.dispose()
+  }
+
+  vm.dispose()
+}
+
+main()
+```
+
+[github]: https://github.com/justjake/quickjs-emscripten
+[npm]: https://www.npmjs.com/package/quickjs-emscripten
+[api]: https://github.com/justjake/quickjs-emscripten/blob/main/doc/modules.md
+[tests]: https://github.com/justjake/quickjs-emscripten/blob/main/ts/quickjs.test.ts
+[values]: #interfacing-with-the-interpreter
+[asyncify]: #asyncify
+[functions]: #exposing-apis
+
+## Usage
+
+Install from `npm`: `npm install --save quickjs-emscripten` or `yarn add quickjs-emscripten`.
+
+The root entrypoint of this library is the `getQuickJS` function, which returns
+a promise that resolves to a [QuickJS singleton](./doc/classes/quickjs.md) when
+the QuickJS WASM module is ready.
+
+Once `getQuickJS` has been awaited at least once, you also can use the `getQuickJSSync`
+function to directly access the singleton engine in your synchronous code.
+
+### Safely evaluate Javascript code
+
+See [QuickJS.evalCode](https://github.com/justjake/quickjs-emscripten/blob/main/doc/classes/quickjs.md#evalcode)
+
+```typescript
+import { getQuickJS, shouldInterruptAfterDeadline } from "quickjs-emscripten"
+
+getQuickJS().then((QuickJS) => {
+  const result = QuickJS.evalCode("1 + 1", {
+    shouldInterrupt: shouldInterruptAfterDeadline(Date.now() + 1000),
+    memoryLimitBytes: 1024 * 1024,
+  })
+  console.log(result)
+})
+```
+
+### Interfacing with the interpreter
+
+You can use [QuickJSContext](https://github.com/justjake/quickjs-emscripten/blob/main/doc/classes/QuickJSContext.md)
+to build a scripting environment by modifying globals and exposing functions
+into the QuickJS interpreter.
+
+Each `QuickJSContext` instance has its own environment -- globals, built-in
+classes -- and actions from one context won't leak into other contexts or
+runtimes (with one exception, see [Asyncify][asyncify]).
+
+Every context is created inside a
+[QuickJSRuntime](https://github.com/justjake/quickjs-emscripten/blob/main/doc/classes/QuickJSRuntime.md).
+A runtime represents a Javascript heap, and you can even share values between
+contexts in the same runtime.
+
+```typescript
+const vm = QuickJS.newContext()
+let state = 0
+
+const fnHandle = vm.newFunction("nextId", () => {
+  return vm.newNumber(++state)
+})
+
+vm.setProp(vm.global, "nextId", fnHandle)
+fnHandle.dispose()
+
+const nextId = vm.unwrapResult(vm.evalCode(`nextId(); nextId(); nextId()`))
+console.log("vm result:", vm.getNumber(nextId), "native state:", state)
+
+nextId.dispose()
+vm.dispose()
+```
+
+When you create a context from a top-level API like in the example above,
+instead of by calling `runtime.newContext()`, a runtime is automatically created
+for the lifetime of the context, and disposed of when you dispose the context.
+
+#### Runtime
+
+The runtime has APIs for CPU and memory limits that apply to all contexts within
+the runtime in aggregate. You can also use the runtime to configure EcmaScript
+module loading.
+
+```typescript
+const runtime = QuickJS.newRuntime()
+// "Should be enough for everyone" -- attributed to B. Gates
+runtime.setMemoryLimit(1024 * 640)
+// Limit stack size
+runtime.setMaxStackSize(1024 * 320)
+// Interrupt computation after 1024 calls to the interrupt handler
+let interruptCycles = 0
+runtime.setInterruptHandler(() => ++interruptCycles > 1024)
+// Toy module system that always returns the module name
+// as the default export
+runtime.setModuleLoader((moduleName) => `export default '${moduleName}'`)
+const context = runtime.newContext()
+const ok = context.evalCode(`
+import fooName from './foo.js'
+globalThis.result = fooName
+`)
+context.unwrapResult(ok).dispose()
+// logs "foo.js"
+console.log(context.getProp(context.global, "result").consume(context.dump))
+context.dispose()
+runtime.dispose()
+```
+
+### Memory Management
+
+Many methods in this library return handles to memory allocated inside the
+WebAssembly heap. These types cannot be garbage-collected as usual in
+Javascript. Instead, you must manually manage their memory by calling a
+`.dispose()` method to free the underlying resources. Once a handle has been
+disposed, it cannot be used anymore. Note that in the example above, we call
+`.dispose()` on each handle once it is no longer needed.
+
+Calling `QuickJSContext.dispose()` will throw a RuntimeError if you've forgotten to
+dispose any handles associated with that VM, so it's good practice to create a
+new VM instance for each of your tests, and to call `vm.dispose()` at the end
+of every test.
+
+```typescript
+const vm = QuickJS.newContext()
+const numberHandle = vm.newNumber(42)
+// Note: numberHandle not disposed, so it leaks memory.
+vm.dispose()
+// throws RuntimeError: abort(Assertion failed: list_empty(&rt->gc_obj_list), at: quickjs/quickjs.c,1963,JS_FreeRuntime)
+```
+
+Here are some strategies to reduce the toil of calling `.dispose()` on each
+handle you create:
+
+#### Scope
+
+A
+[`Scope`](https://github.com/justjake/quickjs-emscripten/blob/main/doc/classes/scope.md#class-scope)
+instance manages a set of disposables and calls their `.dispose()`
+method in the reverse order in which they're added to the scope. Here's the
+"Interfacing with the interpreter" example re-written using `Scope`:
+
+```typescript
+Scope.withScope((scope) => {
+  const vm = scope.manage(QuickJS.newContext())
+  let state = 0
+
+  const fnHandle = scope.manage(
+    vm.newFunction("nextId", () => {
+      return vm.newNumber(++state)
+    })
+  )
+
+  vm.setProp(vm.global, "nextId", fnHandle)
+
+  const nextId = scope.manage(vm.unwrapResult(vm.evalCode(`nextId(); nextId(); nextId()`)))
+  console.log("vm result:", vm.getNumber(nextId), "native state:", state)
+
+  // When the withScope block exits, it calls scope.dispose(), which in turn calls
+  // the .dispose() methods of all the disposables managed by the scope.
+})
+```
+
+You can also create `Scope` instances with `new Scope()` if you want to manage
+calling `scope.dispose()` yourself.
+
+#### `Lifetime.consume(fn)`
+
+[`Lifetime.consume`](https://github.com/justjake/quickjs-emscripten/blob/main/doc/classes/lifetime.md#consume)
+is sugar for the common pattern of using a handle and then
+immediately disposing of it. `Lifetime.consume` takes a `map` function that
+produces a result of any type. The `map` fuction is called with the handle,
+then the handle is disposed, then the result is returned.
+
+Here's the "Interfacing with interpreter" example re-written using `.consume()`:
+
+```typescript
+const vm = QuickJS.newContext()
+let state = 0
+
+vm.newFunction("nextId", () => {
+  return vm.newNumber(++state)
+}).consume((fnHandle) => vm.setProp(vm.global, "nextId", fnHandle))
+
+vm.unwrapResult(vm.evalCode(`nextId(); nextId(); nextId()`)).consume((nextId) =>
+  console.log("vm result:", vm.getNumber(nextId), "native state:", state)
+)
+
+vm.dispose()
+```
+
+Generally working with `Scope` leads to more straight-forward code, but
+`Lifetime.consume` can be handy sugar as part of a method call chain.
+
+### Exposing APIs
+
+To add APIs inside the QuickJS environment, you'll need to create objects to
+define the shape of your API, and add properties and functions to those objects
+to allow code inside QuickJS to call code on the host.
+
+By default, no host functionality is exposed to code running inside QuickJS.
+
+```typescript
+const vm = QuickJS.newContext()
+// `console.log`
+const logHandle = vm.newFunction("log", (...args) => {
+  const nativeArgs = args.map(vm.dump)
+  console.log("QuickJS:", ...nativeArgs)
+})
+// Partially implement `console` object
+const consoleHandle = vm.newObject()
+vm.setProp(consoleHandle, "log", logHandle)
+vm.setProp(vm.global, "console", consoleHandle)
+consoleHandle.dispose()
+logHandle.dispose()
+
+vm.unwrapResult(vm.evalCode(`console.log("Hello from QuickJS!")`)).dispose()
+```
+
+#### Promises
+
+To expose an asynchronous function that _returns a promise_ to callers within
+QuickJS, your function can return the handle of a `QuickJSDeferredPromise`
+created via `context.newPromise()`.
+
+When you resolve a `QuickJSDeferredPromise` -- and generally whenever async
+behavior completes for the VM -- pending listeners inside QuickJS may not
+execute immediately. Your code needs to explicitly call
+`runtime.executePendingJobs()` to resume execution inside QuickJS. This API
+gives your code maximum control to _schedule_ when QuickJS will block the host's
+event loop by resuming execution.
+
+To work with QuickJS handles that contain a promise inside the environment, you
+can convert the QuickJSHandle into a native promise using
+`context.resolvePromise()`. Take care with this API to avoid 'deadlocks' where
+the host awaits a guest promise, but the guest cannot make progress until the
+host calls `runtime.executePendingJobs()`. The simplest way to avoid this kind
+of deadlock is to always schedule `executePendingJobs` after any promise is
+settled.
+
+```typescript
+const vm = QuickJS.newContext()
+const fakeFileSystem = new Map([["example.txt", "Example file content"]])
+
+// Function that simulates reading data asynchronously
+const readFileHandle = vm.newFunction("readFile", (pathHandle) => {
+  const path = vm.getString(pathHandle)
+  const promise = vm.newPromise()
+  setTimeout(() => {
+    const content = fakeFileSystem.get(path)
+    promise.resolve(vm.newString(content || ""))
+  }, 100)
+  // IMPORTANT: Once you resolve an async action inside QuickJS,
+  // call runtime.executePendingJobs() to run any code that was
+  // waiting on the promise or callback.
+  promise.settled.then(vm.runtime.executePendingJobs)
+  return promise.handle
+})
+readFileHandle.consume((handle) => vm.setProp(vm.global, "readFile", handle))
+
+// Evaluate code that uses `readFile`, which returns a promise
+const result = vm.evalCode(`(async () => {
+  const content = await readFile('example.txt')
+  return content.toUpperCase()
+})()`)
+const promiseHandle = vm.unwrapResult(result)
+
+// Convert the promise handle into a native promise and await it.
+// If code like this deadlocks, make sure you are calling
+// runtime.executePendingJobs appropriately.
+const resolvedResult = await vm.resolvePromise(promiseHandle)
+promiseHandle.dispose()
+const resolvedHandle = vm.unwrapResult(resolvedResult)
+console.log("Result:", vm.getString(resolvedHandle))
+resolvedHandle.dispose()
+```
+
+#### Asyncify
+
+Sometimes, we want to create a function that's synchronous from the perspective
+of QuickJS, but prefer to implement that function _asynchronously_ in your host
+code. The most obvious use-case is for EcmaScript module loading. The underlying
+QuickJS C library expects the module loader function to return synchronously,
+but loading data synchronously in the browser or server is somewhere between "a
+bad idea" and "impossible". QuickJS also doesn't expose an API to "pause" the
+execution of a runtime, and adding such an API is tricky due to the VM's
+implementation.
+
+As a work-around, we provide an alternate build of QuickJS processed by
+Emscripten/Binaryen's [ASYNCIFY](https://emscripten.org/docs/porting/asyncify.html)
+compiler transform. Here's how Emscripten's documentation describes Asyncify:
+
+> Asyncify lets synchronous C or C++ code interact with asynchronous \[host] JavaScript. This allows things like:
+>
+> - A synchronous call in C that yields to the event loop, which allows browser events to be handled.
+>
+> - A synchronous call in C that waits for an asynchronous operation in \[host] JS to complete.
+>
+> Asyncify automatically transforms ... code into a form that can be paused and
+> resumed ..., so that it is asynchronous (hence the name “Asyncify”) even though
+> \[it is written] in a normal synchronous way.
+
+This means we can suspend an _entire WebAssembly module_ (which could contain
+multiple runtimes and contexts) while our host Javascript loads data
+asynchronously, and then resume execution once the data load completes. This is
+a very handy superpower, but it comes with a couple of major limitations:
+
+1. _An asyncified WebAssembly module can only suspend to wait for a single
+   asynchronous call at a time_. You may call back into a suspended WebAssembly
+   module eg. to create a QuickJS value to return a result, but the system will
+   crash if this call tries to suspend again. Take a look at Emscripten's documentation
+   on [reentrancy](https://emscripten.org/docs/porting/asyncify.html#reentrancy).
+
+2. _Asyncified code is bigger and runs slower_. The asyncified build of
+   Quickjs-emscripten library is 1M, 2x larger than the 500K of the default
+   version. There may be room for further
+   [optimization](https://emscripten.org/docs/porting/asyncify.html#optimizing)
+   Of our build in the future.
+
+To use asyncify features, use the following functions:
+
+- [newAsyncRuntime][]: create a runtime inside a new WebAssembly module.
+- [newAsyncContext][]: create runtime and context together inside a new
+  WebAssembly module.
+- [newQuickJSAsyncWASMModule][]: create an empty WebAssembly module.
+
+[newasyncruntime]: https://github.com/justjake/quickjs-emscripten/blob/main/doc/modules.md#newasyncruntime
+[newasynccontext]: https://github.com/justjake/quickjs-emscripten/blob/main/doc/modules.md#newasynccontext
+[newquickjsasyncwasmmodule]: https://github.com/justjake/quickjs-emscripten/blob/main/doc/modules.md#newquickjsasyncwasmmodule
+
+These functions are asynchronous because they always create a new underlying
+WebAssembly module so that each instance can suspend and resume independently,
+and instantiating a WebAssembly module is an async operation. This also adds
+substantial overhead compared to creating a runtime or context inside an
+existing module; if you only need to wait for a single async action at a time,
+you can create a single top-level module and create runtimes or contexts inside
+of it.
+
+##### Async module loader
+
+Here's an example of valuating a script that loads React asynchronously as an ES
+module. In our example, we're loading from the filesystem for reproducibility,
+but you can use this technique to load using `fetch`.
+
+```typescript
+const module = await newQuickJSAsyncWASMModule()
+const runtime = module.newRuntime()
+const path = await import("path")
+const { promises: fs } = await import("fs")
+
+const importsPath = path.join(__dirname, "../examples/imports") + "/"
+// Module loaders can return promises.
+// Execution will suspend until the promise resolves.
+runtime.setModuleLoader((moduleName) => {
+  const modulePath = path.join(importsPath, moduleName)
+  if (!modulePath.startsWith(importsPath)) {
+    throw new Error("out of bounds")
+  }
+  console.log("loading", moduleName, "from", modulePath)
+  return fs.readFile(modulePath, "utf-8")
+})
+
+// evalCodeAsync is required when execution may suspend.
+const context = runtime.newContext()
+const result = await context.evalCodeAsync(`
+import * as React from 'esm.sh/react@17'
+import * as ReactDOMServer from 'esm.sh/react-dom@17/server'
+const e = React.createElement
+globalThis.html = ReactDOMServer.renderToStaticMarkup(
+  e('div', null, e('strong', null, 'Hello world!'))
+)
+`)
+context.unwrapResult(result).dispose()
+const html = context.getProp(context.global, "html").consume(context.getString)
+console.log(html) // <div><strong>Hello world!</strong></div>
+```
+
+##### Async on host, sync in QuickJS
+
+Here's an example of turning an async function into a sync function inside the
+VM.
+
+```typescript
+const context = await newAsyncContext()
+const path = await import("path")
+const { promises: fs } = await import("fs")
+
+const importsPath = path.join(__dirname, "../examples/imports") + "/"
+const readFileHandle = context.newAsyncifiedFunction("readFile", async (pathHandle) => {
+  const pathString = path.join(importsPath, context.getString(pathHandle))
+  if (!pathString.startsWith(importsPath)) {
+    throw new Error("out of bounds")
+  }
+  const data = await fs.readFile(pathString, "utf-8")
+  return context.newString(data)
+})
+readFileHandle.consume((fn) => context.setProp(context.global, "readFile", fn))
+
+// evalCodeAsync is required when execution may suspend.
+const result = await context.evalCodeAsync(`
+// Not a promise! Sync! vvvvvvvvvvvvvvvvvvvv 
+const data = JSON.parse(readFile('data.json'))
+data.map(x => x.toUpperCase()).join(' ')
+`)
+const upperCaseData = context.unwrapResult(result).consume(context.getString)
+console.log(upperCaseData) // 'VERY USEFUL DATA'
+```
+
+### Testing your code
+
+This library is complicated to use, so please consider automated testing your
+implementation. We highly writing your test suite to run with both the "release"
+build variant of quickjs-emscripten, and also the [DEBUG_SYNC] build variant.
+The debug sync build variant has extra instrumentation code for detecting memory
+leaks.
+
+The class [TestQuickJSWASMModule] exposes the memory leak detection API, although
+this API is only accurate when using `DEBUG_SYNC` variant.
+
+```typescript
+// Define your test suite in a function, so that you can test against
+// different module loaders.
+function myTests(moduleLoader: () => Promise<QuickJSWASMModule>) {
+  let QuickJS: TestQuickJSWASMModule
+  beforeEach(async () => {
+    // Get a unique TestQuickJSWASMModule instance for each test.
+    const wasmModule = await moduleLoader()
+    QuickJS = new TestQuickJSWASMModule(wasmModule)
+  })
+  afterEach(() => {
+    // Assert that the test disposed all handles. The DEBUG_SYNC build
+    // variant will show detailed traces for each leak.
+    QuickJS.assertNoMemoryAllocated()
+  })
+
+  it("works well", () => {
+    // TODO: write a test using QuickJS
+    const context = QuickJS.newContext()
+    context.unwrapResult(context.evalCode("1 + 1")).dispose()
+    context.dispose()
+  })
+}
+
+// Run the test suite against a matrix of module loaders.
+describe("Check for memory leaks with QuickJS DEBUG build", () => {
+  const moduleLoader = memoizePromiseFactory(() => newQuickJSWASMModule(DEBUG_SYNC))
+  myTests(moduleLoader)
+})
+
+describe("Realistic test with QuickJS RELEASE build", () => {
+  myTests(getQuickJS)
+})
+```
+
+For more testing examples, please explore the typescript source of [quickjs-emscripten][ts] repository.
+
+[ts]: https://github.com/justjake/quickjs-emscripten/blob/main/ts
+[debug_sync]: https://github.com/justjake/quickjs-emscripten/blob/main/doc/modules.md#debug_sync
+[testquickjswasmmodule]: https://github.com/justjake/quickjs-emscripten/blob/main/doc/classes/TestQuickJSWASMModule.md
+
+### Debugging
+
+- Switch to a DEBUG build variant of the WebAssembly module to see debug log messages from the C part of this library.
+- Set `process.env.QTS_DEBUG` to see debug log messages from the Javascript part of this library.
+
+### More Documentation
+
+[Github] | [NPM] | [API Documentation][api] | [Examples][tests]
+
+## Background
+
+This was inspired by seeing https://github.com/maple3142/duktape-eval
+[on Hacker News](https://news.ycombinator.com/item?id=21946565) and Figma's
+blogposts about using building a Javascript plugin runtime:
+
+- [How Figma built the Figma plugin system](https://www.figma.com/blog/how-we-built-the-figma-plugin-system/): Describes the LowLevelJavascriptVm interface.
+- [An update on plugin security](https://www.figma.com/blog/an-update-on-plugin-security/): Figma switches to QuickJS.
+
+## Status & Roadmap
+
+**Stability**: Because the version number of this project is below `1.0.0`,
+\*expect occasional breaking API changes.
+
+**Security**: This project makes every effort to be secure, but has not been
+audited. Please use with care in production settings.
+
+**Roadmap**: I work on this project in my free time, for fun. Here's I'm
+thinking comes next. Last updated 2022-03-18.
+
+1. Further work on module loading APIs:
+
+   - Create modules via Javascript, instead of source text.
+   - Scan source text for imports, for ahead of time or concurrent loading.
+     (This is possible with third-party tools, so lower priority.)
+
+2. Higher-level tools for reading QuickJS values:
+
+   - Type guard functions: `context.isArray(handle)`, `context.isPromise(handle)`, etc.
+   - Iteration utilities: `context.getIterable(handle)`, `context.iterateObjectEntries(handle)`.
+     This better supports user-level code to deserialize complex handle objects.
+
+3. Higher-level tools for creating QuickJS values:
+
+   - Devise a way to avoid needing to mess around with handles when setting up
+     the environment.
+   - Consider integrating
+     [quickjs-emscripten-sync](https://github.com/reearth/quickjs-emscripten-sync)
+     for automatic translation.
+   - Consider class-based or interface-type-based marshalling.
+
+4. EcmaScript Modules / WebAssembly files / Deno support. This requires me to
+   learn a lot of new things, but should be interesting for modern browser usage.
+
+5. SQLite integration.
+
+## Related
+
+- Duktape wrapped in Wasm: https://github.com/maple3142/duktape-eval/blob/main/src/Makefile
+- QuickJS wrapped in C++: https://github.com/ftk/quickjspp
+
+## Developing
+
+This library is implemented in two languages: C (compiled to WASM with
+Emscripten), and Typescript.
+
+### The C parts
+
+The ./c directory contains C code that wraps the QuickJS C library (in ./quickjs).
+Public functions (those starting with `QTS_`) in ./c/interface.c are
+automatically exported to native code (via a generated header) and to
+Typescript (via a generated FFI class). See ./generate.ts for how this works.
+
+The C code builds as both with `emscripten` (using `emcc`), to produce WASM (or
+ASM.js) and with `clang`. Build outputs are checked in, so you can iterate on
+the Javascript parts of the library without setting up the Emscripten toolchain.
+
+Intermediate object files from QuickJS end up in ./build/quickjs/.
+
+This project uses `emscripten 3.1.32`.
+
+- On ARM64, you should install `emscripten` on your machine. For example on macOS, `brew install emscripten`.
+- If _the correct version of emcc_ is not in your PATH, compilation falls back to using Docker.
+  On ARM64, this is 10-50x slower than native compilation, but it's just fine on x64.
+
+Related NPM scripts:
+
+- `yarn update-quickjs` will sync the ./quickjs folder with a
+  github repo tracking the upstream QuickJS.
+- `yarn make-debug` will rebuild C outputs into ./build/wrapper
+- `yarn make-release` will rebuild C outputs in release mode, which is the mode
+  that should be checked into the repo.
+
+### The Typescript parts
+
+The ./ts directory contains Typescript types and wraps the generated Emscripten
+FFI in a more usable interface.
+
+You'll need `node` and `yarn`. Install dependencies with `yarn install`.
+
+- `yarn build` produces ./dist.
+- `yarn test` runs the tests.
+- `yarn test --watch` watches for changes and re-runs the tests.
+
+### Yarn updates
+
+Just run `yarn set version from sources` to upgrade the Yarn release.

Scripts/node_modules/@tootallnate/quickjs-emscripten/c/interface.c

@@ -0,0 +1,819 @@
+/**
+ * interface.c
+ *
+ * We primarily use JSValue* (pointer to JSValue) when communicating with the
+ * host javascript environment, because pointers are trivial to use for calls
+ * into emscripten because they're just a number!
+ *
+ * As with the quickjs.h API, a JSValueConst* value is "borrowed" and should
+ * not be freed. A JSValue* is "owned" and should be freed by the owner.
+ *
+ * Functions starting with "QTS_" are exported by generate.ts to:
+ * - interface.h for native C code.
+ * - ffi.ts for emscripten.
+ *
+ * We support building the following build outputs:
+ *
+ * ## 1. Native machine code
+ * For internal development testing purposes.
+ *
+ * ## 2. WASM via Emscripten
+ * For general production use.
+ *
+ * ## 3. Experimental: Asyncified WASM via Emscripten with -s ASYNCIFY=1.
+ * This variant supports treating async host Javascript calls as synchronous
+ * from the perspective of the WASM c code.
+ *
+ * The way this works is described here:
+ * https://emscripten.org/docs/porting/asyncify.html
+ *
+ * In this variant, any call into our C code could return a promise if it ended
+ * up suspended. We mark the methods we suspect might suspend due to users' code
+ * as returning MaybeAsync(T). This information is ignored for the regular
+ * build.
+ */
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#endif
+
+#include <math.h>  // For NAN
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef QTS_SANITIZE_LEAK
+#include <sanitizer/lsan_interface.h>
+#endif
+
+#include "../quickjs/cutils.h"
+#include "../quickjs/quickjs-libc.h"
+#include "../quickjs/quickjs.h"
+
+#define PKG "quickjs-emscripten: "
+
+#ifdef QTS_DEBUG_MODE
+#define QTS_DEBUG(msg) qts_log(msg);
+#define QTS_DUMP(value) qts_dump(ctx, value);
+#else
+#define QTS_DEBUG(msg) ;
+#define QTS_DUMP(value) ;
+#endif
+
+/**
+ * Signal to our FFI code generator that this string argument should be passed as a pointer
+ * allocated by the caller on the heap, not a JS string on the stack.
+ * https://github.com/emscripten-core/emscripten/issues/6860#issuecomment-405818401
+ */
+#define BorrowedHeapChar const char
+#define OwnedHeapChar char
+#define JSBorrowedChar const char
+
+/**
+ * Signal to our FFI code generator that this function should be called
+ * asynchronously when compiled with ASYNCIFY.
+ */
+#define MaybeAsync(T) T
+
+/**
+ * Signal to our FFI code generator that this function is only available in
+ * ASYNCIFY builds.
+ */
+#define AsyncifyOnly(T) T
+
+#define JSVoid void
+
+#define EvalFlags int
+#define EvalDetectModule int
+
+void qts_log(char *msg) {
+  fputs(PKG, stderr);
+  fputs(msg, stderr);
+  fputs("\n", stderr);
+}
+
+void qts_dump(JSContext *ctx, JSValueConst value) {
+  const char *str = JS_ToCString(ctx, value);
+  if (!str) {
+    QTS_DEBUG("QTS_DUMP: can't dump");
+    return;
+  }
+  fputs(str, stderr);
+  JS_FreeCString(ctx, str);
+  putchar('\n');
+}
+
+void copy_prop_if_needed(JSContext *ctx, JSValueConst dest, JSValueConst src, const char *prop_name) {
+  JSAtom prop_atom = JS_NewAtom(ctx, prop_name);
+  JSValue dest_prop = JS_GetProperty(ctx, dest, prop_atom);
+  if (JS_IsUndefined(dest_prop)) {
+    JSValue src_prop = JS_GetProperty(ctx, src, prop_atom);
+    if (!JS_IsUndefined(src_prop) && !JS_IsException(src_prop)) {
+      JS_SetProperty(ctx, dest, prop_atom, src_prop);
+    }
+  } else {
+    JS_FreeValue(ctx, dest_prop);
+  }
+  JS_FreeAtom(ctx, prop_atom);
+}
+
+JSValue *jsvalue_to_heap(JSValueConst value) {
+  JSValue *result = malloc(sizeof(JSValue));
+  if (result) {
+    // Could be better optimized, but at -0z / -ftlo, it
+    // appears to produce the same binary code as a memcpy.
+    *result = value;
+  }
+  return result;
+}
+
+JSValue *QTS_Throw(JSContext *ctx, JSValueConst *error) {
+  JSValue copy = JS_DupValue(ctx, *error);
+  return jsvalue_to_heap(JS_Throw(ctx, copy));
+}
+
+JSValue *QTS_NewError(JSContext *ctx) {
+  return jsvalue_to_heap(JS_NewError(ctx));
+}
+
+/**
+ * Limits.
+ */
+
+/**
+ * Memory limit. Set to -1 to disable.
+ */
+void QTS_RuntimeSetMemoryLimit(JSRuntime *rt, size_t limit) {
+  JS_SetMemoryLimit(rt, limit);
+}
+
+/**
+ * Memory diagnostics
+ */
+
+JSValue *QTS_RuntimeComputeMemoryUsage(JSRuntime *rt, JSContext *ctx) {
+  JSMemoryUsage s;
+  JS_ComputeMemoryUsage(rt, &s);
+
+  // Note that we're going to allocate more memory just to report the memory usage.
+  // A more sound approach would be to bind JSMemoryUsage struct directly - but that's
+  // a lot of work. This should be okay in the mean time.
+  JSValue result = JS_NewObject(ctx);
+
+  // Manually generated via editor-fu from JSMemoryUsage struct definition in quickjs.h
+  JS_SetPropertyStr(ctx, result, "malloc_limit", JS_NewInt64(ctx, s.malloc_limit));
+  JS_SetPropertyStr(ctx, result, "memory_used_size", JS_NewInt64(ctx, s.memory_used_size));
+  JS_SetPropertyStr(ctx, result, "malloc_count", JS_NewInt64(ctx, s.malloc_count));
+  JS_SetPropertyStr(ctx, result, "memory_used_count", JS_NewInt64(ctx, s.memory_used_count));
+  JS_SetPropertyStr(ctx, result, "atom_count", JS_NewInt64(ctx, s.atom_count));
+  JS_SetPropertyStr(ctx, result, "atom_size", JS_NewInt64(ctx, s.atom_size));
+  JS_SetPropertyStr(ctx, result, "str_count", JS_NewInt64(ctx, s.str_count));
+  JS_SetPropertyStr(ctx, result, "str_size", JS_NewInt64(ctx, s.str_size));
+  JS_SetPropertyStr(ctx, result, "obj_count", JS_NewInt64(ctx, s.obj_count));
+  JS_SetPropertyStr(ctx, result, "obj_size", JS_NewInt64(ctx, s.obj_size));
+  JS_SetPropertyStr(ctx, result, "prop_count", JS_NewInt64(ctx, s.prop_count));
+  JS_SetPropertyStr(ctx, result, "prop_size", JS_NewInt64(ctx, s.prop_size));
+  JS_SetPropertyStr(ctx, result, "shape_count", JS_NewInt64(ctx, s.shape_count));
+  JS_SetPropertyStr(ctx, result, "shape_size", JS_NewInt64(ctx, s.shape_size));
+  JS_SetPropertyStr(ctx, result, "js_func_count", JS_NewInt64(ctx, s.js_func_count));
+  JS_SetPropertyStr(ctx, result, "js_func_size", JS_NewInt64(ctx, s.js_func_size));
+  JS_SetPropertyStr(ctx, result, "js_func_code_size", JS_NewInt64(ctx, s.js_func_code_size));
+  JS_SetPropertyStr(ctx, result, "js_func_pc2line_count", JS_NewInt64(ctx, s.js_func_pc2line_count));
+  JS_SetPropertyStr(ctx, result, "js_func_pc2line_size", JS_NewInt64(ctx, s.js_func_pc2line_size));
+  JS_SetPropertyStr(ctx, result, "c_func_count", JS_NewInt64(ctx, s.c_func_count));
+  JS_SetPropertyStr(ctx, result, "array_count", JS_NewInt64(ctx, s.array_count));
+  JS_SetPropertyStr(ctx, result, "fast_array_count", JS_NewInt64(ctx, s.fast_array_count));
+  JS_SetPropertyStr(ctx, result, "fast_array_elements", JS_NewInt64(ctx, s.fast_array_elements));
+  JS_SetPropertyStr(ctx, result, "binary_object_count", JS_NewInt64(ctx, s.binary_object_count));
+  JS_SetPropertyStr(ctx, result, "binary_object_size", JS_NewInt64(ctx, s.binary_object_size));
+
+  return jsvalue_to_heap(result);
+}
+
+OwnedHeapChar *QTS_RuntimeDumpMemoryUsage(JSRuntime *rt) {
+  char *result = malloc(sizeof(char) * 1024);
+  FILE *memfile = fmemopen(result, 1024, "w");
+  JSMemoryUsage s;
+  JS_ComputeMemoryUsage(rt, &s);
+  JS_DumpMemoryUsage(memfile, &s, rt);
+  fclose(memfile);
+  return result;
+}
+
+int QTS_RecoverableLeakCheck() {
+#ifdef QTS_SANITIZE_LEAK
+  return __lsan_do_recoverable_leak_check();
+#else
+  return 0;
+#endif
+}
+
+int QTS_BuildIsSanitizeLeak() {
+#ifdef QTS_SANITIZE_LEAK
+  return 1;
+#else
+  return 0;
+#endif
+}
+
+#ifdef QTS_ASYNCIFY
+EM_JS(void, set_asyncify_stack_size, (size_t size), {
+  Asyncify.StackSize = size || 81920;
+});
+#endif
+
+/**
+ * Set the stack size limit, in bytes. Set to 0 to disable.
+ */
+void QTS_RuntimeSetMaxStackSize(JSRuntime *rt, size_t stack_size) {
+#ifdef QTS_ASYNCIFY
+  set_asyncify_stack_size(stack_size);
+#endif
+  JS_SetMaxStackSize(rt, stack_size);
+}
+
+/**
+ * Constant pointers. Because we always use JSValue* from the host Javascript environment,
+ * we need helper fuctions to return pointers to these constants.
+ */
+
+JSValueConst QTS_Undefined = JS_UNDEFINED;
+JSValueConst *QTS_GetUndefined() {
+  return &QTS_Undefined;
+}
+
+JSValueConst QTS_Null = JS_NULL;
+JSValueConst *QTS_GetNull() {
+  return &QTS_Null;
+}
+
+JSValueConst QTS_False = JS_FALSE;
+JSValueConst *QTS_GetFalse() {
+  return &QTS_False;
+}
+
+JSValueConst QTS_True = JS_TRUE;
+JSValueConst *QTS_GetTrue() {
+  return &QTS_True;
+}
+
+/**
+ * Standard FFI functions
+ */
+
+JSRuntime *QTS_NewRuntime() {
+  return JS_NewRuntime();
+}
+
+void QTS_FreeRuntime(JSRuntime *rt) {
+  JS_FreeRuntime(rt);
+}
+
+JSContext *QTS_NewContext(JSRuntime *rt) {
+  return JS_NewContext(rt);
+}
+
+void QTS_FreeContext(JSContext *ctx) {
+  JS_FreeContext(ctx);
+}
+
+void QTS_FreeValuePointer(JSContext *ctx, JSValue *value) {
+  JS_FreeValue(ctx, *value);
+  free(value);
+}
+
+void QTS_FreeValuePointerRuntime(JSRuntime *rt, JSValue *value) {
+  JS_FreeValueRT(rt, *value);
+  free(value);
+}
+
+void QTS_FreeVoidPointer(JSContext *ctx, JSVoid *ptr) {
+  js_free(ctx, ptr);
+}
+
+void QTS_FreeCString(JSContext *ctx, JSBorrowedChar *str) {
+  JS_FreeCString(ctx, str);
+}
+
+JSValue *QTS_DupValuePointer(JSContext *ctx, JSValueConst *val) {
+  return jsvalue_to_heap(JS_DupValue(ctx, *val));
+}
+
+JSValue *QTS_NewObject(JSContext *ctx) {
+  return jsvalue_to_heap(JS_NewObject(ctx));
+}
+
+JSValue *QTS_NewObjectProto(JSContext *ctx, JSValueConst *proto) {
+  return jsvalue_to_heap(JS_NewObjectProto(ctx, *proto));
+}
+
+JSValue *QTS_NewArray(JSContext *ctx) {
+  return jsvalue_to_heap(JS_NewArray(ctx));
+}
+
+JSValue *QTS_NewFloat64(JSContext *ctx, double num) {
+  return jsvalue_to_heap(JS_NewFloat64(ctx, num));
+}
+
+double QTS_GetFloat64(JSContext *ctx, JSValueConst *value) {
+  double result = NAN;
+  JS_ToFloat64(ctx, &result, *value);
+  return result;
+}
+
+JSValue *QTS_NewString(JSContext *ctx, BorrowedHeapChar *string) {
+  return jsvalue_to_heap(JS_NewString(ctx, string));
+}
+
+JSBorrowedChar *QTS_GetString(JSContext *ctx, JSValueConst *value) {
+  return JS_ToCString(ctx, *value);
+}
+
+JSValue qts_get_symbol_key(JSContext *ctx, JSValueConst *value) {
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue Symbol = JS_GetPropertyStr(ctx, global, "Symbol");
+  JS_FreeValue(ctx, global);
+
+  JSValue Symbol_keyFor = JS_GetPropertyStr(ctx, Symbol, "keyFor");
+  JSValue key = JS_Call(ctx, Symbol_keyFor, Symbol, 1, value);
+  JS_FreeValue(ctx, Symbol_keyFor);
+  JS_FreeValue(ctx, Symbol);
+  return key;
+}
+
+JSValue *QTS_NewSymbol(JSContext *ctx, BorrowedHeapChar *description, int isGlobal) {
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue Symbol = JS_GetPropertyStr(ctx, global, "Symbol");
+  JS_FreeValue(ctx, global);
+  JSValue descriptionValue = JS_NewString(ctx, description);
+  JSValue symbol;
+
+  if (isGlobal != 0) {
+    JSValue Symbol_for = JS_GetPropertyStr(ctx, Symbol, "for");
+    symbol = JS_Call(ctx, Symbol_for, Symbol, 1, &descriptionValue);
+    JS_FreeValue(ctx, descriptionValue);
+    JS_FreeValue(ctx, Symbol_for);
+    JS_FreeValue(ctx, Symbol);
+    return jsvalue_to_heap(symbol);
+  }
+
+  symbol = JS_Call(ctx, Symbol, JS_UNDEFINED, 1, &descriptionValue);
+  JS_FreeValue(ctx, descriptionValue);
+  JS_FreeValue(ctx, Symbol);
+
+  return jsvalue_to_heap(symbol);
+}
+
+MaybeAsync(JSBorrowedChar *) QTS_GetSymbolDescriptionOrKey(JSContext *ctx, JSValueConst *value) {
+  JSBorrowedChar *result;
+
+  JSValue key = qts_get_symbol_key(ctx, value);
+  if (!JS_IsUndefined(key)) {
+    result = JS_ToCString(ctx, key);
+    JS_FreeValue(ctx, key);
+    return result;
+  }
+
+  JSValue description = JS_GetPropertyStr(ctx, *value, "description");
+  result = JS_ToCString(ctx, description);
+  JS_FreeValue(ctx, description);
+  return result;
+}
+
+int QTS_IsGlobalSymbol(JSContext *ctx, JSValueConst *value) {
+  JSValue key = qts_get_symbol_key(ctx, value);
+  int undefined = JS_IsUndefined(key);
+  JS_FreeValue(ctx, key);
+
+  if (undefined) {
+    return 0;
+  } else {
+    return 1;
+  }
+}
+
+int QTS_IsJobPending(JSRuntime *rt) {
+  return JS_IsJobPending(rt);
+}
+
+/*
+  runs pending jobs (Promises/async functions) until it encounters
+  an exception or it executed the passed maxJobsToExecute jobs.
+
+  Passing a negative value will run the loop until there are no more
+  pending jobs or an exception happened
+
+  Returns the executed number of jobs or the exception encountered
+*/
+MaybeAsync(JSValue *) QTS_ExecutePendingJob(JSRuntime *rt, int maxJobsToExecute, JSContext **lastJobContext) {
+  JSContext *pctx;
+  int status = 1;
+  int executed = 0;
+  while (executed != maxJobsToExecute && status == 1) {
+    status = JS_ExecutePendingJob(rt, &pctx);
+    if (status == -1) {
+      *lastJobContext = pctx;
+      return jsvalue_to_heap(JS_GetException(pctx));
+    } else if (status == 1) {
+      *lastJobContext = pctx;
+      executed++;
+    }
+  }
+#ifdef QTS_DEBUG_MODE
+  char msg[500];
+  sprintf(msg, "QTS_ExecutePendingJob(executed: %d, pctx: %p, lastJobExecuted: %p)", executed, pctx, *lastJobContext);
+  QTS_DEBUG(msg)
+#endif
+  return jsvalue_to_heap(JS_NewFloat64(pctx, executed));
+}
+
+MaybeAsync(JSValue *) QTS_GetProp(JSContext *ctx, JSValueConst *this_val, JSValueConst *prop_name) {
+  JSAtom prop_atom = JS_ValueToAtom(ctx, *prop_name);
+  JSValue prop_val = JS_GetProperty(ctx, *this_val, prop_atom);
+  JS_FreeAtom(ctx, prop_atom);
+  return jsvalue_to_heap(prop_val);
+}
+
+MaybeAsync(void) QTS_SetProp(JSContext *ctx, JSValueConst *this_val, JSValueConst *prop_name, JSValueConst *prop_value) {
+  JSAtom prop_atom = JS_ValueToAtom(ctx, *prop_name);
+  JSValue extra_prop_value = JS_DupValue(ctx, *prop_value);
+  // TODO: should we use DefineProperty internally if this object doesn't have the property yet?
+  JS_SetProperty(ctx, *this_val, prop_atom, extra_prop_value);  // consumes extra_prop_value
+  JS_FreeAtom(ctx, prop_atom);
+}
+
+void QTS_DefineProp(JSContext *ctx, JSValueConst *this_val, JSValueConst *prop_name, JSValueConst *prop_value, JSValueConst *get, JSValueConst *set, bool configurable, bool enumerable, bool has_value) {
+  JSAtom prop_atom = JS_ValueToAtom(ctx, *prop_name);
+
+  int flags = 0;
+  if (configurable) {
+    flags = flags | JS_PROP_CONFIGURABLE;
+    if (has_value) {
+      flags = flags | JS_PROP_HAS_CONFIGURABLE;
+    }
+  }
+  if (enumerable) {
+    flags = flags | JS_PROP_ENUMERABLE;
+    if (has_value) {
+      flags = flags | JS_PROP_HAS_ENUMERABLE;
+    }
+  }
+  if (!JS_IsUndefined(*get)) {
+    flags = flags | JS_PROP_HAS_GET;
+  }
+  if (!JS_IsUndefined(*set)) {
+    flags = flags | JS_PROP_HAS_SET;
+  }
+  if (has_value) {
+    flags = flags | JS_PROP_HAS_VALUE;
+  }
+
+  JS_DefineProperty(ctx, *this_val, prop_atom, *prop_value, *get, *set, flags);
+  JS_FreeAtom(ctx, prop_atom);
+}
+
+MaybeAsync(JSValue *) QTS_Call(JSContext *ctx, JSValueConst *func_obj, JSValueConst *this_obj, int argc, JSValueConst **argv_ptrs) {
+  // convert array of pointers to array of values
+  JSValueConst argv[argc];
+  int i;
+  for (i = 0; i < argc; i++) {
+    argv[i] = *(argv_ptrs[i]);
+  }
+
+  return jsvalue_to_heap(JS_Call(ctx, *func_obj, *this_obj, argc, argv));
+}
+
+/**
+ * If maybe_exception is an exception, get the error.
+ * Otherwise, return NULL.
+ */
+JSValue *QTS_ResolveException(JSContext *ctx, JSValue *maybe_exception) {
+  if (JS_IsException(*maybe_exception)) {
+    return jsvalue_to_heap(JS_GetException(ctx));
+  }
+
+  return NULL;
+}
+
+MaybeAsync(JSBorrowedChar *) QTS_Dump(JSContext *ctx, JSValueConst *obj) {
+  JSValue obj_json_value = JS_JSONStringify(ctx, *obj, JS_UNDEFINED, JS_UNDEFINED);
+  if (!JS_IsException(obj_json_value)) {
+    const char *obj_json_chars = JS_ToCString(ctx, obj_json_value);
+    JS_FreeValue(ctx, obj_json_value);
+    if (obj_json_chars != NULL) {
+      JSValue enumerable_props = JS_ParseJSON(ctx, obj_json_chars, strlen(obj_json_chars), "<dump>");
+      JS_FreeCString(ctx, obj_json_chars);
+      if (!JS_IsException(enumerable_props)) {
+        // Copy common non-enumerable props for different object types.
+        // Errors:
+        copy_prop_if_needed(ctx, enumerable_props, *obj, "name");
+        copy_prop_if_needed(ctx, enumerable_props, *obj, "message");
+        copy_prop_if_needed(ctx, enumerable_props, *obj, "stack");
+
+        // Serialize again.
+        JSValue enumerable_json = JS_JSONStringify(ctx, enumerable_props, JS_UNDEFINED, JS_UNDEFINED);
+        JS_FreeValue(ctx, enumerable_props);
+
+        JSBorrowedChar *result = QTS_GetString(ctx, &enumerable_json);
+        JS_FreeValue(ctx, enumerable_json);
+        return result;
+      }
+    }
+  }
+
+#ifdef QTS_DEBUG_MODE
+  qts_log("Error dumping JSON:");
+  js_std_dump_error(ctx);
+#endif
+
+  // Fallback: convert to string
+  return QTS_GetString(ctx, obj);
+}
+
+MaybeAsync(JSValue *) QTS_Eval(JSContext *ctx, BorrowedHeapChar *js_code, const char *filename, EvalDetectModule detectModule, EvalFlags evalFlags) {
+  size_t js_code_len = strlen(js_code);
+
+  if (detectModule) {
+    if (JS_DetectModule((const char *)js_code, js_code_len)) {
+      QTS_DEBUG("QTS_Eval: Detected module = true");
+      evalFlags |= JS_EVAL_TYPE_MODULE;
+    } else {
+      QTS_DEBUG("QTS_Eval: Detected module = false");
+    }
+  } else {
+    QTS_DEBUG("QTS_Eval: do not detect module");
+  }
+
+  return jsvalue_to_heap(JS_Eval(ctx, js_code, strlen(js_code), filename, evalFlags));
+}
+
+OwnedHeapChar *QTS_Typeof(JSContext *ctx, JSValueConst *value) {
+  const char *result = "unknown";
+  uint32_t tag = JS_VALUE_GET_TAG(*value);
+
+  if (JS_IsNumber(*value)) {
+    result = "number";
+  } else if (JS_IsBigInt(ctx, *value)) {
+    result = "bigint";
+  } else if (JS_IsBigFloat(*value)) {
+    result = "bigfloat";
+  } else if (JS_IsBigDecimal(*value)) {
+    result = "bigdecimal";
+  } else if (JS_IsFunction(ctx, *value)) {
+    result = "function";
+  } else if (JS_IsBool(*value)) {
+    result = "boolean";
+  } else if (JS_IsNull(*value)) {
+    result = "object";
+  } else if (JS_IsUndefined(*value)) {
+    result = "undefined";
+  } else if (JS_IsUninitialized(*value)) {
+    result = "undefined";
+  } else if (JS_IsString(*value)) {
+    result = "string";
+  } else if (JS_IsSymbol(*value)) {
+    result = "symbol";
+  } else if (JS_IsObject(*value)) {
+    result = "object";
+  }
+
+  char *out = strdup(result);
+  return out;
+}
+
+JSValue *QTS_GetGlobalObject(JSContext *ctx) {
+  return jsvalue_to_heap(JS_GetGlobalObject(ctx));
+}
+
+JSValue *QTS_NewPromiseCapability(JSContext *ctx, JSValue **resolve_funcs_out) {
+  JSValue resolve_funcs[2];
+  JSValue promise = JS_NewPromiseCapability(ctx, resolve_funcs);
+  resolve_funcs_out[0] = jsvalue_to_heap(resolve_funcs[0]);
+  resolve_funcs_out[1] = jsvalue_to_heap(resolve_funcs[1]);
+  return jsvalue_to_heap(promise);
+}
+
+void QTS_TestStringArg(const char *string) {
+  // pass
+}
+
+int QTS_BuildIsDebug() {
+#ifdef QTS_DEBUG_MODE
+  return 1;
+#else
+  return 0;
+#endif
+}
+
+int QTS_BuildIsAsyncify() {
+#ifdef QTS_ASYNCIFY
+  return 1;
+#else
+  return 0;
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// Module loading helpers
+
+// ----------------------------------------------------------------------------
+// C -> Host Callbacks
+// Note: inside EM_JS, we need to use ['...'] subscript syntax for accessing JS
+// objects, because in optimized builds, Closure compiler will mangle all the
+// names.
+
+// -------------------
+// function: C -> Host
+#ifdef __EMSCRIPTEN__
+EM_JS(MaybeAsync(JSValue *), qts_host_call_function, (JSContext * ctx, JSValueConst *this_ptr, int argc, JSValueConst *argv, uint32_t magic_func_id), {
+#ifdef QTS_ASYNCIFY
+  const asyncify = {['handleSleep'] : Asyncify.handleSleep};
+#else
+  const asyncify = undefined;
+#endif
+  return Module['callbacks']['callFunction'](asyncify, ctx, this_ptr, argc, argv, magic_func_id);
+});
+#endif
+
+// Function: QuickJS -> C
+JSValue qts_call_function(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) {
+  JSValue *result_ptr = qts_host_call_function(ctx, &this_val, argc, argv, magic);
+  if (result_ptr == NULL) {
+    return JS_UNDEFINED;
+  }
+  JSValue result = *result_ptr;
+  free(result_ptr);
+  return result;
+}
+
+// Function: Host -> QuickJS
+JSValue *QTS_NewFunction(JSContext *ctx, uint32_t func_id, const char *name) {
+#ifdef QTS_DEBUG_MODE
+  char msg[500];
+  sprintf(msg, "new_function(name: %s, magic: %d)", name, func_id);
+  QTS_DEBUG(msg)
+#endif
+  JSValue func_obj = JS_NewCFunctionMagic(
+      /* context */ ctx,
+      /* JSCFunctionMagic* */ &qts_call_function,
+      /* name */ name,
+      /* min argc */ 0,
+      /* function type */ JS_CFUNC_generic_magic,
+      /* magic: fn id */ func_id);
+  return jsvalue_to_heap(func_obj);
+}
+
+JSValueConst *QTS_ArgvGetJSValueConstPointer(JSValueConst *argv, int index) {
+  return &argv[index];
+}
+
+// --------------------
+// interrupt: C -> Host
+#ifdef __EMSCRIPTEN__
+EM_JS(int, qts_host_interrupt_handler, (JSRuntime * rt), {
+  // Async not supported here.
+  // #ifdef QTS_ASYNCIFY
+  //   const asyncify = Asyncify;
+  // #else
+  const asyncify = undefined;
+  // #endif
+  return Module['callbacks']['shouldInterrupt'](asyncify, rt);
+});
+#endif
+
+// interrupt: QuickJS -> C
+int qts_interrupt_handler(JSRuntime *rt, void *_unused) {
+  return qts_host_interrupt_handler(rt);
+}
+
+// interrupt: Host -> QuickJS
+void QTS_RuntimeEnableInterruptHandler(JSRuntime *rt) {
+  JS_SetInterruptHandler(rt, &qts_interrupt_handler, NULL);
+}
+
+void QTS_RuntimeDisableInterruptHandler(JSRuntime *rt) {
+  JS_SetInterruptHandler(rt, NULL, NULL);
+}
+
+// --------------------
+// load module: C -> Host
+// TODO: a future version can support host returning JSModuleDef* directly;
+// for now we only support loading module source code.
+
+/*
+The module loading model under ASYNCIFY is convoluted. We need to make sure we
+never have an async request running concurrently for loading modules.
+
+The first implemenation looked like this:
+
+C                                  HOST                      SUSPENDED
+qts_host_load_module(name) ------>                            false
+                                   call rt.loadModule(name)   false
+                                   Start async load module    false
+                                   Suspend C                  true
+                                   Async load complete        true
+            < ---------------      QTS_CompileModule(source)  true
+QTS_Eval(source, COMPILE_ONLY)                                true
+Loaded module has import                                      true
+qts_host_load_module(dep) ------->                            true
+                                  call rt.loadModule(dep)     true
+                                  Start async load module     true
+                                  ALREADY SUSPENDED, CRASH
+
+We can solve this in two different ways:
+
+1. Return to C as soon as we async load the module source.
+   That way, we unsuspend before calling QTS_CompileModule.
+2. Once we load the module, use a new API to detect and async
+   load the module's downstream dependencies. This way
+   they're loaded synchronously so we don't need to suspend "again".
+
+Probably we could optimize (2) to make it more performant, eg with parallel
+loading, but (1) seems much easier to implement in the sort run.
+*/
+
+JSModuleDef *qts_compile_module(JSContext *ctx, const char *module_name, BorrowedHeapChar *module_body) {
+#ifdef QTS_DEBUG_MODE
+  char msg[500];
+  sprintf(msg, "QTS_CompileModule(ctx: %p, name: %s, bodyLength: %lu)", ctx, module_name, strlen(module_body));
+  QTS_DEBUG(msg)
+#endif
+  JSValue func_val = JS_Eval(ctx, module_body, strlen(module_body), module_name, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+  if (JS_IsException(func_val)) {
+    return NULL;
+  }
+  // TODO: Is exception ok?
+  // TODO: set import.meta?
+  JSModuleDef *module = JS_VALUE_GET_PTR(func_val);
+  JS_FreeValue(ctx, func_val);
+  return module;
+}
+
+#ifdef __EMSCRIPTEN__
+EM_JS(MaybeAsync(char *), qts_host_load_module_source, (JSRuntime * rt, JSContext *ctx, const char *module_name), {
+#ifdef QTS_ASYNCIFY
+  const asyncify = {['handleSleep'] : Asyncify.handleSleep};
+#else
+  const asyncify = undefined;
+#endif
+  // https://emscripten.org/docs/api_reference/preamble.js.html#UTF8ToString
+  const moduleNameString = UTF8ToString(module_name);
+  return Module['callbacks']['loadModuleSource'](asyncify, rt, ctx, moduleNameString);
+});
+
+EM_JS(MaybeAsync(char *), qts_host_normalize_module, (JSRuntime * rt, JSContext *ctx, const char *module_base_name, const char *module_name), {
+#ifdef QTS_ASYNCIFY
+  const asyncify = {['handleSleep'] : Asyncify.handleSleep};
+#else
+  const asyncify = undefined;
+#endif
+  // https://emscripten.org/docs/api_reference/preamble.js.html#UTF8ToString
+  const moduleBaseNameString = UTF8ToString(module_base_name);
+  const moduleNameString = UTF8ToString(module_name);
+  return Module['callbacks']['normalizeModule'](asyncify, rt, ctx, moduleBaseNameString, moduleNameString);
+});
+#endif
+
+// load module: QuickJS -> C
+// See js_module_loader in quickjs/quickjs-libc.c:567
+JSModuleDef *qts_load_module(JSContext *ctx, const char *module_name, void *_unused) {
+  JSRuntime *rt = JS_GetRuntime(ctx);
+#ifdef QTS_DEBUG_MODE
+  char msg[500];
+  sprintf(msg, "qts_load_module(rt: %p, ctx: %p, name: %s)", rt, ctx, module_name);
+  QTS_DEBUG(msg)
+#endif
+  char *module_source = qts_host_load_module_source(rt, ctx, module_name);
+  if (module_source == NULL) {
+    return NULL;
+  }
+
+  JSModuleDef *module = qts_compile_module(ctx, module_name, module_source);
+  free(module_source);
+  return module;
+}
+
+char *qts_normalize_module(JSContext *ctx, const char *module_base_name, const char *module_name, void *_unused) {
+  JSRuntime *rt = JS_GetRuntime(ctx);
+#ifdef QTS_DEBUG_MODE
+  char msg[500];
+  sprintf(msg, "qts_normalize_module(rt: %p, ctx: %p, base_name: %s, name: %s)", rt, ctx, module_base_name, module_name);
+  QTS_DEBUG(msg)
+#endif
+  char *em_module_name = qts_host_normalize_module(rt, ctx, module_base_name, module_name);
+  char *js_module_name = js_strdup(ctx, em_module_name);
+  free(em_module_name);
+  return js_module_name;
+}
+
+// Load module: Host -> QuickJS
+void QTS_RuntimeEnableModuleLoader(JSRuntime *rt, int use_custom_normalize) {
+  JSModuleNormalizeFunc *module_normalize = NULL; /* use default name normalizer */
+  if (use_custom_normalize) {
+    module_normalize = &qts_normalize_module;
+  }
+  JS_SetModuleLoaderFunc(rt, module_normalize, &qts_load_module, NULL);
+}
+
+void QTS_RuntimeDisableModuleLoader(JSRuntime *rt) {
+  JS_SetModuleLoaderFunc(rt, NULL, NULL, NULL);
+}

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

@@ -0,0 +1,24 @@
+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 {};

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

@@ -0,0 +1,53 @@
+"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

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

@@ -0,0 +1 @@
+{"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"]}

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

@@ -0,0 +1,48 @@
+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;
+}

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

@@ -0,0 +1,58 @@
+"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

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

@@ -0,0 +1 @@
+{"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"]}

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

@@ -0,0 +1,371 @@
+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 {};

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/context.js

@@ -0,0 +1,691 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickJSContext = void 0;
+const debug_1 = require("./debug");
+const deferred_promise_1 = require("./deferred-promise");
+const errors_1 = require("./errors");
+const lifetime_1 = require("./lifetime");
+const memory_1 = require("./memory");
+const types_1 = require("./types");
+/**
+ * @private
+ */
+class ContextMemory extends memory_1.ModuleMemory {
+    /** @private */
+    constructor(args) {
+        super(args.module);
+        this.scope = new lifetime_1.Scope();
+        this.copyJSValue = (ptr) => {
+            return this.ffi.QTS_DupValuePointer(this.ctx.value, ptr);
+        };
+        this.freeJSValue = (ptr) => {
+            this.ffi.QTS_FreeValuePointer(this.ctx.value, ptr);
+        };
+        args.ownedLifetimes?.forEach((lifetime) => this.scope.manage(lifetime));
+        this.owner = args.owner;
+        this.module = args.module;
+        this.ffi = args.ffi;
+        this.rt = args.rt;
+        this.ctx = this.scope.manage(args.ctx);
+    }
+    get alive() {
+        return this.scope.alive;
+    }
+    dispose() {
+        return this.scope.dispose();
+    }
+    /**
+     * Track `lifetime` so that it is disposed when this scope is disposed.
+     */
+    manage(lifetime) {
+        return this.scope.manage(lifetime);
+    }
+    consumeJSCharPointer(ptr) {
+        const str = this.module.UTF8ToString(ptr);
+        this.ffi.QTS_FreeCString(this.ctx.value, ptr);
+        return str;
+    }
+    heapValueHandle(ptr) {
+        return new lifetime_1.Lifetime(ptr, this.copyJSValue, this.freeJSValue, this.owner);
+    }
+}
+/**
+ * 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.
+ *
+ */
+// TODO: Manage own callback registration
+class QuickJSContext {
+    /**
+     * Use {@link QuickJS.createVm} to create a QuickJSContext instance.
+     */
+    constructor(args) {
+        /** @private */
+        this._undefined = undefined;
+        /** @private */
+        this._null = undefined;
+        /** @private */
+        this._false = undefined;
+        /** @private */
+        this._true = undefined;
+        /** @private */
+        this._global = undefined;
+        /** @private */
+        this._BigInt = undefined;
+        /** @private */
+        this.fnNextId = -32768; // min value of signed 16bit int used by Quickjs
+        /** @private */
+        this.fnMaps = new Map();
+        /**
+         * @hidden
+         */
+        this.cToHostCallbacks = {
+            callFunction: (ctx, this_ptr, argc, argv, fn_id) => {
+                if (ctx !== this.ctx.value) {
+                    throw new Error("QuickJSContext instance received C -> JS call with mismatched ctx");
+                }
+                const fn = this.getFunction(fn_id);
+                if (!fn) {
+                    // this "throw" is not catch-able from the TS side. could we somehow handle this higher up?
+                    throw new Error(`QuickJSContext had no callback with id ${fn_id}`);
+                }
+                return lifetime_1.Scope.withScopeMaybeAsync(this, function* (awaited, scope) {
+                    const thisHandle = scope.manage(new lifetime_1.WeakLifetime(this_ptr, this.memory.copyJSValue, this.memory.freeJSValue, this.runtime));
+                    const argHandles = new Array(argc);
+                    for (let i = 0; i < argc; i++) {
+                        const ptr = this.ffi.QTS_ArgvGetJSValueConstPointer(argv, i);
+                        argHandles[i] = scope.manage(new lifetime_1.WeakLifetime(ptr, this.memory.copyJSValue, this.memory.freeJSValue, this.runtime));
+                    }
+                    try {
+                        const result = yield* awaited(fn.apply(thisHandle, argHandles));
+                        if (result) {
+                            if ("error" in result && result.error) {
+                                (0, debug_1.debugLog)("throw error", result.error);
+                                throw result.error;
+                            }
+                            const handle = scope.manage(result instanceof lifetime_1.Lifetime ? result : result.value);
+                            return this.ffi.QTS_DupValuePointer(this.ctx.value, handle.value);
+                        }
+                        return 0;
+                    }
+                    catch (error) {
+                        return this.errorToHandle(error).consume((errorHandle) => this.ffi.QTS_Throw(this.ctx.value, errorHandle.value));
+                    }
+                });
+            },
+        };
+        this.runtime = args.runtime;
+        this.module = args.module;
+        this.ffi = args.ffi;
+        this.rt = args.rt;
+        this.ctx = args.ctx;
+        this.memory = new ContextMemory({
+            ...args,
+            owner: this.runtime,
+        });
+        args.callbacks.setContextCallbacks(this.ctx.value, this.cToHostCallbacks);
+        this.dump = this.dump.bind(this);
+        this.getString = this.getString.bind(this);
+        this.getNumber = this.getNumber.bind(this);
+        this.resolvePromise = this.resolvePromise.bind(this);
+    }
+    // @implement Disposable ----------------------------------------------------
+    get alive() {
+        return this.memory.alive;
+    }
+    /**
+     * Dispose of this VM's underlying resources.
+     *
+     * @throws Calling this method without disposing of all created handles
+     * will result in an error.
+     */
+    dispose() {
+        this.memory.dispose();
+    }
+    // Globals ------------------------------------------------------------------
+    /**
+     * [`undefined`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined).
+     */
+    get undefined() {
+        if (this._undefined) {
+            return this._undefined;
+        }
+        // Undefined is a constant, immutable value in QuickJS.
+        const ptr = this.ffi.QTS_GetUndefined();
+        return (this._undefined = new lifetime_1.StaticLifetime(ptr));
+    }
+    /**
+     * [`null`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null).
+     */
+    get null() {
+        if (this._null) {
+            return this._null;
+        }
+        // Null is a constant, immutable value in QuickJS.
+        const ptr = this.ffi.QTS_GetNull();
+        return (this._null = new lifetime_1.StaticLifetime(ptr));
+    }
+    /**
+     * [`true`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/true).
+     */
+    get true() {
+        if (this._true) {
+            return this._true;
+        }
+        // True is a constant, immutable value in QuickJS.
+        const ptr = this.ffi.QTS_GetTrue();
+        return (this._true = new lifetime_1.StaticLifetime(ptr));
+    }
+    /**
+     * [`false`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/false).
+     */
+    get false() {
+        if (this._false) {
+            return this._false;
+        }
+        // False is a constant, immutable value in QuickJS.
+        const ptr = this.ffi.QTS_GetFalse();
+        return (this._false = new lifetime_1.StaticLifetime(ptr));
+    }
+    /**
+     * [`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() {
+        if (this._global) {
+            return this._global;
+        }
+        // The global is a JSValue, but since it's lifetime is as long as the VM's,
+        // we should manage it.
+        const ptr = this.ffi.QTS_GetGlobalObject(this.ctx.value);
+        // Automatically clean up this reference when we dispose
+        this.memory.manage(this.memory.heapValueHandle(ptr));
+        // This isn't technically a static lifetime, but since it has the same
+        // lifetime as the VM, it's okay to fake one since when the VM is
+        // disposed, no other functions will accept the value.
+        this._global = new lifetime_1.StaticLifetime(ptr, this.runtime);
+        return this._global;
+    }
+    // New values ---------------------------------------------------------------
+    /**
+     * Converts a Javascript number into a QuickJS value.
+     */
+    newNumber(num) {
+        return this.memory.heapValueHandle(this.ffi.QTS_NewFloat64(this.ctx.value, num));
+    }
+    /**
+     * Create a QuickJS [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String) value.
+     */
+    newString(str) {
+        const ptr = this.memory
+            .newHeapCharPointer(str)
+            .consume((charHandle) => this.ffi.QTS_NewString(this.ctx.value, charHandle.value));
+        return this.memory.heapValueHandle(ptr);
+    }
+    /**
+     * 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) {
+        const key = (typeof description === "symbol" ? description.description : description) ?? "";
+        const ptr = this.memory
+            .newHeapCharPointer(key)
+            .consume((charHandle) => this.ffi.QTS_NewSymbol(this.ctx.value, charHandle.value, 0));
+        return this.memory.heapValueHandle(ptr);
+    }
+    /**
+     * 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) {
+        const description = (typeof key === "symbol" ? key.description : key) ?? "";
+        const ptr = this.memory
+            .newHeapCharPointer(description)
+            .consume((charHandle) => this.ffi.QTS_NewSymbol(this.ctx.value, charHandle.value, 1));
+        return this.memory.heapValueHandle(ptr);
+    }
+    /**
+     * Create a QuickJS [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) value.
+     */
+    newBigInt(num) {
+        if (!this._BigInt) {
+            const bigIntHandle = this.getProp(this.global, "BigInt");
+            this.memory.manage(bigIntHandle);
+            this._BigInt = new lifetime_1.StaticLifetime(bigIntHandle.value, this.runtime);
+        }
+        const bigIntHandle = this._BigInt;
+        const asString = String(num);
+        return this.newString(asString).consume((handle) => this.unwrapResult(this.callFunction(bigIntHandle, this.undefined, handle)));
+    }
+    /**
+     * `{}`.
+     * 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) {
+        if (prototype) {
+            this.runtime.assertOwned(prototype);
+        }
+        const ptr = prototype
+            ? this.ffi.QTS_NewObjectProto(this.ctx.value, prototype.value)
+            : this.ffi.QTS_NewObject(this.ctx.value);
+        return this.memory.heapValueHandle(ptr);
+    }
+    /**
+     * `[]`.
+     * Create a new QuickJS [array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array).
+     */
+    newArray() {
+        const ptr = this.ffi.QTS_NewArray(this.ctx.value);
+        return this.memory.heapValueHandle(ptr);
+    }
+    newPromise(value) {
+        const deferredPromise = lifetime_1.Scope.withScope((scope) => {
+            const mutablePointerArray = scope.manage(this.memory.newMutablePointerArray(2));
+            const promisePtr = this.ffi.QTS_NewPromiseCapability(this.ctx.value, mutablePointerArray.value.ptr);
+            const promiseHandle = this.memory.heapValueHandle(promisePtr);
+            const [resolveHandle, rejectHandle] = Array.from(mutablePointerArray.value.typedArray).map((jsvaluePtr) => this.memory.heapValueHandle(jsvaluePtr));
+            return new deferred_promise_1.QuickJSDeferredPromise({
+                context: this,
+                promiseHandle,
+                resolveHandle,
+                rejectHandle,
+            });
+        });
+        if (value && typeof value === "function") {
+            value = new Promise(value);
+        }
+        if (value) {
+            Promise.resolve(value).then(deferredPromise.resolve, (error) => error instanceof lifetime_1.Lifetime
+                ? deferredPromise.reject(error)
+                : this.newError(error).consume(deferredPromise.reject));
+        }
+        return deferredPromise;
+    }
+    /**
+     * 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, fn) {
+        const fnId = ++this.fnNextId;
+        this.setFunction(fnId, fn);
+        return this.memory.heapValueHandle(this.ffi.QTS_NewFunction(this.ctx.value, fnId, name));
+    }
+    newError(error) {
+        const errorHandle = this.memory.heapValueHandle(this.ffi.QTS_NewError(this.ctx.value));
+        if (error && typeof error === "object") {
+            if (error.name !== undefined) {
+                this.newString(error.name).consume((handle) => this.setProp(errorHandle, "name", handle));
+            }
+            if (error.message !== undefined) {
+                this.newString(error.message).consume((handle) => this.setProp(errorHandle, "message", handle));
+            }
+        }
+        else if (typeof error === "string") {
+            this.newString(error).consume((handle) => this.setProp(errorHandle, "message", handle));
+        }
+        else if (error !== undefined) {
+            // This isn't supported in the type signature but maybe it will make life easier.
+            this.newString(String(error)).consume((handle) => this.setProp(errorHandle, "message", handle));
+        }
+        return errorHandle;
+    }
+    // Read values --------------------------------------------------------------
+    /**
+     * `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) {
+        this.runtime.assertOwned(handle);
+        return this.memory.consumeHeapCharPointer(this.ffi.QTS_Typeof(this.ctx.value, handle.value));
+    }
+    /**
+     * Converts `handle` into a Javascript number.
+     * @returns `NaN` on error, otherwise a `number`.
+     */
+    getNumber(handle) {
+        this.runtime.assertOwned(handle);
+        return this.ffi.QTS_GetFloat64(this.ctx.value, handle.value);
+    }
+    /**
+     * Converts `handle` to a Javascript string.
+     */
+    getString(handle) {
+        this.runtime.assertOwned(handle);
+        return this.memory.consumeJSCharPointer(this.ffi.QTS_GetString(this.ctx.value, handle.value));
+    }
+    /**
+     * 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) {
+        this.runtime.assertOwned(handle);
+        const key = this.memory.consumeJSCharPointer(this.ffi.QTS_GetSymbolDescriptionOrKey(this.ctx.value, handle.value));
+        const isGlobal = this.ffi.QTS_IsGlobalSymbol(this.ctx.value, handle.value);
+        return isGlobal ? Symbol.for(key) : Symbol(key);
+    }
+    /**
+     * Converts `handle` to a Javascript bigint.
+     */
+    getBigInt(handle) {
+        this.runtime.assertOwned(handle);
+        const asString = this.getString(handle);
+        return BigInt(asString);
+    }
+    /**
+     * `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) {
+        this.runtime.assertOwned(promiseLikeHandle);
+        const vmResolveResult = lifetime_1.Scope.withScope((scope) => {
+            const vmPromise = scope.manage(this.getProp(this.global, "Promise"));
+            const vmPromiseResolve = scope.manage(this.getProp(vmPromise, "resolve"));
+            return this.callFunction(vmPromiseResolve, vmPromise, promiseLikeHandle);
+        });
+        if (vmResolveResult.error) {
+            return Promise.resolve(vmResolveResult);
+        }
+        return new Promise((resolve) => {
+            lifetime_1.Scope.withScope((scope) => {
+                const resolveHandle = scope.manage(this.newFunction("resolve", (value) => {
+                    resolve({ value: value && value.dup() });
+                }));
+                const rejectHandle = scope.manage(this.newFunction("reject", (error) => {
+                    resolve({ error: error && error.dup() });
+                }));
+                const promiseHandle = scope.manage(vmResolveResult.value);
+                const promiseThenHandle = scope.manage(this.getProp(promiseHandle, "then"));
+                this.unwrapResult(this.callFunction(promiseThenHandle, promiseHandle, resolveHandle, rejectHandle)).dispose();
+            });
+        });
+    }
+    // Properties ---------------------------------------------------------------
+    /**
+     * `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, key) {
+        this.runtime.assertOwned(handle);
+        const ptr = this.borrowPropertyKey(key).consume((quickJSKey) => this.ffi.QTS_GetProp(this.ctx.value, handle.value, quickJSKey.value));
+        const result = this.memory.heapValueHandle(ptr);
+        return result;
+    }
+    /**
+     * `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, key, value) {
+        this.runtime.assertOwned(handle);
+        // free newly allocated value if key was a string or number. No-op if string was already
+        // a QuickJS handle.
+        this.borrowPropertyKey(key).consume((quickJSKey) => this.ffi.QTS_SetProp(this.ctx.value, handle.value, quickJSKey.value, value.value));
+    }
+    /**
+     * [`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, key, descriptor) {
+        this.runtime.assertOwned(handle);
+        lifetime_1.Scope.withScope((scope) => {
+            const quickJSKey = scope.manage(this.borrowPropertyKey(key));
+            const value = descriptor.value || this.undefined;
+            const configurable = Boolean(descriptor.configurable);
+            const enumerable = Boolean(descriptor.enumerable);
+            const hasValue = Boolean(descriptor.value);
+            const get = descriptor.get
+                ? scope.manage(this.newFunction(descriptor.get.name, descriptor.get))
+                : this.undefined;
+            const set = descriptor.set
+                ? scope.manage(this.newFunction(descriptor.set.name, descriptor.set))
+                : this.undefined;
+            this.ffi.QTS_DefineProp(this.ctx.value, handle.value, quickJSKey.value, value.value, get.value, set.value, configurable, enumerable, hasValue);
+        });
+    }
+    // Evaluation ---------------------------------------------------------------
+    /**
+     * [`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, thisVal, ...args) {
+        this.runtime.assertOwned(func);
+        const resultPtr = this.memory
+            .toPointerArray(args)
+            .consume((argsArrayPtr) => this.ffi.QTS_Call(this.ctx.value, func.value, thisVal.value, args.length, argsArrayPtr.value));
+        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) };
+    }
+    /**
+     * 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, filename = "eval.js", 
+    /**
+     * If no options are passed, a heuristic will be used to detect if `code` is
+     * an ES module.
+     *
+     * See [[EvalFlags]] for number semantics.
+     */
+    options) {
+        const detectModule = (options === undefined ? 1 : 0);
+        const flags = (0, types_1.evalOptionsToFlags)(options);
+        const resultPtr = this.memory
+            .newHeapCharPointer(code)
+            .consume((charHandle) => this.ffi.QTS_Eval(this.ctx.value, charHandle.value, filename, detectModule, flags));
+        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) };
+    }
+    /**
+     * Throw an error in the VM, interrupted whatever current execution is in progress when execution resumes.
+     * @experimental
+     */
+    throw(error) {
+        return this.errorToHandle(error).consume((handle) => this.ffi.QTS_Throw(this.ctx.value, handle.value));
+    }
+    /**
+     * @private
+     */
+    borrowPropertyKey(key) {
+        if (typeof key === "number") {
+            return this.newNumber(key);
+        }
+        if (typeof key === "string") {
+            return this.newString(key);
+        }
+        // key is already a JSValue, but we're borrowing it. Return a static handle
+        // for internal use only.
+        return new lifetime_1.StaticLifetime(key.value, this.runtime);
+    }
+    /**
+     * @private
+     */
+    getMemory(rt) {
+        if (rt === this.rt.value) {
+            return this.memory;
+        }
+        else {
+            throw new Error("Private API. Cannot get memory from a different runtime");
+        }
+    }
+    // Utilities ----------------------------------------------------------------
+    /**
+     * Dump a JSValue to Javascript in a best-effort fashion.
+     * Returns `handle.toString()` if it cannot be serialized to JSON.
+     */
+    dump(handle) {
+        this.runtime.assertOwned(handle);
+        const type = this.typeof(handle);
+        if (type === "string") {
+            return this.getString(handle);
+        }
+        else if (type === "number") {
+            return this.getNumber(handle);
+        }
+        else if (type === "bigint") {
+            return this.getBigInt(handle);
+        }
+        else if (type === "undefined") {
+            return undefined;
+        }
+        else if (type === "symbol") {
+            return this.getSymbol(handle);
+        }
+        const str = this.memory.consumeJSCharPointer(this.ffi.QTS_Dump(this.ctx.value, handle.value));
+        try {
+            return JSON.parse(str);
+        }
+        catch (err) {
+            return str;
+        }
+    }
+    /**
+     * 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(result) {
+        if (result.error) {
+            const context = "context" in result.error ? result.error.context : this;
+            const cause = result.error.consume((error) => this.dump(error));
+            if (cause && typeof cause === "object" && typeof cause.message === "string") {
+                const { message, name, stack } = cause;
+                const exception = new errors_1.QuickJSUnwrapError("");
+                const hostStack = exception.stack;
+                if (typeof name === "string") {
+                    exception.name = cause.name;
+                }
+                if (typeof stack === "string") {
+                    exception.stack = `${name}: ${message}\n${cause.stack}Host: ${hostStack}`;
+                }
+                Object.assign(exception, { cause, context, message });
+                throw exception;
+            }
+            throw new errors_1.QuickJSUnwrapError(cause, context);
+        }
+        return result.value;
+    }
+    /** @private */
+    getFunction(fn_id) {
+        const map_id = fn_id >> 8;
+        const fnMap = this.fnMaps.get(map_id);
+        if (!fnMap) {
+            return undefined;
+        }
+        return fnMap.get(fn_id);
+    }
+    /** @private */
+    setFunction(fn_id, handle) {
+        const map_id = fn_id >> 8;
+        let fnMap = this.fnMaps.get(map_id);
+        if (!fnMap) {
+            fnMap = new Map();
+            this.fnMaps.set(map_id, fnMap);
+        }
+        return fnMap.set(fn_id, handle);
+    }
+    errorToHandle(error) {
+        if (error instanceof lifetime_1.Lifetime) {
+            return error;
+        }
+        return this.newError(error);
+    }
+}
+exports.QuickJSContext = QuickJSContext;
+//# sourceMappingURL=context.js.map

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/debug.d.ts

@@ -0,0 +1,5 @@
+export declare const QTS_DEBUG: boolean;
+export declare let debugLog: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+};

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/debug.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLog = exports.QTS_DEBUG = void 0;
+exports.QTS_DEBUG = false || Boolean(typeof process === "object" && process.env.QTS_DEBUG);
+exports.debugLog = exports.QTS_DEBUG ? console.log.bind(console) : () => { };
+//# sourceMappingURL=debug.js.map

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.js","sourceRoot":"","sources":["../ts/debug.ts"],"names":[],"mappings":";;;AAAa,QAAA,SAAS,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;AACpF,QAAA,QAAQ,GAAG,iBAAS,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,GAAE,CAAC,CAAA","sourcesContent":["export const QTS_DEBUG = false || Boolean(typeof process === \"object\" && process.env.QTS_DEBUG)\nexport let debugLog = QTS_DEBUG ? console.log.bind(console) : () => {}\n"]}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/deferred-promise.d.ts

@@ -0,0 +1,75 @@
+import type { Disposable } from "./lifetime";
+import type { QuickJSHandle } from "./types";
+import type { QuickJSRuntime } from "./runtime";
+import type { QuickJSContext } from "./context";
+export type { PromiseExecutor } from "./types";
+/**
+ * QuickJSDeferredPromise wraps a QuickJS promise [[handle]] and allows
+ * [[resolve]]ing or [[reject]]ing that promise. Use it to bridge asynchronous
+ * code on the host to APIs inside a QuickJSContext.
+ *
+ * Managing the lifetime of promises is tricky. There are three
+ * [[QuickJSHandle]]s inside of each deferred promise object: (1) the promise
+ * itself, (2) the `resolve` callback, and (3) the `reject` callback.
+ *
+ * - If the promise will be fulfilled before the end of it's [[owner]]'s lifetime,
+ *   the only cleanup necessary is `deferred.handle.dispose()`, because
+ *   calling [[resolve]] or [[reject]] will dispose of both callbacks automatically.
+ *
+ * - As the return value of a [[VmFunctionImplementation]], return [[handle]],
+ *   and ensure that either [[resolve]] or [[reject]] will be called. No other
+ *   clean-up is necessary.
+ *
+ * - In other cases, call [[dispose]], which will dispose [[handle]] as well as the
+ *   QuickJS handles that back [[resolve]] and [[reject]]. For this object,
+ *   [[dispose]] is idempotent.
+ */
+export declare class QuickJSDeferredPromise implements Disposable {
+    owner: QuickJSRuntime;
+    context: QuickJSContext;
+    /**
+     * A handle of the Promise instance inside the QuickJSContext.
+     * You must dispose [[handle]] or the entire QuickJSDeferredPromise once you
+     * are finished with it.
+     */
+    handle: QuickJSHandle;
+    /**
+     * A native promise that will resolve once this deferred is settled.
+     */
+    settled: Promise<void>;
+    private resolveHandle;
+    private rejectHandle;
+    private onSettled;
+    /**
+     * Use [[QuickJSContext.newPromise]] to create a new promise instead of calling
+     * this constructor directly.
+     * @unstable
+     */
+    constructor(args: {
+        context: QuickJSContext;
+        promiseHandle: QuickJSHandle;
+        resolveHandle: QuickJSHandle;
+        rejectHandle: QuickJSHandle;
+    });
+    /**
+     * Resolve [[handle]] with the given value, if any.
+     * Calling this method after calling [[dispose]] is a no-op.
+     *
+     * Note that after resolving a promise, you may need to call
+     * [[QuickJSContext.executePendingJobs]] to propagate the result to the promise's
+     * callbacks.
+     */
+    resolve: (value?: QuickJSHandle) => void;
+    /**
+     * Reject [[handle]] with the given value, if any.
+     * Calling this method after calling [[dispose]] is a no-op.
+     *
+     * Note that after rejecting a promise, you may need to call
+     * [[QuickJSContext.executePendingJobs]] to propagate the result to the promise's
+     * callbacks.
+     */
+    reject: (value?: QuickJSHandle) => void;
+    get alive(): boolean;
+    dispose: () => void;
+    private disposeResolvers;
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/deferred-promise.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickJSDeferredPromise = void 0;
+/**
+ * QuickJSDeferredPromise wraps a QuickJS promise [[handle]] and allows
+ * [[resolve]]ing or [[reject]]ing that promise. Use it to bridge asynchronous
+ * code on the host to APIs inside a QuickJSContext.
+ *
+ * Managing the lifetime of promises is tricky. There are three
+ * [[QuickJSHandle]]s inside of each deferred promise object: (1) the promise
+ * itself, (2) the `resolve` callback, and (3) the `reject` callback.
+ *
+ * - If the promise will be fulfilled before the end of it's [[owner]]'s lifetime,
+ *   the only cleanup necessary is `deferred.handle.dispose()`, because
+ *   calling [[resolve]] or [[reject]] will dispose of both callbacks automatically.
+ *
+ * - As the return value of a [[VmFunctionImplementation]], return [[handle]],
+ *   and ensure that either [[resolve]] or [[reject]] will be called. No other
+ *   clean-up is necessary.
+ *
+ * - In other cases, call [[dispose]], which will dispose [[handle]] as well as the
+ *   QuickJS handles that back [[resolve]] and [[reject]]. For this object,
+ *   [[dispose]] is idempotent.
+ */
+class QuickJSDeferredPromise {
+    /**
+     * Use [[QuickJSContext.newPromise]] to create a new promise instead of calling
+     * this constructor directly.
+     * @unstable
+     */
+    constructor(args) {
+        /**
+         * Resolve [[handle]] with the given value, if any.
+         * Calling this method after calling [[dispose]] is a no-op.
+         *
+         * Note that after resolving a promise, you may need to call
+         * [[QuickJSContext.executePendingJobs]] to propagate the result to the promise's
+         * callbacks.
+         */
+        this.resolve = (value) => {
+            if (!this.resolveHandle.alive) {
+                return;
+            }
+            this.context
+                .unwrapResult(this.context.callFunction(this.resolveHandle, this.context.undefined, value || this.context.undefined))
+                .dispose();
+            this.disposeResolvers();
+            this.onSettled();
+        };
+        /**
+         * Reject [[handle]] with the given value, if any.
+         * Calling this method after calling [[dispose]] is a no-op.
+         *
+         * Note that after rejecting a promise, you may need to call
+         * [[QuickJSContext.executePendingJobs]] to propagate the result to the promise's
+         * callbacks.
+         */
+        this.reject = (value) => {
+            if (!this.rejectHandle.alive) {
+                return;
+            }
+            this.context
+                .unwrapResult(this.context.callFunction(this.rejectHandle, this.context.undefined, value || this.context.undefined))
+                .dispose();
+            this.disposeResolvers();
+            this.onSettled();
+        };
+        this.dispose = () => {
+            if (this.handle.alive) {
+                this.handle.dispose();
+            }
+            this.disposeResolvers();
+        };
+        this.context = args.context;
+        this.owner = args.context.runtime;
+        this.handle = args.promiseHandle;
+        this.settled = new Promise((resolve) => {
+            this.onSettled = resolve;
+        });
+        this.resolveHandle = args.resolveHandle;
+        this.rejectHandle = args.rejectHandle;
+    }
+    get alive() {
+        return this.handle.alive || this.resolveHandle.alive || this.rejectHandle.alive;
+    }
+    disposeResolvers() {
+        if (this.resolveHandle.alive) {
+            this.resolveHandle.dispose();
+        }
+        if (this.rejectHandle.alive) {
+            this.rejectHandle.dispose();
+        }
+    }
+}
+exports.QuickJSDeferredPromise = QuickJSDeferredPromise;
+//# sourceMappingURL=deferred-promise.js.map

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

@@ -0,0 +1,97 @@
+import { BorrowedHeapCharPointer, JSContextPointer, JSRuntimePointer, JSValueConstPointer, JSValuePointer, OwnedHeapCharPointer } from "./types-ffi";
+declare namespace Emscripten {
+    interface FileSystemType {
+    }
+    type EnvironmentType = "WEB" | "NODE" | "SHELL" | "WORKER";
+    type ValueType = "number" | "string" | "array" | "boolean";
+    type TypeCompatibleWithC = number | string | any[] | boolean;
+    type WebAssemblyImports = Array<{
+        name: string;
+        kind: string;
+    }>;
+    type WebAssemblyExports = Array<{
+        module: string;
+        name: string;
+        kind: string;
+    }>;
+    interface CCallOpts {
+        async?: boolean;
+    }
+}
+/**
+ * Typings for the features we use to interface with our Emscripten build of
+ * QuickJS.
+ */
+interface EmscriptenModule {
+    /**
+     * Write JS `str` to HeapChar pointer.
+     * https://emscripten.org/docs/api_reference/preamble.js.html#stringToUTF8
+     */
+    stringToUTF8(str: string, outPtr: OwnedHeapCharPointer, maxBytesToRead?: number): void;
+    /**
+     * HeapChar to JS string.
+     * https://emscripten.org/docs/api_reference/preamble.js.html#UTF8ToString
+     */
+    UTF8ToString(ptr: BorrowedHeapCharPointer, maxBytesToRead?: number): string;
+    lengthBytesUTF8(str: string): number;
+    _malloc(size: number): number;
+    _free(ptr: number): void;
+    cwrap(ident: string, returnType: Emscripten.ValueType | null, argTypes: Emscripten.ValueType[], opts?: Emscripten.CCallOpts): (...args: any[]) => any;
+    HEAP8: Int8Array;
+    HEAP16: Int16Array;
+    HEAP32: Int32Array;
+    HEAPU8: Uint8Array;
+    HEAPU16: Uint16Array;
+    HEAPU32: Uint32Array;
+    HEAPF32: Float32Array;
+    HEAPF64: Float64Array;
+    TOTAL_STACK: number;
+    TOTAL_MEMORY: number;
+    FAST_MEMORY: number;
+}
+declare const AsyncifySleepReturnValue: unique symbol;
+/** @private */
+export type AsyncifySleepResult<T> = T & typeof AsyncifySleepReturnValue;
+/**
+ * Allows us to optionally suspend the Emscripten runtime to wait for a promise.
+ * https://emscripten.org/docs/porting/asyncify.html#ways-to-use-async-apis-in-older-engines
+ * ```
+ * EM_JS(int, do_fetch, (), {
+ *   return Asyncify.handleSleep(function (wakeUp) {
+ *     out("waiting for a fetch");
+ *     fetch("a.html").then(function (response) {
+ *       out("got the fetch response");
+ *       // (normally you would do something with the fetch here)
+ *       wakeUp(42);
+ *     });
+ *   });
+ * });
+ * ```
+ * @private
+ */
+export interface Asyncify {
+    handleSleep<T>(maybeAsyncFn: (wakeUp: (result: T) => void) => void): AsyncifySleepResult<T>;
+}
+/**
+ * @private
+ */
+export interface EmscriptenModuleCallbacks {
+    callFunction: (asyncify: Asyncify | undefined, ctx: JSContextPointer, this_ptr: JSValueConstPointer, argc: number, argv: JSValueConstPointer, fn_id: number) => JSValuePointer | AsyncifySleepResult<JSValuePointer>;
+    loadModuleSource: (asyncify: Asyncify | undefined, rt: JSRuntimePointer, ctx: JSContextPointer, module_name: string) => BorrowedHeapCharPointer | AsyncifySleepResult<BorrowedHeapCharPointer>;
+    normalizeModule: (asyncify: Asyncify | undefined, rt: JSRuntimePointer, ctx: JSContextPointer, module_base_name: string, module_name: string) => BorrowedHeapCharPointer | AsyncifySleepResult<BorrowedHeapCharPointer>;
+    shouldInterrupt: (asyncify: Asyncify | undefined, rt: JSRuntimePointer) => 0 | 1 | AsyncifySleepResult<0 | 1>;
+}
+export interface QuickJSEmscriptenModule extends EmscriptenModule {
+    type: "sync";
+    callbacks: EmscriptenModuleCallbacks;
+}
+export interface QuickJSAsyncEmscriptenModule extends EmscriptenModule {
+    /** @todo Implement this field */
+    type: "async";
+    callbacks: EmscriptenModuleCallbacks;
+}
+export type EitherModule = QuickJSEmscriptenModule | QuickJSAsyncEmscriptenModule;
+export interface EmscriptenModuleLoader<T extends EmscriptenModule> {
+    (): Promise<T>;
+}
+export {};

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/emscripten-types.js

@@ -0,0 +1,15 @@
+"use strict";
+// This is a subset of the Emscripten type definitions from @types/emscripten
+// Project: http://kripken.github.io/emscripten-site/index.html
+// Definitions by: Kensuke Matsuzaki <https://github.com/zakki>
+//                 Periklis Tsirakidis <https://github.com/periklis>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+//
+// quickjs-emscripten doesn't use the full EmscriptenModule type from @types/emscripten because:
+//
+// - the upstream types define many properties that don't exist on our module due
+//   to our build settings
+// - some upstream types reference web-only ambient types like WebGL stuff, which
+//   we don't use.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=emscripten-types.js.map

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/errors.d.ts

@@ -0,0 +1,28 @@
+import type { QuickJSContext } from "./context";
+/**
+ * Error thrown if [[QuickJSContext.unwrapResult]] unwraps an error value that isn't an object.
+ */
+export declare class QuickJSUnwrapError extends Error {
+    cause: unknown;
+    context?: QuickJSContext | undefined;
+    name: string;
+    constructor(cause: unknown, context?: QuickJSContext | undefined);
+}
+export declare class QuickJSWrongOwner extends Error {
+    name: string;
+}
+export declare class QuickJSUseAfterFree extends Error {
+    name: string;
+}
+export declare class QuickJSNotImplemented extends Error {
+    name: string;
+}
+export declare class QuickJSAsyncifyError extends Error {
+    name: string;
+}
+export declare class QuickJSAsyncifySuspended extends Error {
+    name: string;
+}
+export declare class QuickJSMemoryLeakDetected extends Error {
+    name: string;
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/errors.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickJSMemoryLeakDetected = exports.QuickJSAsyncifySuspended = exports.QuickJSAsyncifyError = exports.QuickJSNotImplemented = exports.QuickJSUseAfterFree = exports.QuickJSWrongOwner = exports.QuickJSUnwrapError = void 0;
+/**
+ * Error thrown if [[QuickJSContext.unwrapResult]] unwraps an error value that isn't an object.
+ */
+class QuickJSUnwrapError extends Error {
+    constructor(cause, context) {
+        super(String(cause));
+        this.cause = cause;
+        this.context = context;
+        this.name = "QuickJSUnwrapError";
+    }
+}
+exports.QuickJSUnwrapError = QuickJSUnwrapError;
+class QuickJSWrongOwner extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "QuickJSWrongOwner";
+    }
+}
+exports.QuickJSWrongOwner = QuickJSWrongOwner;
+class QuickJSUseAfterFree extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "QuickJSUseAfterFree";
+    }
+}
+exports.QuickJSUseAfterFree = QuickJSUseAfterFree;
+class QuickJSNotImplemented extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "QuickJSNotImplemented";
+    }
+}
+exports.QuickJSNotImplemented = QuickJSNotImplemented;
+class QuickJSAsyncifyError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "QuickJSAsyncifyError";
+    }
+}
+exports.QuickJSAsyncifyError = QuickJSAsyncifyError;
+class QuickJSAsyncifySuspended extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "QuickJSAsyncifySuspended";
+    }
+}
+exports.QuickJSAsyncifySuspended = QuickJSAsyncifySuspended;
+class QuickJSMemoryLeakDetected extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "QuickJSMemoryLeakDetected";
+    }
+}
+exports.QuickJSMemoryLeakDetected = QuickJSMemoryLeakDetected;
+//# sourceMappingURL=errors.js.map

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../ts/errors.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACH,MAAa,kBAAmB,SAAQ,KAAK;IAE3C,YAAmB,KAAc,EAAS,OAAwB;QAChE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;QADH,UAAK,GAAL,KAAK,CAAS;QAAS,YAAO,GAAP,OAAO,CAAiB;QADlE,SAAI,GAAG,oBAAoB,CAAA;IAG3B,CAAC;CACF;AALD,gDAKC;AAED,MAAa,iBAAkB,SAAQ,KAAK;IAA5C;;QACE,SAAI,GAAG,mBAAmB,CAAA;IAC5B,CAAC;CAAA;AAFD,8CAEC;AAED,MAAa,mBAAoB,SAAQ,KAAK;IAA9C;;QACE,SAAI,GAAG,qBAAqB,CAAA;IAC9B,CAAC;CAAA;AAFD,kDAEC;AAED,MAAa,qBAAsB,SAAQ,KAAK;IAAhD;;QACE,SAAI,GAAG,uBAAuB,CAAA;IAChC,CAAC;CAAA;AAFD,sDAEC;AAED,MAAa,oBAAqB,SAAQ,KAAK;IAA/C;;QACE,SAAI,GAAG,sBAAsB,CAAA;IAC/B,CAAC;CAAA;AAFD,oDAEC;AAED,MAAa,wBAAyB,SAAQ,KAAK;IAAnD;;QACE,SAAI,GAAG,0BAA0B,CAAA;IACnC,CAAC;CAAA;AAFD,4DAEC;AAED,MAAa,yBAA0B,SAAQ,KAAK;IAApD;;QACE,SAAI,GAAG,2BAA2B,CAAA;IACpC,CAAC;CAAA;AAFD,8DAEC","sourcesContent":["import type { QuickJSContext } from \"./context\"\n\n/**\n * Error thrown if [[QuickJSContext.unwrapResult]] unwraps an error value that isn't an object.\n */\nexport class QuickJSUnwrapError extends Error {\n  name = \"QuickJSUnwrapError\"\n  constructor(public cause: unknown, public context?: QuickJSContext) {\n    super(String(cause))\n  }\n}\n\nexport class QuickJSWrongOwner extends Error {\n  name = \"QuickJSWrongOwner\"\n}\n\nexport class QuickJSUseAfterFree extends Error {\n  name = \"QuickJSUseAfterFree\"\n}\n\nexport class QuickJSNotImplemented extends Error {\n  name = \"QuickJSNotImplemented\"\n}\n\nexport class QuickJSAsyncifyError extends Error {\n  name = \"QuickJSAsyncifyError\"\n}\n\nexport class QuickJSAsyncifySuspended extends Error {\n  name = \"QuickJSAsyncifySuspended\"\n}\n\nexport class QuickJSMemoryLeakDetected extends Error {\n  name = \"QuickJSMemoryLeakDetected\"\n}\n"]}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/esmHelpers.d.ts

@@ -0,0 +1,9 @@
+/** Typescript thinks import('...js/.d.ts') needs mod.default.default */
+declare function fakeUnwrapDefault<T>(mod: {
+    default: T;
+}): T;
+/** Typescript thinks import('...ts') doesn't need mod.default.default, but does */
+declare function actualUnwrapDefault<T>(mod: T): T;
+export declare const unwrapTypescript: typeof actualUnwrapDefault;
+export declare const unwrapJavascript: typeof fakeUnwrapDefault;
+export {};

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/esmHelpers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapJavascript = exports.unwrapTypescript = void 0;
+/** Typescript thinks import('...js/.d.ts') needs mod.default.default */
+function fakeUnwrapDefault(mod) {
+    // console.log("fakeUnwrapDefault", mod)
+    return mod.default;
+}
+/** Typescript thinks import('...ts') doesn't need mod.default.default, but does */
+function actualUnwrapDefault(mod) {
+    // console.log("actualUnwrapDefault", mod)
+    const maybeUnwrap = mod.default;
+    return maybeUnwrap ?? mod;
+}
+// I'm not sure if this behavior is needed in all runtimes,
+// or just for mocha + ts-node.
+exports.unwrapTypescript = actualUnwrapDefault;
+exports.unwrapJavascript = fakeUnwrapDefault;
+//# sourceMappingURL=esmHelpers.js.map

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/esmHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esmHelpers.js","sourceRoot":"","sources":["../ts/esmHelpers.ts"],"names":[],"mappings":";;;AAAA,wEAAwE;AACxE,SAAS,iBAAiB,CAAI,GAAmB;IAC/C,wCAAwC;IACxC,OAAO,GAAG,CAAC,OAAY,CAAA;AACzB,CAAC;AAED,mFAAmF;AACnF,SAAS,mBAAmB,CAAI,GAAM;IACpC,0CAA0C;IAC1C,MAAM,WAAW,GAAI,GAAW,CAAC,OAAO,CAAA;IACxC,OAAO,WAAW,IAAI,GAAG,CAAA;AAC3B,CAAC;AAED,2DAA2D;AAC3D,+BAA+B;AAClB,QAAA,gBAAgB,GAAG,mBAAmB,CAAA;AACtC,QAAA,gBAAgB,GAAG,iBAAiB,CAAA","sourcesContent":["/** Typescript thinks import('...js/.d.ts') needs mod.default.default */\nfunction fakeUnwrapDefault<T>(mod: { default: T }): T {\n  // console.log(\"fakeUnwrapDefault\", mod)\n  return mod.default as T\n}\n\n/** Typescript thinks import('...ts') doesn't need mod.default.default, but does */\nfunction actualUnwrapDefault<T>(mod: T): T {\n  // console.log(\"actualUnwrapDefault\", mod)\n  const maybeUnwrap = (mod as any).default\n  return maybeUnwrap ?? mod\n}\n\n// I'm not sure if this behavior is needed in all runtimes,\n// or just for mocha + ts-node.\nexport const unwrapTypescript = actualUnwrapDefault\nexport const unwrapJavascript = fakeUnwrapDefault\n"]}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/generated/emscripten-module.WASM_RELEASE_SYNC.d.ts

@@ -0,0 +1,5 @@
+export = QuickJSRaw;
+declare function QuickJSRaw(QuickJSRaw?: {}): any;
+declare namespace QuickJSRaw {
+    export { QuickJSRaw };
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/generated/ffi.WASM_RELEASE_SYNC.d.ts

@@ -0,0 +1,67 @@
+import { QuickJSEmscriptenModule } from "../emscripten-types";
+import { JSRuntimePointer, JSContextPointer, JSContextPointerPointer, JSValuePointer, JSValueConstPointer, JSValuePointerPointer, JSValueConstPointerPointer, BorrowedHeapCharPointer, OwnedHeapCharPointer, JSBorrowedCharPointer, JSVoidPointer, EvalFlags, EvalDetectModule } from "../types-ffi";
+/**
+ * Low-level FFI bindings to QuickJS's Emscripten module.
+ * See instead [[QuickJSContext]], the public Javascript interface exposed by this
+ * library.
+ *
+ * @unstable The FFI interface is considered private and may change.
+ */
+export declare class QuickJSFFI {
+    private module;
+    constructor(module: QuickJSEmscriptenModule);
+    /** Set at compile time. */
+    readonly DEBUG = false;
+    QTS_Throw: (ctx: JSContextPointer, error: JSValuePointer | JSValueConstPointer) => JSValuePointer;
+    QTS_NewError: (ctx: JSContextPointer) => JSValuePointer;
+    QTS_RuntimeSetMemoryLimit: (rt: JSRuntimePointer, limit: number) => void;
+    QTS_RuntimeComputeMemoryUsage: (rt: JSRuntimePointer, ctx: JSContextPointer) => JSValuePointer;
+    QTS_RuntimeDumpMemoryUsage: (rt: JSRuntimePointer) => OwnedHeapCharPointer;
+    QTS_RecoverableLeakCheck: () => number;
+    QTS_BuildIsSanitizeLeak: () => number;
+    QTS_RuntimeSetMaxStackSize: (rt: JSRuntimePointer, stack_size: number) => void;
+    QTS_GetUndefined: () => JSValueConstPointer;
+    QTS_GetNull: () => JSValueConstPointer;
+    QTS_GetFalse: () => JSValueConstPointer;
+    QTS_GetTrue: () => JSValueConstPointer;
+    QTS_NewRuntime: () => JSRuntimePointer;
+    QTS_FreeRuntime: (rt: JSRuntimePointer) => void;
+    QTS_NewContext: (rt: JSRuntimePointer) => JSContextPointer;
+    QTS_FreeContext: (ctx: JSContextPointer) => void;
+    QTS_FreeValuePointer: (ctx: JSContextPointer, value: JSValuePointer) => void;
+    QTS_FreeValuePointerRuntime: (rt: JSRuntimePointer, value: JSValuePointer) => void;
+    QTS_FreeVoidPointer: (ctx: JSContextPointer, ptr: JSVoidPointer) => void;
+    QTS_FreeCString: (ctx: JSContextPointer, str: JSBorrowedCharPointer) => void;
+    QTS_DupValuePointer: (ctx: JSContextPointer, val: JSValuePointer | JSValueConstPointer) => JSValuePointer;
+    QTS_NewObject: (ctx: JSContextPointer) => JSValuePointer;
+    QTS_NewObjectProto: (ctx: JSContextPointer, proto: JSValuePointer | JSValueConstPointer) => JSValuePointer;
+    QTS_NewArray: (ctx: JSContextPointer) => JSValuePointer;
+    QTS_NewFloat64: (ctx: JSContextPointer, num: number) => JSValuePointer;
+    QTS_GetFloat64: (ctx: JSContextPointer, value: JSValuePointer | JSValueConstPointer) => number;
+    QTS_NewString: (ctx: JSContextPointer, string: BorrowedHeapCharPointer) => JSValuePointer;
+    QTS_GetString: (ctx: JSContextPointer, value: JSValuePointer | JSValueConstPointer) => JSBorrowedCharPointer;
+    QTS_NewSymbol: (ctx: JSContextPointer, description: BorrowedHeapCharPointer, isGlobal: number) => JSValuePointer;
+    QTS_GetSymbolDescriptionOrKey: (ctx: JSContextPointer, value: JSValuePointer | JSValueConstPointer) => JSBorrowedCharPointer;
+    QTS_IsGlobalSymbol: (ctx: JSContextPointer, value: JSValuePointer | JSValueConstPointer) => number;
+    QTS_IsJobPending: (rt: JSRuntimePointer) => number;
+    QTS_ExecutePendingJob: (rt: JSRuntimePointer, maxJobsToExecute: number, lastJobContext: JSContextPointerPointer) => JSValuePointer;
+    QTS_GetProp: (ctx: JSContextPointer, this_val: JSValuePointer | JSValueConstPointer, prop_name: JSValuePointer | JSValueConstPointer) => JSValuePointer;
+    QTS_SetProp: (ctx: JSContextPointer, this_val: JSValuePointer | JSValueConstPointer, prop_name: JSValuePointer | JSValueConstPointer, prop_value: JSValuePointer | JSValueConstPointer) => void;
+    QTS_DefineProp: (ctx: JSContextPointer, this_val: JSValuePointer | JSValueConstPointer, prop_name: JSValuePointer | JSValueConstPointer, prop_value: JSValuePointer | JSValueConstPointer, get: JSValuePointer | JSValueConstPointer, set: JSValuePointer | JSValueConstPointer, configurable: boolean, enumerable: boolean, has_value: boolean) => void;
+    QTS_Call: (ctx: JSContextPointer, func_obj: JSValuePointer | JSValueConstPointer, this_obj: JSValuePointer | JSValueConstPointer, argc: number, argv_ptrs: JSValueConstPointerPointer) => JSValuePointer;
+    QTS_ResolveException: (ctx: JSContextPointer, maybe_exception: JSValuePointer) => JSValuePointer;
+    QTS_Dump: (ctx: JSContextPointer, obj: JSValuePointer | JSValueConstPointer) => JSBorrowedCharPointer;
+    QTS_Eval: (ctx: JSContextPointer, js_code: BorrowedHeapCharPointer, filename: string, detectModule: EvalDetectModule, evalFlags: EvalFlags) => JSValuePointer;
+    QTS_Typeof: (ctx: JSContextPointer, value: JSValuePointer | JSValueConstPointer) => OwnedHeapCharPointer;
+    QTS_GetGlobalObject: (ctx: JSContextPointer) => JSValuePointer;
+    QTS_NewPromiseCapability: (ctx: JSContextPointer, resolve_funcs_out: JSValuePointerPointer) => JSValuePointer;
+    QTS_TestStringArg: (string: string) => void;
+    QTS_BuildIsDebug: () => number;
+    QTS_BuildIsAsyncify: () => number;
+    QTS_NewFunction: (ctx: JSContextPointer, func_id: number, name: string) => JSValuePointer;
+    QTS_ArgvGetJSValueConstPointer: (argv: JSValuePointer | JSValueConstPointer, index: number) => JSValueConstPointer;
+    QTS_RuntimeEnableInterruptHandler: (rt: JSRuntimePointer) => void;
+    QTS_RuntimeDisableInterruptHandler: (rt: JSRuntimePointer) => void;
+    QTS_RuntimeEnableModuleLoader: (rt: JSRuntimePointer, use_custom_normalize: number) => void;
+    QTS_RuntimeDisableModuleLoader: (rt: JSRuntimePointer) => void;
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/generated/ffi.WASM_RELEASE_SYNC.js

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

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/index.d.ts

@@ -0,0 +1,75 @@
+import type { QuickJSWASMModule } from "./module";
+import type { QuickJSRuntime, InterruptHandler } from "./runtime";
+import type { QuickJSContext } from "./context";
+export type { QuickJSWASMModule, QuickJSContext, QuickJSRuntime };
+import type { QuickJSAsyncWASMModule } from "./module-asyncify";
+import type { QuickJSAsyncRuntime } from "./runtime-asyncify";
+import type { QuickJSAsyncContext, AsyncFunctionImplementation } from "./context-asyncify";
+import { AsyncRuntimeOptions, ContextOptions } from "./types";
+export type { QuickJSAsyncContext, QuickJSAsyncRuntime, QuickJSAsyncWASMModule, AsyncFunctionImplementation, };
+import { newQuickJSWASMModule, newQuickJSAsyncWASMModule, DEBUG_ASYNC, DEBUG_SYNC, RELEASE_ASYNC, RELEASE_SYNC, SyncBuildVariant, AsyncBuildVariant } from "./variants";
+export { newQuickJSWASMModule, newQuickJSAsyncWASMModule, DEBUG_ASYNC, DEBUG_SYNC, RELEASE_ASYNC, RELEASE_SYNC, SyncBuildVariant, AsyncBuildVariant, };
+export * from "./vm-interface";
+export * from "./lifetime";
+/** Collects the informative errors this library may throw. */
+export * as errors from "./errors";
+export * from "./deferred-promise";
+export * from "./module-test";
+export type { StaticJSValue, JSValueConst, JSValue, QuickJSHandle, ContextOptions, ContextEvalOptions, RuntimeOptions, AsyncRuntimeOptions, RuntimeOptionsBase, JSModuleLoader, JSModuleLoadResult, JSModuleLoaderAsync, JSModuleLoadSuccess, JSModuleLoadFailure, JSModuleNormalizer, JSModuleNormalizerAsync, JSModuleNormalizeResult, JSModuleNormalizeFailure, JSModuleNormalizeSuccess, } from "./types";
+export type { ModuleEvalOptions } from "./module";
+export type { InterruptHandler, ExecutePendingJobsResult } from "./runtime";
+export type { QuickJSPropertyKey } from "./context";
+/**
+ * Get a shared singleton {@link QuickJSWASMModule}. Use this to evaluate code
+ * or create Javascript environments.
+ *
+ * This is the top-level entrypoint for the quickjs-emscripten library.
+ *
+ * If you need strictest possible isolation guarantees, you may create a
+ * separate {@link QuickJSWASMModule} via {@link newQuickJSWASMModule}.
+ *
+ * To work with the asyncified version of this library, see these functions:
+ *
+ * - {@link newAsyncRuntime}.
+ * - {@link newAsyncContext}.
+ * - {@link newQuickJSAsyncWASMModule}.
+ */
+export declare function getQuickJS(): Promise<QuickJSWASMModule>;
+/**
+ * Provides synchronous access to the shared {@link QuickJSWASMModule} instance returned by {@link getQuickJS}, as long as
+ * least once.
+ * @throws If called before `getQuickJS` resolves.
+ */
+export declare function getQuickJSSync(): QuickJSWASMModule;
+/**
+ * Create a new [[QuickJSAsyncRuntime]] in a separate WebAssembly module.
+ *
+ * Each runtime is isolated in a separate WebAssembly module, so that errors in
+ * one runtime cannot contaminate another runtime, and each runtime can execute
+ * an asynchronous action without conflicts.
+ *
+ * Note that there is a hard limit on the number of WebAssembly modules in older
+ * versions of v8:
+ * https://bugs.chromium.org/p/v8/issues/detail?id=12076
+ */
+export declare function newAsyncRuntime(options?: AsyncRuntimeOptions): Promise<QuickJSAsyncRuntime>;
+/**
+ * Create a new [[QuickJSAsyncContext]] (with an associated runtime) in an
+ * separate WebAssembly module.
+ *
+ * Each context is isolated in a separate WebAssembly module, so that errors in
+ * one runtime cannot contaminate another runtime, and each runtime can execute
+ * an asynchronous action without conflicts.
+ *
+ * Note that there is a hard limit on the number of WebAssembly modules in older
+ * versions of v8:
+ * https://bugs.chromium.org/p/v8/issues/detail?id=12076
+ */
+export declare function newAsyncContext(options?: ContextOptions): Promise<QuickJSAsyncContext>;
+/**
+ * Returns an interrupt handler that interrupts Javascript execution after a deadline time.
+ *
+ * @param deadline - Interrupt execution if it's still running after this time.
+ *   Number values are compared against `Date.now()`
+ */
+export declare function shouldInterruptAfterDeadline(deadline: Date | number): InterruptHandler;

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/index.js

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

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/lifetime.d.ts

@@ -0,0 +1,115 @@
+import { MaybeAsyncBlock } from "./asyncify-helpers";
+import type { QuickJSHandle } from "./types";
+/**
+ * An object that can be disposed.
+ * [[Lifetime]] is the canonical implementation of Disposable.
+ * Use [[Scope]] to manage cleaning up multiple disposables.
+ */
+export interface Disposable {
+    /**
+     * Dispose of the underlying resources used by this object.
+     */
+    dispose(): void;
+    /**
+     * @returns true if the object is alive
+     * @returns false after the object has been [[dispose]]d
+     */
+    alive: boolean;
+}
+/**
+ * A lifetime prevents access to a value after the lifetime has been
+ * [[dispose]]ed.
+ *
+ * Typically, quickjs-emscripten uses Lifetimes to protect C memory pointers.
+ */
+export declare class Lifetime<T, TCopy = never, Owner = never> implements Disposable {
+    protected readonly _value: T;
+    protected readonly copier?: ((value: T | TCopy) => TCopy) | undefined;
+    protected readonly disposer?: ((value: T | TCopy) => void) | undefined;
+    protected readonly _owner?: Owner | undefined;
+    protected _alive: boolean;
+    protected _constructorStack: string | undefined;
+    /**
+     * When the Lifetime is disposed, it will call `disposer(_value)`. Use the
+     * disposer function to implement whatever cleanup needs to happen at the end
+     * of `value`'s lifetime.
+     *
+     * `_owner` is not used or controlled by the lifetime. It's just metadata for
+     * the creator.
+     */
+    constructor(_value: T, copier?: ((value: T | TCopy) => TCopy) | undefined, disposer?: ((value: T | TCopy) => void) | undefined, _owner?: Owner | undefined);
+    get alive(): boolean;
+    /**
+     * The value this Lifetime protects. You must never retain the value - it
+     * may become invalid, leading to memory errors.
+     *
+     * @throws If the lifetime has been [[dispose]]d already.
+     */
+    get value(): T;
+    get owner(): Owner | undefined;
+    get dupable(): boolean;
+    /**
+     * Create a new handle pointing to the same [[value]].
+     */
+    dup(): Lifetime<TCopy, TCopy, Owner>;
+    /**
+     * Call `map` with this lifetime, then dispose the lifetime.
+     * @return the result of `map(this)`.
+     */
+    consume<O>(map: (lifetime: this) => O): O;
+    consume<O>(map: (lifetime: QuickJSHandle) => O): O;
+    /**
+     * Dispose of [[value]] and perform cleanup.
+     */
+    dispose(): void;
+    private assertAlive;
+}
+/**
+ * A Lifetime that lives forever. Used for constants.
+ */
+export declare class StaticLifetime<T, Owner = never> extends Lifetime<T, T, Owner> {
+    constructor(value: T, owner?: Owner);
+    get dupable(): boolean;
+    dup(): this;
+    dispose(): void;
+}
+/**
+ * A Lifetime that does not own its `value`. A WeakLifetime never calls its
+ * `disposer` function, but can be `dup`ed to produce regular lifetimes that
+ * do.
+ *
+ * Used for function arguments.
+ */
+export declare class WeakLifetime<T, TCopy = never, Owner = never> extends Lifetime<T, TCopy, Owner> {
+    constructor(value: T, copier?: (value: T | TCopy) => TCopy, disposer?: (value: TCopy) => void, owner?: Owner);
+    dispose(): void;
+}
+/**
+ * Scope helps reduce the burden of manually tracking and disposing of
+ * Lifetimes. See [[withScope]]. and [[withScopeAsync]].
+ */
+export declare class Scope implements Disposable {
+    /**
+     * Run `block` with a new Scope instance that will be disposed after the block returns.
+     * Inside `block`, call `scope.manage` on each lifetime you create to have the lifetime
+     * automatically disposed after the block returns.
+     *
+     * @warning Do not use with async functions. Instead, use [[withScopeAsync]].
+     */
+    static withScope<R>(block: (scope: Scope) => R): R;
+    static withScopeMaybeAsync<Return, This, Yielded>(_this: This, block: MaybeAsyncBlock<Return, This, Yielded, [Scope]>): Return | Promise<Return>;
+    /**
+     * Run `block` with a new Scope instance that will be disposed after the
+     * block's returned promise settles. Inside `block`, call `scope.manage` on each
+     * lifetime you create to have the lifetime automatically disposed after the
+     * block returns.
+     */
+    static withScopeAsync<R>(block: (scope: Scope) => Promise<R>): Promise<R>;
+    private _disposables;
+    /**
+     * Track `lifetime` so that it is disposed when this scope is disposed.
+     */
+    manage<T extends Disposable>(lifetime: T): T;
+    get alive(): boolean;
+    dispose(): void;
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/lifetime.js

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

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/memory.d.ts

@@ -0,0 +1,18 @@
+import { EitherModule } from "./emscripten-types";
+import { OwnedHeapCharPointer, JSContextPointerPointer, JSValueConstPointerPointer, JSValuePointerPointer } from "./types-ffi";
+import { Lifetime } from "./lifetime";
+import { QuickJSHandle } from "./types";
+/**
+ * @private
+ */
+export declare class ModuleMemory {
+    module: EitherModule;
+    constructor(module: EitherModule);
+    toPointerArray(handleArray: QuickJSHandle[]): Lifetime<JSValueConstPointerPointer>;
+    newMutablePointerArray<T extends JSContextPointerPointer | JSValuePointerPointer>(length: number): Lifetime<{
+        typedArray: Int32Array;
+        ptr: T;
+    }>;
+    newHeapCharPointer(string: string): Lifetime<OwnedHeapCharPointer>;
+    consumeHeapCharPointer(ptr: OwnedHeapCharPointer): string;
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/memory.js

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

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../ts/memory.ts"],"names":[],"mappings":";;;AAOA,yCAAqC;AAGrC;;GAEG;AACH,MAAa,YAAY;IACvB,YAAmB,MAAoB;QAApB,WAAM,GAAN,MAAM,CAAc;IAAG,CAAC;IAE3C,cAAc,CAAC,WAA4B;QACzC,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;QAC5E,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,iBAAiB,CAAA;QACjE,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAA+B,CAAA;QACvE,IAAI,SAAS,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAA;QACxE,SAAS,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAA;QAChD,OAAO,IAAI,mBAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAA;IACtE,CAAC;IAED,sBAAsB,CACpB,MAAc;QAEd,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QACvD,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAA;QACvD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAM,CAAA;QAC9C,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,CAAA;QACzE,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QACrB,OAAO,IAAI,mBAAQ,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAA;IAC9F,CAAC;IAED,kBAAkB,CAAC,MAAc;QAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACxD,MAAM,GAAG,GAAyB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAyB,CAAA;QACvF,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAA;QAC/C,OAAO,IAAI,mBAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAA;IAC1E,CAAC;IAED,sBAAsB,CAAC,GAAyB;QAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAA;QACzC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QACtB,OAAO,GAAG,CAAA;IACZ,CAAC;CACF;AAnCD,oCAmCC","sourcesContent":["import { EitherModule } from \"./emscripten-types\"\nimport {\n  OwnedHeapCharPointer,\n  JSContextPointerPointer,\n  JSValueConstPointerPointer,\n  JSValuePointerPointer,\n} from \"./types-ffi\"\nimport { Lifetime } from \"./lifetime\"\nimport { EitherFFI, QuickJSHandle } from \"./types\"\n\n/**\n * @private\n */\nexport class ModuleMemory {\n  constructor(public module: EitherModule) {}\n\n  toPointerArray(handleArray: QuickJSHandle[]): Lifetime<JSValueConstPointerPointer> {\n    const typedArray = new Int32Array(handleArray.map((handle) => handle.value))\n    const numBytes = typedArray.length * typedArray.BYTES_PER_ELEMENT\n    const ptr = this.module._malloc(numBytes) as JSValueConstPointerPointer\n    var heapBytes = new Uint8Array(this.module.HEAPU8.buffer, ptr, numBytes)\n    heapBytes.set(new Uint8Array(typedArray.buffer))\n    return new Lifetime(ptr, undefined, (ptr) => this.module._free(ptr))\n  }\n\n  newMutablePointerArray<T extends JSContextPointerPointer | JSValuePointerPointer>(\n    length: number\n  ): Lifetime<{ typedArray: Int32Array; ptr: T }> {\n    const zeros = new Int32Array(new Array(length).fill(0))\n    const numBytes = zeros.length * zeros.BYTES_PER_ELEMENT\n    const ptr = this.module._malloc(numBytes) as T\n    const typedArray = new Int32Array(this.module.HEAPU8.buffer, ptr, length)\n    typedArray.set(zeros)\n    return new Lifetime({ typedArray, ptr }, undefined, (value) => this.module._free(value.ptr))\n  }\n\n  newHeapCharPointer(string: string): Lifetime<OwnedHeapCharPointer> {\n    const numBytes = this.module.lengthBytesUTF8(string) + 1\n    const ptr: OwnedHeapCharPointer = this.module._malloc(numBytes) as OwnedHeapCharPointer\n    this.module.stringToUTF8(string, ptr, numBytes)\n    return new Lifetime(ptr, undefined, (value) => this.module._free(value))\n  }\n\n  consumeHeapCharPointer(ptr: OwnedHeapCharPointer): string {\n    const str = this.module.UTF8ToString(ptr)\n    this.module._free(ptr)\n    return str\n  }\n}\n"]}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/module-asyncify.d.ts

@@ -0,0 +1,53 @@
+import { QuickJSAsyncContext } from "./context-asyncify";
+import { QuickJSAsyncEmscriptenModule } from "./emscripten-types";
+import { QuickJSAsyncFFI } from "./variants";
+import { ModuleEvalOptions, QuickJSWASMModule } from "./module";
+import { QuickJSAsyncRuntime } from "./runtime-asyncify";
+import { AsyncRuntimeOptions, ContextOptions } from "./types";
+/**
+ * Asyncified version of [[QuickJSWASMModule]].
+ *
+ * Due to limitations of Emscripten's ASYNCIFY process, only a single async
+ * function call can happen at a time across the entire WebAssembly module.
+ *
+ * That means that all runtimes, contexts, functions, etc created inside this
+ * WebAssembly are limited to a single concurrent async action.
+ * **Multiple concurrent async actions is an error.**
+ *
+ * To allow for multiple concurrent async actions, you must create multiple WebAssembly
+ * modules.
+ */
+export declare class QuickJSAsyncWASMModule extends QuickJSWASMModule {
+    /** @private */
+    protected ffi: QuickJSAsyncFFI;
+    /** @private */
+    protected module: QuickJSAsyncEmscriptenModule;
+    /** @private */
+    constructor(module: QuickJSAsyncEmscriptenModule, ffi: QuickJSAsyncFFI);
+    /**
+     * Create a new async runtime inside this WebAssembly module. All runtimes inside a
+     * module are limited to a single async call at a time. For multiple
+     * concurrent async actions, create multiple WebAssembly modules.
+     */
+    newRuntime(options?: AsyncRuntimeOptions): QuickJSAsyncRuntime;
+    /**
+     * 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?: ContextOptions): QuickJSAsyncContext;
+    /** Synchronous evalCode is not supported. */
+    evalCode(): never;
+    /**
+     * One-off evaluate code without needing to create a [[QuickJSRuntimeAsync]] or
+     * [[QuickJSContextSync]] explicitly.
+     *
+     * This version allows for asynchronous Ecmascript module loading.
+     *
+     * Note that only a single async action can occur at a time inside the entire WebAssembly module.
+     * **Multiple concurrent async actions is an error.**
+     *
+     * See the documentation for [[QuickJSWASMModule.evalCode]] for more details.
+     */
+    evalCodeAsync(code: string, options: ModuleEvalOptions): Promise<unknown>;
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/module-asyncify.js

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

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/module-test.d.ts

@@ -0,0 +1,27 @@
+import type { QuickJSContext } from "./context";
+import type { ModuleEvalOptions, QuickJSWASMModule } from "./module";
+import type { QuickJSRuntime } from "./runtime";
+import type { ContextOptions, RuntimeOptions } from "./types";
+/**
+ * A test wrapper of [[QuickJSWASMModule]] that keeps a reference to each
+ * context or runtime created.
+ *
+ * Call [[disposeAll]] to reset these sets and calls `dispose` on any left alive
+ * (which may throw an error).
+ *
+ * Call [[assertNoMemoryAllocated]] at the end of a test, when you expect that you've
+ * freed all the memory you've ever allocated.
+ */
+export declare class TestQuickJSWASMModule implements Pick<QuickJSWASMModule, keyof QuickJSWASMModule> {
+    private parent;
+    contexts: Set<QuickJSContext>;
+    runtimes: Set<QuickJSRuntime>;
+    constructor(parent: QuickJSWASMModule);
+    newRuntime(options?: RuntimeOptions): QuickJSRuntime;
+    newContext(options?: ContextOptions): QuickJSContext;
+    evalCode(code: string, options?: ModuleEvalOptions): unknown;
+    disposeAll(): void;
+    assertNoMemoryAllocated(): void;
+    /** @private */
+    getFFI(): any;
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/module-test.js

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

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/module-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-test.js","sourceRoot":"","sources":["../ts/module-test.ts"],"names":[],"mappings":";;;AAIA,qCAAoD;AACpD,yCAAqC;AAErC;;;;;;;;;GASG;AACH,MAAa,qBAAqB;IAGhC,YAAoB,MAAyB;QAAzB,WAAM,GAAN,MAAM,CAAmB;QAF7C,aAAQ,GAAG,IAAI,GAAG,EAAkB,CAAA;QACpC,aAAQ,GAAG,IAAI,GAAG,EAAkB,CAAA;IACY,CAAC;IAEjD,UAAU,CAAC,OAAwB;QACjC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;YACrC,GAAG,OAAO;YACV,cAAc,EAAE;gBACd,IAAI,mBAAQ,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBACvE,GAAG,CAAC,OAAO,EAAE,cAAc,IAAI,EAAE,CAAC;aACnC;SACF,CAAC,CAAA;QACF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAC1B,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,UAAU,CAAC,OAAwB;QACjC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;YACrC,GAAG,OAAO;YACV,cAAc,EAAE;gBACd,IAAI,mBAAQ,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBACvE,GAAG,CAAC,OAAO,EAAE,cAAc,IAAI,EAAE,CAAC;aACnC;SACF,CAAC,CAAA;QACF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAC1B,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,QAAQ,CAAC,IAAY,EAAE,OAA2B;QAChD,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;IAC5C,CAAC;IAED,UAAU;QACR,MAAM,cAAc,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAA;QAC3D,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAA;QACrB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAA;QACrB,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YAC3B,IAAI,CAAC,CAAC,KAAK,EAAE;gBACX,CAAC,CAAC,OAAO,EAAE,CAAA;aACZ;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,uBAAuB;QACrB,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,wBAAwB,EAAE,CAAA;QAC9D,IAAI,aAAa,EAAE;YACjB,mEAAmE;YACnE,qBAAqB;YACrB,MAAM,IAAI,kCAAyB,CAAC,yCAAyC,CAAC,CAAA;SAC/E;QAED,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,EAAE;YAC1B,MAAM,IAAI,kCAAyB,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,kBAAkB,CAAC,CAAA;SAC7E;QAED,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,EAAE;YAC1B,MAAM,IAAI,kCAAyB,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,kBAAkB,CAAC,CAAA;SAC7E;IACH,CAAC;IAED,eAAe;IACf,MAAM;QACJ,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAA;IAC7B,CAAC;CACF;AAjED,sDAiEC","sourcesContent":["import type { QuickJSContext } from \"./context\"\nimport type { ModuleEvalOptions, QuickJSWASMModule } from \"./module\"\nimport type { QuickJSRuntime } from \"./runtime\"\nimport type { ContextOptions, RuntimeOptions } from \"./types\"\nimport { QuickJSMemoryLeakDetected } from \"./errors\"\nimport { Lifetime } from \"./lifetime\"\n\n/**\n * A test wrapper of [[QuickJSWASMModule]] that keeps a reference to each\n * context or runtime created.\n *\n * Call [[disposeAll]] to reset these sets and calls `dispose` on any left alive\n * (which may throw an error).\n *\n * Call [[assertNoMemoryAllocated]] at the end of a test, when you expect that you've\n * freed all the memory you've ever allocated.\n */\nexport class TestQuickJSWASMModule implements Pick<QuickJSWASMModule, keyof QuickJSWASMModule> {\n  contexts = new Set<QuickJSContext>()\n  runtimes = new Set<QuickJSRuntime>()\n  constructor(private parent: QuickJSWASMModule) {}\n\n  newRuntime(options?: RuntimeOptions): QuickJSRuntime {\n    const runtime = this.parent.newRuntime({\n      ...options,\n      ownedLifetimes: [\n        new Lifetime(undefined, undefined, () => this.runtimes.delete(runtime)),\n        ...(options?.ownedLifetimes ?? []),\n      ],\n    })\n    this.runtimes.add(runtime)\n    return runtime\n  }\n\n  newContext(options?: ContextOptions): QuickJSContext {\n    const context = this.parent.newContext({\n      ...options,\n      ownedLifetimes: [\n        new Lifetime(undefined, undefined, () => this.contexts.delete(context)),\n        ...(options?.ownedLifetimes ?? []),\n      ],\n    })\n    this.contexts.add(context)\n    return context\n  }\n\n  evalCode(code: string, options?: ModuleEvalOptions): unknown {\n    return this.parent.evalCode(code, options)\n  }\n\n  disposeAll() {\n    const allDisposables = [...this.contexts, ...this.runtimes]\n    this.runtimes.clear()\n    this.contexts.clear()\n    allDisposables.forEach((d) => {\n      if (d.alive) {\n        d.dispose()\n      }\n    })\n  }\n\n  assertNoMemoryAllocated() {\n    const leaksDetected = this.getFFI().QTS_RecoverableLeakCheck()\n    if (leaksDetected) {\n      // Note: this is currently only available when building from source\n      // with debug builds.\n      throw new QuickJSMemoryLeakDetected(\"Leak sanitizer detected un-freed memory\")\n    }\n\n    if (this.contexts.size > 0) {\n      throw new QuickJSMemoryLeakDetected(`${this.contexts.size} contexts leaked`)\n    }\n\n    if (this.runtimes.size > 0) {\n      throw new QuickJSMemoryLeakDetected(`${this.runtimes.size} runtimes leaked`)\n    }\n  }\n\n  /** @private */\n  getFFI() {\n    return this.parent.getFFI()\n  }\n}\n"]}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/module.d.ts

@@ -0,0 +1,152 @@
+import { QuickJSContext } from "./context";
+import { Asyncify, AsyncifySleepResult, EitherModule, EmscriptenModuleCallbacks } from "./emscripten-types";
+import { JSContextPointer, JSRuntimePointer } from "./types-ffi";
+import { InterruptHandler, QuickJSRuntime } from "./runtime";
+import { ContextOptions, EitherFFI, JSModuleLoader, RuntimeOptions, RuntimeOptionsBase } from "./types";
+type EmscriptenCallback<BaseArgs extends any[], Result> = (...args: [Asyncify | undefined, ...BaseArgs]) => Result | AsyncifySleepResult<Result>;
+type MaybeAsyncEmscriptenCallback<T extends EmscriptenCallback<any, any>> = T extends EmscriptenCallback<infer Args, infer Result> ? (...args: Args) => Result | Promise<Result> : never;
+type MaybeAsyncEmscriptenCallbacks = {
+    [K in keyof EmscriptenModuleCallbacks]: MaybeAsyncEmscriptenCallback<EmscriptenModuleCallbacks[K]>;
+};
+/**
+ * @private
+ */
+export interface ContextCallbacks {
+    callFunction: MaybeAsyncEmscriptenCallbacks["callFunction"];
+}
+/**
+ * @private
+ */
+export interface RuntimeCallbacks {
+    shouldInterrupt: MaybeAsyncEmscriptenCallbacks["shouldInterrupt"];
+    loadModuleSource: MaybeAsyncEmscriptenCallbacks["loadModuleSource"];
+    normalizeModule: MaybeAsyncEmscriptenCallbacks["normalizeModule"];
+}
+/**
+ * Options for [[QuickJSWASMModule.evalCode]].
+ */
+export interface ModuleEvalOptions {
+    /**
+     * Interrupt evaluation if `shouldInterrupt` returns `true`.
+     * See [[shouldInterruptAfterDeadline]].
+     */
+    shouldInterrupt?: InterruptHandler;
+    /**
+     * Memory limit, in bytes, of WebAssembly heap memory used by the QuickJS VM.
+     */
+    memoryLimitBytes?: number;
+    /**
+     * Stack size limit for this vm, in bytes
+     * To remove the limit, set to `0`.
+     */
+    maxStackSizeBytes?: number;
+    /**
+     * Module loader for any `import` statements or expressions.
+     */
+    moduleLoader?: JSModuleLoader;
+}
+/**
+ * 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
+ */
+export declare class QuickJSModuleCallbacks {
+    private module;
+    private contextCallbacks;
+    private runtimeCallbacks;
+    constructor(module: EitherModule);
+    setRuntimeCallbacks(rt: JSRuntimePointer, callbacks: RuntimeCallbacks): void;
+    deleteRuntime(rt: JSRuntimePointer): void;
+    setContextCallbacks(ctx: JSContextPointer, callbacks: ContextCallbacks): void;
+    deleteContext(ctx: JSContextPointer): void;
+    private suspendedCount;
+    private suspended;
+    private handleAsyncify;
+    private cToHostCallbacks;
+}
+/**
+ * Process RuntimeOptions and apply them to a QuickJSRuntime.
+ * @private
+ */
+export declare function applyBaseRuntimeOptions(runtime: QuickJSRuntime, options: RuntimeOptionsBase): void;
+/**
+ * Process ModuleEvalOptions and apply them to a QuickJSRuntime.
+ * @private
+ */
+export declare function applyModuleEvalRuntimeOptions<T extends QuickJSRuntime>(runtime: T, options: ModuleEvalOptions): void;
+/**
+ * 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}.
+ */
+export declare class QuickJSWASMModule {
+    /** @private */
+    protected ffi: EitherFFI;
+    /** @private */
+    protected callbacks: QuickJSModuleCallbacks;
+    /** @private */
+    protected module: EitherModule;
+    /** @private */
+    constructor(module: EitherModule, ffi: EitherFFI);
+    /**
+     * 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?: RuntimeOptions): QuickJSRuntime;
+    /**
+     * 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?: ContextOptions): QuickJSContext;
+    /**
+     * 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: string, options?: ModuleEvalOptions): unknown;
+    /**
+     * 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(): EitherFFI;
+}
+export {};

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/module.js

@@ -0,0 +1,302 @@
+"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

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/runtime-asyncify.d.ts

@@ -0,0 +1,38 @@
+import { Lifetime } from ".";
+import { QuickJSAsyncContext } from "./context-asyncify";
+import { QuickJSAsyncEmscriptenModule } from "./emscripten-types";
+import { QuickJSAsyncFFI } from "./variants";
+import { JSContextPointer, JSRuntimePointer } from "./types-ffi";
+import { QuickJSModuleCallbacks } from "./module";
+import { QuickJSRuntime } from "./runtime";
+import { ContextOptions, JSModuleLoaderAsync, JSModuleNormalizerAsync } from "./types";
+export declare class QuickJSAsyncRuntime extends QuickJSRuntime {
+    context: QuickJSAsyncContext | undefined;
+    /** @private */
+    protected module: QuickJSAsyncEmscriptenModule;
+    /** @private */
+    protected ffi: QuickJSAsyncFFI;
+    /** @private */
+    protected rt: Lifetime<JSRuntimePointer>;
+    /** @private */
+    protected callbacks: QuickJSModuleCallbacks;
+    /** @private */
+    protected contextMap: Map<JSContextPointer, QuickJSAsyncContext>;
+    /** @private */
+    constructor(args: {
+        module: QuickJSAsyncEmscriptenModule;
+        ffi: QuickJSAsyncFFI;
+        rt: Lifetime<JSRuntimePointer>;
+        callbacks: QuickJSModuleCallbacks;
+    });
+    newContext(options?: ContextOptions): QuickJSAsyncContext;
+    setModuleLoader(moduleLoader: JSModuleLoaderAsync, moduleNormalizer?: JSModuleNormalizerAsync): void;
+    /**
+     * 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: number): void;
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/runtime-asyncify.js

@@ -0,0 +1,49 @@
+"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

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/runtime-asyncify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-asyncify.js","sourceRoot":"","sources":["../ts/runtime-asyncify.ts"],"names":[],"mappings":";;;AACA,wBAA4B;AAC5B,yDAAwD;AAKxD,uCAA0C;AAC1C,mCAOgB;AAEhB,MAAa,mBAAoB,SAAQ,wBAAc;IAcrD,eAAe;IACf,YAAY,IAKX;QACC,KAAK,CAAC,IAAI,CAAC,CAAA;IACb,CAAC;IAEQ,UAAU,CAAC,UAA0B,EAAE;QAC9C,IAAI,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU,KAAK,yBAAiB,EAAE;YAClE,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;SACjE;QAED,MAAM,GAAG,GAAG,IAAI,WAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE;YACtF,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;YAC/B,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,CAAA;YACrC,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,CAAA;QACnC,CAAC,CAAC,CAAA;QAEF,MAAM,OAAO,GAAG,IAAI,sCAAmB,CAAC;YACtC,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,GAAG;YACH,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,cAAc,EAAE,EAAE;YAClB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC,CAAA;QACF,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAEvC,OAAO,OAAO,CAAA;IAChB,CAAC;IAEe,eAAe,CAC7B,YAAiC,EACjC,gBAA0C;QAE1C,KAAK,CAAC,eAAe,CACnB,YAA8B,EAC9B,gBAAkD,CACnD,CAAA;IACH,CAAC;IAED;;;;;;OAMG;IACa,eAAe,CAAC,SAAiB;QAC/C,OAAO,KAAK,CAAC,eAAe,CAAC,SAAS,CAAC,CAAA;IACzC,CAAC;CACF;AArED,kDAqEC","sourcesContent":["import type { QuickJSAsyncWASMModule } from \"./module-asyncify\"\nimport { Lifetime } from \".\"\nimport { QuickJSAsyncContext } from \"./context-asyncify\"\nimport { QuickJSAsyncEmscriptenModule } from \"./emscripten-types\"\nimport { QuickJSAsyncFFI } from \"./variants\"\nimport { JSContextPointer, JSRuntimePointer } from \"./types-ffi\"\nimport { QuickJSModuleCallbacks } from \"./module\"\nimport { QuickJSRuntime } from \"./runtime\"\nimport {\n  ContextOptions,\n  DefaultIntrinsics,\n  JSModuleLoader,\n  JSModuleLoaderAsync,\n  JSModuleNormalizer,\n  JSModuleNormalizerAsync,\n} from \"./types\"\n\nexport class QuickJSAsyncRuntime extends QuickJSRuntime {\n  public context: QuickJSAsyncContext | undefined\n\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  /** @private */\n  protected declare contextMap: Map<JSContextPointer, QuickJSAsyncContext>\n\n  /** @private */\n  constructor(args: {\n    module: QuickJSAsyncEmscriptenModule\n    ffi: QuickJSAsyncFFI\n    rt: Lifetime<JSRuntimePointer>\n    callbacks: QuickJSModuleCallbacks\n  }) {\n    super(args)\n  }\n\n  override newContext(options: ContextOptions = {}): QuickJSAsyncContext {\n    if (options.intrinsics && options.intrinsics !== DefaultIntrinsics) {\n      throw new Error(\"TODO: Custom intrinsics are not supported yet\")\n    }\n\n    const ctx = new Lifetime(this.ffi.QTS_NewContext(this.rt.value), undefined, (ctx_ptr) => {\n      this.contextMap.delete(ctx_ptr)\n      this.callbacks.deleteContext(ctx_ptr)\n      this.ffi.QTS_FreeContext(ctx_ptr)\n    })\n\n    const context = new QuickJSAsyncContext({\n      module: this.module,\n      ctx,\n      ffi: this.ffi,\n      rt: this.rt,\n      ownedLifetimes: [],\n      runtime: this,\n      callbacks: this.callbacks,\n    })\n    this.contextMap.set(ctx.value, context)\n\n    return context\n  }\n\n  public override setModuleLoader(\n    moduleLoader: JSModuleLoaderAsync,\n    moduleNormalizer?: JSModuleNormalizerAsync\n  ): void {\n    super.setModuleLoader(\n      moduleLoader as JSModuleLoader,\n      moduleNormalizer as JSModuleNormalizer | undefined\n    )\n  }\n\n  /**\n   * Set the max stack size for this runtime in bytes.\n   * To remove the limit, set to `0`.\n   *\n   * Setting this limit also adjusts the global `ASYNCIFY_STACK_SIZE` for the entire {@link QuickJSAsyncWASMModule}.\n   * See the [pull request](https://github.com/justjake/quickjs-emscripten/pull/114) for more details.\n   */\n  public override setMaxStackSize(stackSize: number): void {\n    return super.setMaxStackSize(stackSize)\n  }\n}\n"]}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/runtime.d.ts

@@ -0,0 +1,174 @@
+import { QuickJSContext } from "./context";
+import { EitherModule } from "./emscripten-types";
+import { JSContextPointer, JSRuntimePointer } from "./types-ffi";
+import { Disposable, Lifetime, Scope } from "./lifetime";
+import { ModuleMemory } from "./memory";
+import { QuickJSModuleCallbacks } from "./module";
+import { ContextOptions, EitherFFI, JSModuleLoader, JSModuleNormalizer, QuickJSHandle } from "./types";
+import { SuccessOrFail } from "./vm-interface";
+/**
+ * Callback called regularly while the VM executes code.
+ * Determines if a VM's execution should be interrupted.
+ *
+ * @returns `true` to interrupt JS execution inside the VM.
+ * @returns `false` or `undefined` to continue JS execution inside the VM.
+ */
+export type InterruptHandler = (runtime: QuickJSRuntime) => boolean | undefined;
+/**
+ * Used as an optional for the results of executing pendingJobs.
+ * On success, `value` contains the number of async jobs executed
+ * by the runtime.
+ * @source
+ */
+export type ExecutePendingJobsResult = SuccessOrFail<
+/** Number of jobs successfully executed. */
+number, 
+/** The error that occurred. */
+QuickJSHandle & {
+    /** The context where the error occurred. */
+    context: QuickJSContext;
+}>;
+/**
+ * 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]].
+ */
+export declare class QuickJSRuntime implements Disposable {
+    /**
+     * If this runtime was created as as part of a context, points to the context
+     * associated with the runtime.
+     *
+     * If this runtime was created stand-alone, this may or may not contain a context.
+     * A context here may be allocated if one is needed by the runtime, eg for [[computeMemoryUsage]].
+     */
+    context: QuickJSContext | undefined;
+    /** @private */
+    protected module: EitherModule;
+    /** @private */
+    protected memory: ModuleMemory;
+    /** @private */
+    protected ffi: EitherFFI;
+    /** @private */
+    protected rt: Lifetime<JSRuntimePointer>;
+    /** @private */
+    protected callbacks: QuickJSModuleCallbacks;
+    /** @private */
+    protected scope: Scope;
+    /** @private */
+    protected contextMap: Map<JSContextPointer, QuickJSContext>;
+    /** @private */
+    protected moduleLoader: JSModuleLoader | undefined;
+    /** @private */
+    protected moduleNormalizer: JSModuleNormalizer | undefined;
+    /** @private */
+    constructor(args: {
+        module: EitherModule;
+        ffi: EitherFFI;
+        rt: Lifetime<JSRuntimePointer>;
+        callbacks: QuickJSModuleCallbacks;
+        ownedLifetimes?: Disposable[];
+    });
+    get alive(): boolean;
+    dispose(): void;
+    newContext(options?: ContextOptions): QuickJSContext;
+    /**
+     * Set the loader for EcmaScript modules requested by any context in this
+     * runtime.
+     *
+     * The loader can be removed with [[removeModuleLoader]].
+     */
+    setModuleLoader(moduleLoader: JSModuleLoader, moduleNormalizer?: JSModuleNormalizer): void;
+    /**
+     * Remove the the loader set by [[setModuleLoader]]. This disables module loading.
+     */
+    removeModuleLoader(): void;
+    /**
+     * 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(): boolean;
+    private interruptHandler;
+    /**
+     * 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: InterruptHandler): void;
+    /**
+     * Remove the interrupt handler, if any.
+     * See [[setInterruptHandler]].
+     */
+    removeInterruptHandler(): void;
+    /**
+     * 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?: number | void): ExecutePendingJobsResult;
+    /**
+     * Set the max memory this runtime can allocate.
+     * To remove the limit, set to `-1`.
+     */
+    setMemoryLimit(limitBytes: number): void;
+    /**
+     * 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(): QuickJSHandle;
+    /**
+     * @returns a human-readable description of memory usage in this runtime.
+     * For programmatic access to this information, see [[computeMemoryUsage]].
+     */
+    dumpMemoryUsage(): string;
+    /**
+     * Set the max stack size for this runtime, in bytes.
+     * To remove the limit, set to `0`.
+     */
+    setMaxStackSize(stackSize: number): void;
+    /**
+     * Assert that `handle` is owned by this runtime.
+     * @throws QuickJSWrongOwner if owned by a different runtime.
+     */
+    assertOwned(handle: QuickJSHandle): void;
+    private getSystemContext;
+    private cToHostCallbacks;
+}

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/runtime.js

@@ -0,0 +1,300 @@
+"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

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/types-ffi.d.ts

@@ -0,0 +1,114 @@
+/**
+ * C pointer to type `CType`. Pointer types are used internally for FFI, but
+ * are not intended for external use.
+ *
+ * @unstable This type is considered private and may change.
+ */
+type Pointer<CType extends string> = number & {
+    ctype: CType;
+};
+type Brand<T, B> = T & {
+    brand: B;
+};
+/**
+ * `JSRuntime*`.
+ */
+export type JSRuntimePointer = Pointer<"JSRuntime">;
+/**
+ * `JSContext*`.
+ */
+export type JSContextPointer = Pointer<"JSContext">;
+/**
+ * `JSContext**`. Used internally for execute pending jobs.
+ */
+export type JSContextPointerPointer = Pointer<"JSContext">;
+/**
+ * `JSModuleDef*`.
+ */
+export type JSModuleDefPointer = Pointer<"JSModuleDef">;
+/**
+ * `JSValue*`.
+ * See [[JSValue]].
+ */
+export type JSValuePointer = Pointer<"JSValue">;
+/**
+ * `JSValueConst*
+ * See [[JSValueConst]] and [[StaticJSValue]].
+ */
+export type JSValueConstPointer = Pointer<"JSValueConst">;
+/**
+ * Used internally for Javascript-to-C function calls.
+ */
+export type JSValuePointerPointer = Pointer<"JSValue[]">;
+/**
+ * Used internally for Javascript-to-C function calls.
+ */
+export type JSValueConstPointerPointer = Pointer<"JSValueConst[]">;
+/**
+ * Used internally for C-to-Javascript function calls.
+ */
+/**
+ * Used internally for C-to-Javascript function calls.
+ */
+export type QTS_C_To_HostCallbackFuncPointer = Pointer<"C_To_HostCallbackFunc">;
+/**
+ * Used internally for C-to-Javascript interrupt handlers.
+ */
+export type QTS_C_To_HostInterruptFuncPointer = Pointer<"C_To_HostInterruptFunc">;
+/**
+ * Used internally for C-to-Javascript module loading.
+ */
+export type QTS_C_To_HostLoadModuleFuncPointer = Pointer<"C_To_HostLoadModuleFunc">;
+/**
+ * Used internally for Javascript-to-C calls that may contain strings too large
+ * for the Emscripten stack.
+ */
+export type BorrowedHeapCharPointer = Pointer<"const char" | "char" | "js const char">;
+/**
+ * Used internally for Javascript-to-C calls that may contain strings too large
+ * for the Emscripten stack.
+ */
+export type OwnedHeapCharPointer = Pointer<"char">;
+/**
+ * Used internally for Javascript-to-C calls that may contain strings too large
+ * for the Emscripten stack.
+ */
+export type JSBorrowedCharPointer = Pointer<"js const char">;
+/**
+ * Opaque pointer that was allocated by js_malloc.
+ */
+export type JSVoidPointer = Pointer<any>;
+/**
+ * @private
+ */
+export type EvalFlags = Brand<number, "EvalFlags">;
+/**
+ * @private
+ */
+export type EvalDetectModule = Brand<number, "EvalDetectModule">;
+export declare function assertSync<Args extends any[], R>(fn: (...args: Args) => R): (...args: Args) => R;
+/** Bitfield options for JS_Eval() C function. */
+export declare const EvalFlags: {
+    /** global code (default) */
+    JS_EVAL_TYPE_GLOBAL: number;
+    /** module code */
+    JS_EVAL_TYPE_MODULE: number;
+    /** direct call (internal use) */
+    JS_EVAL_TYPE_DIRECT: number;
+    /** indirect call (internal use) */
+    JS_EVAL_TYPE_INDIRECT: number;
+    JS_EVAL_TYPE_MASK: number;
+    /** force 'strict' mode */
+    JS_EVAL_FLAG_STRICT: number;
+    /** force 'strip' mode */
+    JS_EVAL_FLAG_STRIP: number;
+    /**
+     * 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: number;
+    /** don't include the stack frames before this eval in the Error() backtraces */
+    JS_EVAL_FLAG_BACKTRACE_BARRIER: number;
+};
+export {};

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/types-ffi.js

@@ -0,0 +1,38 @@
+"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

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

@@ -0,0 +1 @@
+{"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"]}

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

@@ -0,0 +1,158 @@
+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 {};

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/types.js

@@ -0,0 +1,58 @@
+"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

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

@@ -0,0 +1,113 @@
+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;

Scripts/node_modules/@tootallnate/quickjs-emscripten/dist/variants.js

@@ -0,0 +1,169 @@
+"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

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

@@ -0,0 +1,68 @@
+/**
+ * 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;
+}

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

@@ -0,0 +1,12 @@
+"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

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

@@ -0,0 +1 @@
+{"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"]}

Scripts/node_modules/@tootallnate/quickjs-emscripten/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@tootallnate/quickjs-emscripten",
+  "version": "0.23.0",
+  "main": "dist/index.js",
+  "sideEffects": false,
+  "license": "MIT",
+  "keywords": [
+    "eval",
+    "quickjs",
+    "vm",
+    "interpreter",
+    "runtime",
+    "safe",
+    "emscripten",
+    "wasm"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/justjake/quickjs-emscripten"
+  },
+  "files": [
+    "c/interface.c",
+    "dist/**/*",
+    "!dist/*.test.js",
+    "!dist/*.tsbuildinfo"
+  ],
+  "scripts": {
+    "tarball": "make build/quickjs-emscripten.tgz",
+    "clean": "make clean",
+    "tsc": "node_modules/.bin/tsc",
+    "build": "make dist",
+    "doc": "typedoc",
+    "test": "TS_NODE_TRANSPILE_ONLY=true mocha 'ts/**/*.test.ts'",
+    "test-dist": "cd dist && TS_NODE_TRANSPILE_ONLY=true mocha --require source-map-support/register *.test.js",
+    "test-fast": "TEST_NO_ASYNC=true yarn test 'ts/**/*.test.ts'",
+    "test-all": "TEST_LEAK=1 yarn test && TEST_LEAK=1 yarn test-dist",
+    "prettier": "prettier --write .",
+    "prettier-check": "prettier --check .",
+    "update-quickjs": "git subtree pull --prefix=quickjs --squash git@github.com:bellard/quickjs.git master",
+    "smoketest-node": "yarn tarball && ./scripts/smoketest-node.sh",
+    "smoketest-cra": "yarn tarball && ./scripts/smoketest-website.sh"
+  },
+  "devDependencies": {
+    "@types/emscripten": "^1.38.0",
+    "@types/fs-extra": "^9.0.13",
+    "@types/mocha": "^5.2.7",
+    "@types/node": "^13.1.4",
+    "fs-extra": "^10.0.1",
+    "markserv": "^1.17.4",
+    "mocha": "7.2.0",
+    "node-fetch-commonjs": "^3.1.1",
+    "prettier": "2.8.4",
+    "source-map-support": "^0.5.21",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.22.0",
+    "typedoc-plugin-inline-sources": "^1.0.1",
+    "typedoc-plugin-markdown": "^3.11.12",
+    "typescript": "^4.9.5"
+  }
+}