quickjs-emscripten
Advanced tools
Changelog
v0.29.1
context.evalCode(..., { type: 'module' }) would return success when some kinds of error occurred when using quickjs variants.
context.getPromiseState(handle) to resolve promises synchronously.Readme
Javascript/Typescript bindings for QuickJS, a modern Javascript interpreter, compiled to WebAssembly.
Github | NPM | API Documentation | Variants | Examples
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()
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 QuickJSWASMModule 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 in your synchronous code.
See QuickJSWASMModule.evalCode
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)
})
You can use QuickJSContext 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).
Every context is created inside a QuickJSRuntime. A runtime represents a Javascript heap, and you can even share values between contexts in the same runtime.
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.
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.
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()
When you evaluate code as an ES Module, the result will be a handle to the module's exports, or a handle to a promise that resolves to the module's exports if the module depends on a top-level await.
const context = QuickJS.newContext()
const result = context.evalCode(
`
export const name = 'Jake'
export const favoriteBean = 'wax bean'
export default 'potato'
`,
"jake.js",
{ type: "module" },
)
const moduleExports = context.unwrapResult(result)
console.log(context.dump(moduleExports))
// -> { name: 'Jake', favoriteBean: 'wax bean', default: 'potato' }
moduleExports.dispose()
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.
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:
using statementThe using statement is a Stage 3 (as of 2023-12-29) proposal for Javascript that declares a constant variable and automatically calls the [Symbol.dispose]() method of an object when it goes out of scope. Read more in this Typescript release announcement. Here's the "Interfacing with the interpreter" example re-written using using:
using vm = QuickJS.newContext()
let state = 0
// The block here isn't needed for correctness, but it shows
// how to get a tighter bound on the lifetime of `fnHandle`.
{
using fnHandle = vm.newFunction("nextId", () => {
return vm.newNumber(++state)
})
vm.setProp(vm.global, "nextId", fnHandle)
// fnHandle.dispose() is called automatically when the block exits
}
using nextId = vm.unwrapResult(vm.evalCode(`nextId(); nextId(); nextId()`))
console.log("vm result:", vm.getNumber(nextId), "native state:", state)
// nextId.dispose() is called automatically when the block exits
// vm.dispose() is called automatically when the block exits
A
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:
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
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():
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.
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. The newFunction documentation covers writing functions in detail.
By default, no host functionality is exposed to code running inside QuickJS.
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()
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, there are two options:
You can synchronously peek into a QuickJS promise handle and get its state without introducing asynchronous host code, described by the type JSPromiseState:
type JSPromiseState =
| { type: "pending"; error: Error }
| { type: "fulfilled"; value: QuickJSHandle; notAPromise?: boolean }
| { type: "rejected"; error: QuickJSHandle }
The result conforms to the SuccessOrFail type returned by context.evalCode, so you can use context.unwrapResult(context.getPromiseState(promiseHandle)) to assert a promise is settled successfully and retrieve its value. Calling context.unwrapResult on a pending or rejected promise will throw an error.
const promiseHandle = context.evalCode(`Promise.resolve(42)`)
const resultHandle = context.unwrapResult(context.getPromiseState(promiseHandle))
context.getNumber(resultHandle) === 42 // true
resultHandle.dispose()
promiseHandle.dispose()
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.
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()
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 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:
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.
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 Of our build in the future.
To use asyncify features, use the following functions:
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.
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.
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>
Here's an example of turning an async function into a sync function inside the VM.
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'
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.
// 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 repository.
The main quickjs-emscripten package includes several build variants of the WebAssembly module:
RELEASE... build variants should be used in production. They offer better performance and smaller file size compared to DEBUG... build variants.
RELEASE_SYNC: This is the default variant used when you don't explicitly provide one. It offers the fastest performance and smallest file size.RELEASE_ASYNC: The default variant if you need asyncify magic, which comes at a performance cost. See the asyncify docs for details.DEBUG... build variants can be helpful during development and testing. They include source maps and assertions for catching bugs in your code. We recommend running your tests with both a debug build variant and the release build variant you'll use in production.
DEBUG_SYNC: Instrumented to detect memory leaks, in addition to assertions and source maps.DEBUG_ASYNC: An asyncify variant with source maps.To use a variant, call newQuickJSWASMModule or newQuickJSAsyncWASMModule with the variant object. These functions return a promise that resolves to a QuickJSWASMModule, the same as getQuickJS.
import {
newQuickJSWASMModule,
newQuickJSAsyncWASMModule,
RELEASE_SYNC,
DEBUG_SYNC,
RELEASE_ASYNC,
DEBUG_ASYNC,
} from "quickjs-emscripten"
const QuickJSReleaseSync = await newQuickJSWASMModule(RELEASE_SYNC)
const QuickJSDebugSync = await newQuickJSWASMModule(DEBUG_SYNC)
const QuickJSReleaseAsync = await newQuickJSAsyncWASMModule(RELEASE_ASYNC)
const QuickJSDebugAsync = await newQuickJSAsyncWASMModule(DEBUG_ASYNC)
for (const quickjs of [
QuickJSReleaseSync,
QuickJSDebugSync,
QuickJSReleaseAsync,
QuickJSDebugAsync,
]) {
const vm = quickjs.newContext()
const result = vm.unwrapResult(vm.evalCode("1 + 1")).consume(vm.getNumber)
console.log(result)
vm.dispose()
quickjs.dispose()
}
Including 4 different copies of the WebAssembly module in the main package gives it an install size of about 9.04mb. If you're building a CLI package or library of your own, or otherwise don't need to include 4 different variants in your node_modules, you can switch to the quickjs-emscripten-core package, which contains only the Javascript code for this library, and install one (or more) variants a-la-carte as separate packages.
The most minimal setup would be to install quickjs-emscripten-core and @jitl/quickjs-wasmfile-release-sync (1.3mb total):
yarn add quickjs-emscripten-core @jitl/quickjs-wasmfile-release-sync
du -h node_modules
# 640K node_modules/@jitl/quickjs-wasmfile-release-sync
# 80K node_modules/@jitl/quickjs-ffi-types
# 588K node_modules/quickjs-emscripten-core
# 1.3M node_modules
Then, you can use quickjs-emscripten-core's newQuickJSWASMModuleFromVariant to create a QuickJS module (see the minimal example):
// src/quickjs.mjs
import { newQuickJSWASMModuleFromVariant } from "quickjs-emscripten-core"
import RELEASE_SYNC from "@jitl/quickjs-wasmfile-release-sync"
export const QuickJS = await newQuickJSWASMModuleFromVariant(RELEASE_SYNC)
// src/app.mjs
import { QuickJS } from "./quickjs.mjs"
console.log(QuickJS.evalCode("1 + 1"))
See the documentation of quickjs-emscripten-core for more details and the list of variant packages.
To run QuickJS, we need to load a WebAssembly module into the host Javascript runtime's memory (usually as an ArrayBuffer or TypedArray) and compile it to a WebAssembly.Module. This means we need to find the file path or URI of the WebAssembly module, and then read it using an API like fetch (browser) or fs.readFile (NodeJS). quickjs-emscripten tries to handle this automatically using patterns like new URL('./local-path', import.meta.url) that work in the browser or are handled automatically by bundlers, or __dirname in NodeJS, but you may need to configure this manually if these don't work in your environment, or you want more control about how the WebAssembly module is loaded.
To customize the loading of an existing variant, create a new variant with your loading settings using newVariant, passing CustomizeVariantOptions. For example, you need to customize loading in Cloudflare Workers (see the full example).
import { newQuickJSWASMModule, DEBUG_SYNC as baseVariant, newVariant } from "quickjs-emscripten"
import cloudflareWasmModule from "./DEBUG_SYNC.wasm"
import cloudflareWasmModuleSourceMap from "./DEBUG_SYNC.wasm.map.txt"
/**
* We need to make a new variant that directly passes the imported WebAssembly.Module
* to Emscripten. Normally we'd load the wasm file as bytes from a URL, but
* that's forbidden in Cloudflare workers.
*/
const cloudflareVariant = newVariant(baseVariant, {
wasmModule: cloudflareWasmModule,
wasmSourceMapData: cloudflareWasmModuleSourceMap,
})
quickjs-ng/quickjs (aka quickjs-ng) is a fork of the original bellard/quickjs under active development. It implements more EcmaScript standards and removes some of quickjs's custom language features like BigFloat.
There are several variants of quickjs-ng available, and quickjs-emscripten may switch to using quickjs-ng by default in the future. See the list of variants.
You can use quickjs-emscripten directly from an HTML file in two ways:
Import it in an ES Module script tag
<!doctype html>
<!-- Import from a ES Module CDN -->
<script type="module">
import { getQuickJS } from "https://esm.sh/quickjs-emscripten@0.25.0"
const QuickJS = await getQuickJS()
console.log(QuickJS.evalCode("1+1"))
</script>
In edge cases, you might want to use the IIFE build which provides QuickJS as the global QJS. You should probably use the ES module though, any recent browser supports it.
<!doctype html>
<!-- Add a script tag to load the library as the QJS global -->
<script
src="https://cdn.jsdelivr.net/npm/quickjs-emscripten@0.25.0/dist/index.global.js"
type="text/javascript"
></script>
<!-- Then use the QJS global in a script tag -->
<script type="text/javascript">
QJS.getQuickJS().then((QuickJS) => {
console.log(QuickJS.evalCode("1+1"))
})
</script>
Switch to a DEBUG build variant of the WebAssembly module to see debug log messages from the C part of this library:
import { newQuickJSWASMModule, DEBUG_SYNC } from "quickjs-emscripten"
const QuickJS = await newQuickJSWASMModule(DEBUG_SYNC)
With quickjs-emscripten-core:
import { newQuickJSWASMModuleFromVariant } from "quickjs-emscripten-core"
import DEBUG_SYNC from "@jitl/quickjs-wasmfile-debug-sync"
const QuickJS = await newQuickJSWASMModuleFromVariant(DEBUG_SYNC)
Enable debug log messages from the Javascript part of this library with setDebugMode:
import { setDebugMode } from "quickjs-emscripten"
setDebugMode(true)
With quickjs-emscripten-core:
import { setDebugMode } from "quickjs-emscripten-core"
setDebugMode(true)
quickjs-emscripten and related packages should work in any environment that supports ES2020.
Github | NPM | API Documentation | Variants | Examples
This was inspired by seeing https://github.com/maple3142/duktape-eval on Hacker News and Figma's blogposts about using building a Javascript plugin runtime:
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.
Further work on module loading APIs:
Higher-level tools for reading QuickJS values:
context.isArray(handle), context.isPromise(handle), etc.context.getIterable(handle), context.iterateObjectEntries(handle).
This better supports user-level code to deserialize complex handle objects.Higher-level tools for creating QuickJS values:
SQLite integration.
This library is implemented in two languages: C (compiled to WASM with Emscripten), and Typescript.
You will need node, yarn, make, and emscripten to build this project.
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 with emscripten (using emcc), to produce WebAssembly.
The version of Emscripten used by the project is defined in templates/Variant.mk.
emscripten on your machine. For example on macOS, brew install emscripten.We produce multiple build variants of the C code compiled to WebAssembly using a template script the ./packages directory. Each build variant uses its own copy of a Makefile to build the C code. The Makefile is generated from a template in ./templates/Variant.mk.
Related NPM scripts:
yarn vendor:update updates vendor/quickjs and vendor/quickjs-ng to the latest versions on Github.yarn build:codegen updates the ./packages from the template script ./prepareVariants.ts and Variant.mk.yarn build:packages builds the variant packages in parallel.The Javascript/Typescript code is also organized into several NPM packages in ./packages:
getQuickJS function.
This package combines quickjs-emscripten-core with platform-appropriate WebAssembly/C code.Related NPM scripts:
yarn check runs all available checks (build, format, tests, etc).yarn build builds all the packages and generates the docs.yarn test runs the tests for all packages.
yarn test:fast runs the tests using only fast build variants.yarn doc generates the docs into ./doc.
yarn doc:serve previews the current ./doc in a browser.yarn prettier formats the repo.Just run yarn set version from sources to upgrade the Yarn release.
FAQs
Unknown package
The npm package quickjs-emscripten receives a total of 18,017 weekly downloads. As such, quickjs-emscripten popularity was classified as popular.
We found that quickjs-emscripten demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
UnitedHealth Group disclosed that the ransomware attack on Change Healthcare compromised protected health information for millions in the U.S., with estimated costs to the company expected to reach $1 billion.
Security News
GitHub is susceptible to a CDN flaw that allows attackers to host malware on any public repository.
Security News
At Node Congress, Socket CEO Feross Aboukhadijeh uncovers the darker aspects of open source, where applications that rely heavily on third-party dependencies can be exploited in supply chain attacks.