quickjs-emscripten-sync 1.2.0 → 1.5.0

package/src/unmarshal/custom.ts

@@ -0,0 +1,31 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
+import { call } from "../vmutil";
+
+export default function unmarshalCustom(
+  ctx: QuickJSContext,
+  handle: QuickJSHandle,
+  preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined,
+  custom: Iterable<(handle: QuickJSHandle, ctx: QuickJSContext) => any>,
+): symbol | undefined {
+  let obj: any;
+  for (const c of custom) {
+    obj = c(handle, ctx);
+    if (obj) break;
+  }
+  return obj ? preUnmarshal(obj, handle) ?? obj : undefined;
+}
+
+export function symbol(handle: QuickJSHandle, ctx: QuickJSContext): symbol | undefined {
+  if (ctx.typeof(handle) !== "symbol") return;
+  const desc = ctx.getString(ctx.getProp(handle, "description"));
+  return Symbol(desc);
+}
+
+export function date(handle: QuickJSHandle, ctx: QuickJSContext): Date | undefined {
+  if (!ctx.dump(call(ctx, "a => a instanceof Date", undefined, handle))) return;
+  const t = ctx.getNumber(call(ctx, "a => a.getTime()", undefined, handle));
+  return new Date(t);
+}
+
+export const defaultCustom = [symbol, date];

package/src/unmarshal/function.test.ts

@@ -1,21 +1,18 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import { json } from "../vmutil";
+
 import unmarshalFunction from "./function";
 
 test("arrow function", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn((v): [QuickJSHandle, boolean] => [
-    json(vm, v),
-    false,
-  ]);
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
-    false,
-  ]);
-  const preUnmarshal = jest.fn((a) => a);
+  const ctx = (await getQuickJS()).newContext();
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [json(ctx, v), false]);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [ctx.dump(v), false]);
+  const preUnmarshal = vi.fn(a => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`(a, b) => a + b`));
-  const func = unmarshalFunction(vm, handle, marshal, unmarshal, preUnmarshal);
+  const handle = ctx.unwrapResult(ctx.evalCode(`(a, b) => a + b`));
+  const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
   if (!func) throw new Error("func is undefined");
 
   expect(func(1, 2)).toBe(3);
@@ -35,30 +32,28 @@ test("arrow function", async () => {
   handle.dispose();
   expect(() => func(1, 2)).toThrow("Lifetime not alive");
 
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("function", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const that = { a: 1 };
-  const thatHandle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
-  const marshal = jest.fn((v): [QuickJSHandle, boolean] => [
-    v === that ? thatHandle : json(vm, v),
+  const thatHandle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
+    v === that ? thatHandle : json(ctx, v),
     false,
   ]);
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
+    const ty = ctx.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
-    return [vm.dump(v), false];
+    return [ctx.dump(v), false];
   });
-  const preUnmarshal = jest.fn((a) => a);
+  const preUnmarshal = vi.fn(a => a);
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function (a) { return this.a + a; })`)
-  );
+  const handle = ctx.unwrapResult(ctx.evalCode(`(function (a) { return this.a + a; })`));
 
-  const func = unmarshalFunction(vm, handle, marshal, unmarshal, preUnmarshal);
+  const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
   if (!func) throw new Error("func is undefined");
 
   expect(func.call(that, 2)).toBe(3);
@@ -76,37 +71,29 @@ test("function", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(func, handle);
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   thatHandle.dispose();
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("constructor", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn((v): [QuickJSHandle, boolean] => [
-    typeof v === "object" ? vm.undefined : json(vm, v),
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
+    typeof v === "object" ? ctx.undefined : json(ctx, v),
     false,
   ]);
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
+    const ty = ctx.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
-    return [vm.dump(v), false];
+    return [ctx.dump(v), false];
   });
-  const preUnmarshal = jest.fn((a) => a);
-
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function (b) { this.a = b + 2; })`)
-  );
-
-  const Cls = unmarshalFunction(
-    vm,
-    handle,
-    marshal,
-    unmarshal,
-    preUnmarshal
-  ) as any;
+  const preUnmarshal = vi.fn(a => a);
+
+  const handle = ctx.unwrapResult(ctx.evalCode(`(function (b) { this.a = b + 2; })`));
+
+  const Cls = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal) as any;
   if (!Cls) throw new Error("Cls is undefined");
 
   const instance = new Cls(100);
@@ -126,36 +113,28 @@ test("constructor", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(Cls, handle);
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("class", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn((v): [QuickJSHandle, boolean] => [
-    typeof v === "object" ? vm.undefined : json(vm, v),
+  const ctx = (await getQuickJS()).newContext();
+  const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
+    typeof v === "object" ? ctx.undefined : json(ctx, v),
     false,
   ]);
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
+    const ty = ctx.typeof(v);
     if (ty === "object" || ty === "function") disposables.push(v);
-    return [vm.dump(v), false];
+    return [ctx.dump(v), false];
   });
-  const preUnmarshal = jest.fn((a) => a);
-
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(class A { constructor(a) { this.a = a + 1; } })`)
-  );
-
-  const Cls = unmarshalFunction(
-    vm,
-    handle,
-    marshal,
-    unmarshal,
-    preUnmarshal
-  ) as any;
+  const preUnmarshal = vi.fn(a => a);
+
+  const handle = ctx.unwrapResult(ctx.evalCode(`(class A { constructor(a) { this.a = a + 1; } })`));
+
+  const Cls = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal) as any;
   if (!Cls) throw new Error("Cls is undefined");
 
   const instance = new Cls(2);
@@ -175,32 +154,30 @@ test("class", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(Cls, handle);
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("undefined", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const f = jest.fn();
-
-  expect(unmarshalFunction(vm, vm.undefined, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.true, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.false, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.null, f, f, f)).toEqual(undefined);
-  expect(unmarshalFunction(vm, vm.newString("hoge"), f, f, f)).toEqual(
-    undefined
-  );
-  expect(unmarshalFunction(vm, vm.newNumber(-10), f, f, f)).toEqual(undefined);
-
-  const obj = vm.newObject();
-  expect(unmarshalFunction(vm, obj, f, f, f)).toEqual(undefined);
-  const array = vm.newArray();
-  expect(unmarshalFunction(vm, array, f, f, f)).toEqual(undefined);
+  const ctx = (await getQuickJS()).newContext();
+  const f = vi.fn();
+
+  expect(unmarshalFunction(ctx, ctx.undefined, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.true, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.false, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.null, f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.newString("hoge"), f, f, f)).toEqual(undefined);
+  expect(unmarshalFunction(ctx, ctx.newNumber(-10), f, f, f)).toEqual(undefined);
+
+  const obj = ctx.newObject();
+  expect(unmarshalFunction(ctx, obj, f, f, f)).toEqual(undefined);
+  const array = ctx.newArray();
+  expect(unmarshalFunction(ctx, array, f, f, f)).toEqual(undefined);
 
   expect(f).toBeCalledTimes(0);
 
   obj.dispose();
   array.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/function.ts

@@ -1,52 +1,43 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call, mayConsumeAll } from "../vmutil";
+
 import unmarshalProperties from "./properties";
 
 export default function unmarshalFunction(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
-  // marshal returns handle and boolean indicates that the handle should be disposed after use
+  /** marshal returns handle and boolean indicates that the handle should be disposed after use */
   marshal: (value: unknown) => [QuickJSHandle, boolean],
   unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
-  preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
+  preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined,
 ): Function | undefined {
-  if (vm.typeof(handle) !== "function") return;
+  if (ctx.typeof(handle) !== "function") return;
 
   const raw = function (this: any, ...args: any[]) {
     return mayConsumeAll(
-      [marshal(this), ...args.map((a) => marshal(a))],
+      [marshal(this), ...args.map(a => marshal(a))],
       (thisHandle, ...argHandles) => {
         if (new.target) {
           const [instance] = unmarshal(
-            call(
-              vm,
-              `(Cls, ...args) => new Cls(...args)`,
-              thisHandle,
-              handle,
-              ...argHandles
-            )
-          );
-          Object.defineProperties(
-            this,
-            Object.getOwnPropertyDescriptors(instance)
+            call(ctx, `(Cls, ...args) => new Cls(...args)`, thisHandle, handle, ...argHandles),
           );
+          Object.defineProperties(this, Object.getOwnPropertyDescriptors(instance));
           return this;
         }
 
-        const resultHandle = vm.unwrapResult(
-          vm.callFunction(handle, thisHandle, ...argHandles)
-        );
+        const resultHandle = ctx.unwrapResult(ctx.callFunction(handle, thisHandle, ...argHandles));
 
         const [result, alreadyExists] = unmarshal(resultHandle);
         if (alreadyExists) resultHandle.dispose();
 
         return result;
-      }
+      },
     );
   };
 
   const func = preUnmarshal(raw, handle) ?? raw;
-  unmarshalProperties(vm, handle, raw, unmarshal);
+  unmarshalProperties(ctx, handle, raw, unmarshal);
 
   return func;
 }

package/src/unmarshal/index.test.ts

@@ -1,30 +1,24 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import VMMap from "../vmmap";
+import { json } from "../vmutil";
+
 import unmarshal from ".";
 
 test("primitive, array, object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn((): [QuickJSHandle, boolean] => [
-    vm.undefined,
-    false,
-  ]);
-  const map = new VMMap(vm);
-  const find = jest.fn((h) => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
+  const { ctx, unmarshal, marshal, map, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`({
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`({
       hoge: "foo",
       foo: 1,
       aaa: [1, true, {}],
       nested: { aa: null, hoge: undefined },
       bbb: () => "bar"
-    })`)
+    })`),
   );
-  const target = unmarshal(handle, { vm, pre, find, marshal });
+  const target = unmarshal(handle);
 
   expect(target).toEqual({
     hoge: "foo",
@@ -35,119 +29,83 @@ test("primitive, array, object", async () => {
   });
   expect(map.size).toBe(5);
   expect(map.getByHandle(handle)).toBe(target);
-  vm.getProp(handle, "aaa").consume((h) =>
-    expect(map.getByHandle(h)).toBe(target.aaa)
-  );
-  vm.getProp(handle, "aaa")
-    .consume((h) => vm.getProp(h, 2))
-    .consume((h) => expect(map.getByHandle(h)).toBe(target.aaa[2]));
-  vm.getProp(handle, "nested").consume((h) =>
-    expect(map.getByHandle(h)).toBe(target.nested)
-  );
-  vm.getProp(handle, "bbb").consume((h) =>
-    expect(map.getByHandle(h)).toBe(target.bbb)
-  );
+  ctx.getProp(handle, "aaa").consume(h => expect(map.getByHandle(h)).toBe(target.aaa));
+  ctx
+    .getProp(handle, "aaa")
+    .consume(h => ctx.getProp(h, 2))
+    .consume(h => expect(map.getByHandle(h)).toBe(target.aaa[2]));
+  ctx.getProp(handle, "nested").consume(h => expect(map.getByHandle(h)).toBe(target.nested));
+  ctx.getProp(handle, "bbb").consume(h => expect(map.getByHandle(h)).toBe(target.bbb));
 
   expect(marshal).toBeCalledTimes(0);
   expect(target.bbb()).toBe("bar");
   expect(marshal).toBeCalledTimes(1);
   expect(marshal).toBeCalledWith(target); // thisArg of target.bbb()
 
-  handle.dispose();
-  map.dispose();
-  vm.dispose();
+  dispose();
 });
 
 test("object with symbol key", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const map = new VMMap(vm);
-  const pre = (t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  };
+  const { ctx, unmarshal, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`({
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`({
       hoge: "foo",
       [Symbol("a")]: "bar"
-    })`)
+    })`),
   );
-  const target = unmarshal(handle, {
-    vm,
-    pre,
-    find: () => undefined,
-    marshal: () => [vm.undefined, false],
-  });
+  const target = unmarshal(handle);
 
   expect(target.hoge).toBe("foo");
   expect(target[Object.getOwnPropertySymbols(target)[0]]).toBe("bar");
 
-  handle.dispose();
-  map.dispose();
-  vm.dispose();
+  dispose();
 });
 
-test("func", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const jsonParse = vm.unwrapResult(vm.evalCode(`JSON.parse`));
-  const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn((t: unknown): [QuickJSHandle, boolean] => {
-    const h =
-      t === undefined
-        ? vm.undefined
-        : vm.unwrapResult(
-            vm.callFunction(
-              jsonParse,
-              vm.undefined,
-              vm.newString(JSON.stringify(t))
-            )
-          );
-    const ty = vm.typeof(h);
-    if (ty === "object" || ty === "function") disposables.push(h);
-    return [h, false];
-  });
+test("function", async () => {
+  const { ctx, unmarshal, marshal, map, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function(a) { return a.a + "!"; })`)
-  );
-  const map = new VMMap(vm);
-  const find = jest.fn((h) => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
-  const func = unmarshal(handle, { vm, find, pre, marshal });
+  const handle = ctx.unwrapResult(ctx.evalCode(`(function(a) { return a.a + "!"; })`));
+  const func = unmarshal(handle);
   const arg = { a: "hoge" };
   expect(func(arg)).toBe("hoge!");
   expect(marshal).toBeCalledTimes(2);
   expect(marshal).toBeCalledWith(undefined); // this
   expect(marshal).toBeCalledWith(arg); // arg
-  expect(map.size).toBe(2);
+  expect(map.size).toBe(3);
   expect(map.getByHandle(handle)).toBe(func);
+  expect(map.has(func)).toBe(true);
   expect(map.has(func.prototype)).toBe(true);
+  expect(map.has(arg)).toBe(true);
 
-  map.dispose();
-  disposables.forEach((d) => d.dispose());
-  jsonParse.dispose();
-  vm.dispose();
+  dispose();
+});
+
+test("promise", async () => {
+  const { ctx, unmarshal, dispose } = await setup();
+
+  const deferred = ctx.newPromise();
+  const promise = unmarshal(deferred.handle);
+  deferred.resolve(ctx.newString("resolved!"));
+  ctx.runtime.executePendingJobs();
+  await expect(promise).resolves.toBe("resolved!");
+
+  const deferred2 = ctx.newPromise();
+  const promise2 = unmarshal(deferred2.handle);
+  deferred2.reject(ctx.newString("rejected!"));
+  ctx.runtime.executePendingJobs();
+  await expect(promise2).rejects.toBe("rejected!");
+
+  deferred.dispose();
+  deferred2.dispose();
+  dispose();
 });
 
 test("class", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const jsonParse = vm.unwrapResult(vm.evalCode(`JSON.parse`));
-  const disposables: QuickJSHandle[] = [];
-  const map = new VMMap(vm);
-  const marshal = jest.fn((t: unknown): [QuickJSHandle, boolean] => {
-    const h = vm.unwrapResult(
-      vm.callFunction(jsonParse, vm.undefined, vm.newString(JSON.stringify(t)))
-    );
-    const ty = vm.typeof(h);
-    if (ty === "object" || ty === "function") disposables.push(h);
-    return [h, false];
-  });
+  const { ctx, unmarshal, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`{
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`{
       class Cls {
         static hoge = "foo";
 
@@ -158,25 +116,72 @@ test("class", async () => {
       Cls.foo = new Cls(1);
 
       Cls
-    }`)
+    }`),
   );
-  const find = jest.fn((h) => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
-  const Cls = unmarshal(handle, { vm, find, pre, marshal });
+  const Cls = unmarshal(handle);
 
   expect(Cls.hoge).toBe("foo");
-  expect(Cls.foo instanceof Cls).toBe(true);
+  expect(Cls.foo).toBeInstanceOf(Cls);
   expect(Cls.foo.foo).toBe(3);
   const cls = new Cls(2);
-  expect(cls instanceof Cls).toBe(true);
+  expect(cls).toBeInstanceOf(Cls);
   expect(cls.foo).toBe(4);
 
   handle.dispose();
-  map.dispose();
-  disposables.forEach((d) => d.dispose());
-  jsonParse.dispose();
-  vm.dispose();
+  dispose();
+});
+
+test("date", async () => {
+  const { ctx, unmarshal, dispose } = await setup();
+
+  const handle = ctx.unwrapResult(ctx.evalCode("new Date(2022, 7, 26)"));
+  const date = unmarshal(handle);
+  const expected = new Date(2022, 7, 26);
+
+  expect(date).toBeInstanceOf(Date);
+  expect(date.getTime()).toBe(expected.getTime());
+
+  handle.dispose();
+  dispose();
 });
+
+const setup = async () => {
+  const ctx = (await getQuickJS()).newContext();
+  const map = new VMMap(ctx);
+  const disposables: QuickJSHandle[] = [];
+  const marshal = vi.fn((target: unknown): [QuickJSHandle, boolean] => {
+    const handle = map.get(target);
+    if (handle) return [handle, false];
+
+    const handle2 =
+      typeof target === "function"
+        ? ctx.newFunction(target.name, (...handles) => {
+            target(...handles.map(h => ctx.dump(h)));
+          })
+        : json(ctx, target);
+    const ty = ctx.typeof(handle2);
+    if (ty === "object" || ty === "function") map.set(target, handle2);
+    return [handle2, false];
+  });
+
+  return {
+    ctx,
+    map,
+    unmarshal: (handle: QuickJSHandle) =>
+      unmarshal(handle, {
+        find: h => map.getByHandle(h),
+        marshal,
+        pre: (t, h) => {
+          map.set(t, h);
+          return t;
+        },
+        ctx: ctx,
+      }),
+    marshal,
+    dispose: () => {
+      disposables.forEach(d => d.dispose());
+      map.dispose();
+      ctx.dispose();
+    },
+  };
+};

package/src/unmarshal/index.ts

@@ -1,15 +1,18 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
+import unmarshalCustom, { defaultCustom } from "./custom";
 import unmarshalFunction from "./function";
 import unmarshalObject from "./object";
 import unmarshalPrimitive from "./primitive";
-import unmarshalSymbol from "./symbol";
+import unmarshalPromise from "./promise";
 
 export type Options = {
-  vm: QuickJSVm;
-  // marshal returns handle and boolean indicates that the handle should be disposed after use
+  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>(target: T, handle: QuickJSHandle) => T | undefined;
+  pre: <T = unknown>(target: T, handle: QuickJSHandle) => T | undefined;
+  custom?: Iterable<(obj: QuickJSHandle, ctx: QuickJSContext) => any>;
 };
 
 export function unmarshal(handle: QuickJSHandle, options: Options): any {
@@ -17,14 +20,11 @@ export function unmarshal(handle: QuickJSHandle, options: Options): any {
   return result;
 }
 
-function unmarshalInner(
-  handle: QuickJSHandle,
-  options: Options
-): [any, boolean] {
-  const { vm, marshal, find, pre } = options;
+function unmarshalInner(handle: QuickJSHandle, options: Options): [any, boolean] {
+  const { ctx, marshal, find, pre } = options;
 
   {
-    const [target, ok] = unmarshalPrimitive(vm, handle);
+    const [target, ok] = unmarshalPrimitive(ctx, handle);
     if (ok) return [target, false];
   }
 
@@ -38,9 +38,10 @@ function unmarshalInner(
   const unmarshal2 = (h: QuickJSHandle) => unmarshalInner(h, options);
 
   const result =
-    unmarshalSymbol(vm, handle, pre) ??
-    unmarshalFunction(vm, handle, marshal, unmarshal2, pre) ??
-    unmarshalObject(vm, handle, unmarshal2, pre);
+    unmarshalCustom(ctx, handle, pre, [...defaultCustom, ...(options.custom ?? [])]) ??
+    unmarshalPromise(ctx, handle, marshal, pre) ??
+    unmarshalFunction(ctx, handle, marshal, unmarshal2, pre) ??
+    unmarshalObject(ctx, handle, unmarshal2, pre);
 
   return [result, false];
 }