quickjs-emscripten-sync 1.1.0 → 1.4.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 rot1024
+Copyright (c) 2022 rot1024
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ 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.
+SOFTWARE.

package/README.md

@@ -1,6 +1,8 @@
 # quickjs-emscripten-sync
 
-We can build a plugin system that works safely in the web browser!
+[![CI](https://github.com/reearth/quickjs-emscripten-sync/actions/workflows/ci.yml/badge.svg)](https://github.com/reearth/quickjs-emscripten-sync/actions/workflows/main.yml) [![codecov](https://codecov.io/gh/reearth/quickjs-emscripten-sync/branch/main/graph/badge.svg)](https://codecov.io/gh/reearth/quickjs-emscripten-sync)
+
+Build a secure plugin system in web browsers
 
 This library wraps [quickjs-emscripten](https://github.com/justjake/quickjs-emscripten) and provides a way to sync object state between the browser and sandboxed QuickJS.
 
@@ -10,6 +12,7 @@ This library wraps [quickjs-emscripten](https://github.com/justjake/quickjs-emsc
   - Functions
   - Classes and instances
   - Objects with prototypes and any property descriptors
+  - Promises
 - Expose objects as a global object in QuickJS
 - Marshaling limitation for specific objects
 - Register a pair of objects that will be considered the same between the browser and QuickJS
@@ -20,7 +23,7 @@ npm install quickjs-emscripten quickjs-emscripten-sync
 
 ```js
 import { getQuickJS } from "quickjs-emscripten";
-import Arena from "quickjs-emscripten-sync";
+import { Arena } from "quickjs-emscripten-sync";
 
 class Cls {
   field = 0;
@@ -30,10 +33,10 @@ class Cls {
   }
 }
 
-const vm = (await getQuickJS()).createVm();
-const arena = new Arena(vm);
+const ctx = (await getQuickJS()).newContext();
+const arena = new Arena(ctx, { isMarshalable: true });
 
-// We can pass objects to the VM and run code safely
+// We can pass objects to the context and run code safely
 const exposed = {
   Cls,
   cls: new Cls(),
@@ -41,22 +44,22 @@ const exposed = {
 };
 arena.expose(exposed);
 
-arena.evalCode(`cls instanceof Cls`)); // returns true
-arena.evalCode(`cls.field`));          // returns 0
-arena.evalCode(`cls.method()`));       // returns 1
-arena.evalCode(`cls.field`));          // returns 1
+arena.evalCode(`cls instanceof Cls`); // returns true
+arena.evalCode(`cls.field`);          // returns 0
+arena.evalCode(`cls.method()`);       // returns 1
+arena.evalCode(`cls.field`);          // returns 1
 
-arena.evalCode(`syncedCls.field`);     // returns 0
-exposed.syncedCls.method();            // returns 1
-arena.evalCode(`syncedCls.field`);     // returns 1
+arena.evalCode(`syncedCls.field`);    // returns 0
+exposed.syncedCls.method();           // returns 1
+arena.evalCode(`syncedCls.field`);    // returns 1
 
 arena.dispose();
-vm.dispose();
+ctx.dispose();
 ```
 
 [Example code](src/index.test.ts) is available as the unit test code.
 
-## Operating environment
+## Operating Environment
 
 - Web browsers that support WebAssembly
 - Node.js
@@ -67,16 +70,17 @@ If you want to run quickjs-emscripten and quickjs-emscripten-sync in a web brows
 
 ```js
 import { getQuickJS } from "quickjs-emscripten";
-import Arena from "quickjs-emscripten-sync";
+import { Arena } from "quickjs-emscripten-sync";
 
 (async function() {
-  const quickjs = await getQuickJS();
-  const vm = quickjs.createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   // init Arena
-  const arena = new Arena(vm);
+  // ⚠️ Marshaling is opt-in for security reasons.
+  // ⚠️ Be careful when activating marshalling.
+  const arena = new Arena(ctx, { isMarshalable: true });
 
-  // expose objects as global objects in QuickJS VM
+  // expose objects as global objects in QuickJS context
   arena.expose({
     console: {
       log: console.log
@@ -87,32 +91,32 @@ import Arena from "quickjs-emscripten-sync";
 
   // expose objects but also enable sync
   const data = arena.sync({ hoge: "foo" });
-  const exposed = arena.expose({ data });
+  arena.expose({ data });
 
   arena.evalCode(`data.hoge = "bar"`);
   // eval code and operations to exposed objects are automatically synced
   console.log(data.hoge); // "bar"
-  exposed.hoge = "changed!";
+  data.hoge = "changed!";
   console.log(arena.evalCode(`data.hoge`)); // "changed!"
 
-  // Don't forget calling arena.dispose() before disposing QuickJS VM!
+  // Don't forget calling arena.dispose() before disposing QuickJS context!
   arena.dispose();
-  vm.dispose();
+  ctx.dispose();
 })();
 ```
 
-## Marshaling limitations
+## Marshaling Limitations
 
-Objects are automatically converted when they cross between the host and the QuickJS VM. The conversion of a host's object to a VM handle is called marshaling, and the conversion of a VM handle to a host's object is called unmarshaling.
+Objects are automatically converted when they cross between the host and the QuickJS context. The conversion of a host's object to a handle is called marshaling, and the conversion of a handle to a host's object is called unmarshaling.
 
 And for marshalling, it is possible to control whether the conversion is performed or not.
 
 For example, exposing the host's global object to QuickJS is very heavy and dangerous. This exposure can be limited and controlled with the `isMarshalable` option. If `false` is returned, just `undefined` is passed to QuickJS.
 
 ```js
-import Arena, { complexity } from "quickjs-emscripten-sync";
+import { Arena, complexity } from "quickjs-emscripten-sync";
 
-const arena = new Arena(vm, {
+const arena = new Arena(ctx, {
   isMarshalable: (target: any) => {
     // prevent passing globalThis to QuickJS
     if (target === window) return false;
@@ -129,13 +133,13 @@ arena.evalCode(`a => a === undefined`)(document); // true
 
 The `complexity` function is useful to detect whether the object is too heavy to be passed to QuickJS.
 
-## Security warning
+## Security Warning
 
 QuickJS has an environment isolated from the browser, so any code can be executed safely, but there are edge cases where some exposed objects by quickjs-emscripten-sync may break security.
 
 quickjs-emscripten-sync cannot prevent such dangerous case, so **PLEASE be very careful and deliberate about what you expose to QuickJS!**
 
-### Case 1: Prototype pollution in browser
+### Case 1: Prototype pollution
 
 ```js
 import { set } from "lodash-es";
@@ -179,28 +183,34 @@ By default, quickjs-emscripten-sync doesn't prevent any marshaling, even in such
 
 ### `Arena`
 
-The Arena class manages all generated handles at once by quickjs-emscripten and automatically converts objects between the host and the QuickJS VM.
+The Arena class manages all generated handles at once by quickjs-emscripten and automatically converts objects between the host and the QuickJS context.
 
-#### `new Arena(vm: QuickJSVm, options?: Options)`
+#### `new Arena(ctx: QuickJSContext, options?: Options)`
 
-Constructs a new Arena instance. It requires a quickjs-emscripten VM initialized with `quickjs.createVM()`.
+Constructs a new Arena instance. It requires a quickjs-emscripten context initialized with `quickjs.newContext()`.
 
 Options accepted:
 
 ```ts
 type Options = {
-  isMarshalable?: (target: any) => boolean;
+  isMarshalable?: boolean | "json" | ((target: any) => boolean | "json");
   registeredObjects?: Iterable<[any, QuickJSHandle | string]>;
+  compat?: boolean;
 }
 ```
 
-- **`isMarshalable`**: A callback that returns a boolean value that determines whether an object is marshalled or not. If false, no marshaling will be done and undefined will be passed to the QuickJS VM, otherwise marshaling will be done. By default, all objects will be marshalled.
-- **`registeredObjects`**: You can pre-register a pair of objects that will be considered the same between the host and the QuickJS VM. This will be used automatically during the conversion. By default, it will be registered automatically with [`defaultRegisteredObjects`](src/default.ts). If you want to add a new pair to this, please do the following:
+- **`isMarshalable`**: Determines how marshalling will be done when sending objects from the host to the context. **Make sure to set the marshalling to be the minimum necessary as it may reduce the security of your application.** [Please read the section on security above.](#security-warning)
+   - `"json"` (**default**, safety): Target object will be serialized as JSON in host and then parsed in context. Functions and classes will be lost in the process.
+   - `false` (safety): Target object will not be always marshalled as `undefined`.
+   - `(target: any) => boolean | "json"` (recoomended): You can control marshalling mode for each objects. If you want to do marshalling, usually use this method. Allow partial marshalling by returning `true` only for some objects.
+   - `true` (**risky and not recommended**): Target object will be always marshaled. This setting may reduce security.
+- **`registeredObjects`**: You can pre-register a pair of objects that will be considered the same between the host and the QuickJS context. This will be used automatically during the conversion. By default, it will be registered automatically with [`defaultRegisteredObjects`](src/default.ts). If you want to add a new pair to this, please do the following:
+- **`compat`**: If you want to use quickjs-emscripten v0.15 or older, enable this option to automatically inject code to the VM for compatibility.
 
 ```js
 import { defaultRegisteredObjects } from "quickjs-emscripten-sync";
 
-const arena = new Arena(vm, {
+const arena = new Arena(ctx, {
   registeredObjects: [
     ...defaultRegisteredObjects,
     [Math, "Math"]
@@ -208,36 +218,36 @@ const arena = new Arena(vm, {
 });
 ```
 
-Instead of a string, you can also pass a QuickJSHandle directly. In that case, however, you have to dispose of them manually when destroying the VM.
+Instead of a string, you can also pass a QuickJSHandle directly. In that case, however, you have to dispose of them manually when destroying the context.
 
 #### `dispose()`
 
-Dispose of the arena and managed handles. This method won't dispose the VM itself, so the VM has to be disposed of manually.
+Dispose of the arena and managed handles. This method won't dispose the context itself, so the context has to be disposed of manually.
 
 #### `evalCode<T = any>(code: string): T | undefined`
 
-Evaluate JS code in the VM and get the result as an object on the host side. It also converts and re-throws error objects when an error is thrown during evaluation.
+Evaluate JS code in the context and get the result as an object on the host side. It also converts and re-throws error objects when an error is thrown during evaluation.
 
 #### `executePendingJobs(): number`
 
-Almost same as `vm.executePendingJobs()`, but it converts and re-throws error objects when an error is thrown during evaluation.
+Almost same as `ctx.runtime.executePendingJobs()`, but it converts and re-throws error objects when an error is thrown during evaluation.
 
 #### `expose(obj: { [k: string]: any })`
 
-Expose objects as global objects in the VM.
+Expose objects as global objects in the context.
 
-By default, exposed objects are not synchronized between the host and the VM.
-If you want to sync an objects, first wrap the object with sync method, and then expose the wrapped object.
+By default, exposed objects are not synchronized between the host and the context.
+If you want to sync an objects, first wrap the object with `sync` method, and then expose the wrapped object.
 
 #### `sync<T>(target: T): T`
 
-Enables sync for the object between the host and the VM and returns objects wrapped with proxies.
+Enables sync for the object between the host and the context and returns objects wrapped with proxies.
 
-The return value is necessary in order to reflect changes to the object from the host to the VM. Please note that setting a value in the field or deleting a field in the original object will not synchronize it.
+The return value is necessary in order to reflect changes to the object from the host to the context. Please note that setting a value in the field or deleting a field in the original object will not synchronize it.
 
 #### `register(target: any, code: string | QuickJSHandle)`
 
-Register a pair of objects that will be considered the same between the host and the QuickJS VM.
+Register a pair of objects that will be considered the same between the host and the QuickJS context.
 
 #### `unregisterAll(targets: Iterable<[any, string | QuickJSHandle]>)`
 
@@ -263,9 +273,9 @@ Measure the complexity of an object as you traverse the field and prototype chai
 
 ### How to work
 
-quickjs-emscripten can execute JS code safely, but it requires to deal with a lot of handles and lifetimes. Also, when destroying the VM, any un-destroyed handle will result in an error.
+quickjs-emscripten can execute JS code safely, but it requires to deal with a lot of handles and lifetimes. Also, when destroying the context, any un-destroyed handle will result in an error.
 
-quickjs-emscripten-sync will automatically manage all handles once generated by QuickJS VM in an Arena class. 
+quickjs-emscripten-sync will automatically manage all handles once generated by QuickJS context in an Arena class.
 And it will automatically "marshal" objects as handles and "unmarshal" handles as objects to enable seamless data exchange between the browser and QuickJS. It recursively traverses the object properties and prototype chain to transform objects. A function is called after its arguments and this arg are automatically converted for the environment in which the function is defined. The return value will be automatically converted to match the environment of the caller.
 Most objects are wrapped by proxies during conversion, allowing "set" and "delete" operations on objects to be synchronized between the browser and QuickJS.
 
@@ -273,7 +283,7 @@ Most objects are wrapped by proxies during conversion, allowing "set" and "delet
 
 #### Class constructor
 
-When initializing a new instance, it is not possible to fully proxy this arg (a.k.a. `new.target`) inside the class constructor. Therefore, after the constructor call, the fields set for this are re-set to this on the VM side. Therefore, there may be some edge cases where the constructor may not work properly.
+When initializing a new instance, it is not possible to fully proxy this arg (a.k.a. `new.target`) inside the class constructor. Therefore, after the constructor call, the fields set for this are re-set to this on the context side. Therefore, there may be some edge cases where the constructor may not work properly.
 
 ```js
 class Cls {

package/dist/index.d.ts

@@ -1,27 +1,14 @@
-import { QuickJSHandle, QuickJSVm } from "quickjs-emscripten";
-import { SuccessOrFail, VmCallResult } from "quickjs-emscripten/dist/vm-interface";
-import VMMap from "./vmmap";
-import marshal from "./marshal";
-import unmarshal from "./unmarshal";
-import { Wrapped } from "./wrapper";
-import { complexity, isES2015Class, isObject, walkObject } from "./util";
-import { call, eq, isHandleObject, send, consumeAll } from "./vmutil";
-import { defaultRegisteredObjects } from "./default";
-export { Arena, VMMap, defaultRegisteredObjects, marshal, unmarshal, complexity, isES2015Class, isObject, walkObject, call, eq, isHandleObject, send, consumeAll, };
-export declare type Options = {
-    /** A callback that returns a boolean value that determines whether an object is marshalled or not. If false, no marshaling will be done and undefined will be passed to the QuickJS VM, otherwise marshaling will be done. By default, all objects will be marshalled. */
-    isMarshalable?: (target: any) => boolean;
-    /** You can pre-register a pair of objects that will be considered the same between the host and the QuickJS VM. This will be used automatically during the conversion. By default, it will be registered automatically with `defaultRegisteredObjects`.
-     *
-     * Instead of a string, you can also pass a QuickJSHandle directly. In that case, however, you have to dispose of them manually when destroying the VM.
-     */
-    registeredObjects?: Iterable<[any, QuickJSHandle | string]>;
-};
+import type { QuickJSContext } from 'quickjs-emscripten';
+import type { QuickJSDeferredPromise } from 'quickjs-emscripten';
+import type { QuickJSHandle } from 'quickjs-emscripten';
+import type { SuccessOrFail } from 'quickjs-emscripten';
+import type { VmCallResult } from 'quickjs-emscripten';
+
 /**
  * The Arena class manages all generated handles at once by quickjs-emscripten and automatically converts objects between the host and the QuickJS VM.
  */
-export default class Arena {
-    vm: QuickJSVm;
+export declare class Arena {
+    context: QuickJSContext;
     _map: VMMap;
     _registeredMap: VMMap;
     _registeredMapDispose: Set<any>;
@@ -30,8 +17,8 @@ export default class Arena {
     _symbol: symbol;
     _symbolHandle: QuickJSHandle;
     _options?: Options;
-    /** Constructs a new Arena instance. It requires a quickjs-emscripten VM initialized with `quickjs.createVM()`. */
-    constructor(vm: QuickJSVm, options?: Options);
+    /** Constructs a new Arena instance. It requires a quickjs-emscripten context initialized with `quickjs.newContext()`. */
+    constructor(ctx: QuickJSContext, options?: Options);
     /**
      * Dispose of the arena and managed handles. This method won't dispose the VM itself, so the VM has to be disposed of manually.
      */
@@ -81,12 +68,120 @@ export default class Arena {
     endSync(target: any): void;
     _unwrapResult<T>(result: SuccessOrFail<T, QuickJSHandle>): T;
     _unwrapResultAndUnmarshal(result: VmCallResult<QuickJSHandle> | undefined): any;
-    _marshal(target: any): QuickJSHandle;
-    _unmarshal(handle: QuickJSHandle): any;
+    _isMarshalable: (t: unknown) => boolean | "json";
+    _marshalFind: (t: unknown) => QuickJSHandle | undefined;
+    _marshalPre: (t: unknown, h: QuickJSHandle | QuickJSDeferredPromise, mode: true | "json" | undefined) => Wrapped<QuickJSHandle> | undefined;
+    _marshalPreApply: (target: Function, that: unknown, args: unknown[]) => void;
+    _marshal: (target: any) => [QuickJSHandle, boolean];
+    _preUnmarshal: (t: any, h: QuickJSHandle) => Wrapped<any>;
+    _unmarshalFind: (h: QuickJSHandle) => unknown;
+    _unmarshal: (handle: QuickJSHandle) => any;
     _register(t: any, h: QuickJSHandle, map?: VMMap, sync?: boolean): [Wrapped<any>, Wrapped<QuickJSHandle>] | undefined;
-    _syncMode(obj: any): "both" | undefined;
+    _syncMode: (obj: any) => "both" | undefined;
     _wrap<T>(target: T): Wrapped<T> | undefined;
     _unwrap<T>(target: T): T;
+    _unwrapIfNotSynced: <T>(target: T) => T;
     _wrapHandle(handle: QuickJSHandle): [Wrapped<QuickJSHandle> | undefined, boolean];
     _unwrapHandle(target: QuickJSHandle): [QuickJSHandle, boolean];
 }
+
+export declare function call(ctx: QuickJSContext, code: string, thisArg?: QuickJSHandle, ...args: QuickJSHandle[]): QuickJSHandle;
+
+/**
+ * Measure the complexity of an object as you traverse the field and prototype chain. If max is specified, when the complexity reaches max, the traversal is terminated and it returns the max. In this function, one object and function are counted as a complexity of 1, and primitives are not counted as a complexity.
+ */
+export declare function complexity(value: any, max?: number): number;
+
+export declare function consumeAll<T extends QuickJSHandle[], K>(handles: T, cb: (handles: T) => K): K;
+
+/**
+ * Default value of registeredObjects option of the Arena class constructor.
+ */
+export declare const defaultRegisteredObjects: [any, string][];
+
+export declare function eq(ctx: QuickJSContext, a: QuickJSHandle, b: QuickJSHandle): boolean;
+
+export declare function isES2015Class(cls: any): cls is new (...args: any[]) => any;
+
+export declare function isHandleObject(ctx: QuickJSContext, h: QuickJSHandle): boolean;
+
+export declare function isObject(value: any): value is object | Function;
+
+export declare function json(ctx: QuickJSContext, target: any): QuickJSHandle;
+
+export declare function marshal(target: unknown, options: Options_2): QuickJSHandle;
+
+export declare type Options = {
+    /** A callback that returns a boolean value that determines whether an object is marshalled or not. If false, no marshaling will be done and undefined will be passed to the QuickJS VM, otherwise marshaling will be done. By default, all objects will be marshalled. */
+    isMarshalable?: boolean | "json" | ((target: any) => boolean | "json");
+    /** You can pre-register a pair of objects that will be considered the same between the host and the QuickJS VM. This will be used automatically during the conversion. By default, it will be registered automatically with `defaultRegisteredObjects`.
+     *
+     * Instead of a string, you can also pass a QuickJSHandle directly. In that case, however, you have to dispose of them manually when destroying the VM.
+     */
+    registeredObjects?: Iterable<[any, QuickJSHandle | string]>;
+    /** Compatibility with quickjs-emscripten prior to v0.15. Inject code for compatibility into context at Arena class initialization time. */
+    compat?: boolean;
+};
+
+declare type Options_2 = {
+    ctx: QuickJSContext;
+    unmarshal: (handle: QuickJSHandle) => unknown;
+    isMarshalable?: (target: unknown) => boolean | "json";
+    find: (target: unknown) => QuickJSHandle | undefined;
+    pre: (target: unknown, handle: QuickJSHandle | QuickJSDeferredPromise, mode: true | "json" | undefined) => QuickJSHandle | undefined;
+    preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any;
+};
+
+declare type Options_3 = {
+    ctx: QuickJSContext;
+    /** marshal returns handle and boolean indicates that the handle should be disposed after use */
+    marshal: (target: unknown) => [QuickJSHandle, boolean];
+    find: (handle: QuickJSHandle) => unknown | undefined;
+    pre: <T = unknown>(target: T, handle: QuickJSHandle) => T | undefined;
+};
+
+export declare function unmarshal(handle: QuickJSHandle, options: Options_3): any;
+
+export declare class VMMap {
+    ctx: QuickJSContext;
+    _map1: Map<any, number>;
+    _map2: Map<any, number>;
+    _map3: Map<number, QuickJSHandle>;
+    _map4: Map<number, QuickJSHandle>;
+    _counterMap: Map<number, any>;
+    _disposables: Set<QuickJSHandle>;
+    _mapGet: QuickJSHandle;
+    _mapSet: QuickJSHandle;
+    _mapDelete: QuickJSHandle;
+    _mapClear: QuickJSHandle;
+    _counter: number;
+    constructor(ctx: QuickJSContext);
+    set(key: any, handle: QuickJSHandle, key2?: any, handle2?: QuickJSHandle): boolean;
+    merge(iteratable: Iterable<[any, QuickJSHandle | undefined] | [any, QuickJSHandle | undefined, any, QuickJSHandle | undefined]> | undefined): void;
+    get(key: any): QuickJSHandle | undefined;
+    getByHandle(handle: QuickJSHandle): any;
+    has(key: any): boolean;
+    hasHandle(handle: QuickJSHandle): boolean;
+    keys(): IterableIterator<any>;
+    delete(key: any, dispose?: boolean): void;
+    deleteByHandle(handle: QuickJSHandle, dispose?: boolean): void;
+    clear(): void;
+    dispose(): void;
+    get size(): number;
+    [Symbol.iterator](): Iterator<[
+    any,
+    QuickJSHandle,
+    any,
+    QuickJSHandle | undefined
+    ]>;
+    _get2(num: number): any;
+    _call(fn: QuickJSHandle, thisArg: QuickJSHandle | undefined, ...args: QuickJSHandle[]): QuickJSHandle;
+}
+
+export declare function walkObject(value: any, callback?: (target: any, set: Set<any>) => boolean | void): Set<any>;
+
+declare type Wrapped<T> = T & {
+    __qes_wrapped: never;
+};
+
+export { }