quickjs-emscripten-sync 1.3.0 → 1.5.1

package/src/unmarshal/custom.test.ts

@@ -0,0 +1,50 @@
+import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
+import unmarshalCustom, { defaultCustom } from "./custom";
+
+test("symbol", async () => {
+  const ctx = (await getQuickJS()).newContext();
+  const pre = vi.fn();
+  const obj = ctx.newObject();
+  const handle = ctx.unwrapResult(ctx.evalCode(`Symbol("foobar")`));
+
+  const unmarshal = (h: QuickJSHandle): any => unmarshalCustom(ctx, h, pre, defaultCustom);
+
+  expect(unmarshal(obj)).toBe(undefined);
+  expect(pre).toBeCalledTimes(0);
+
+  const sym = unmarshal(handle);
+  expect(typeof sym).toBe("symbol");
+  expect((sym as any).description).toBe("foobar");
+  expect(pre).toReturnTimes(1);
+  expect(pre.mock.calls[0][0]).toBe(sym);
+  expect(pre.mock.calls[0][1] === handle).toBe(true);
+
+  handle.dispose();
+  obj.dispose();
+  ctx.dispose();
+});
+
+test("date", async () => {
+  const ctx = (await getQuickJS()).newContext();
+  const pre = vi.fn();
+  const obj = ctx.newObject();
+  const handle = ctx.unwrapResult(ctx.evalCode(`new Date(2022, 7, 26)`));
+
+  const unmarshal = (h: QuickJSHandle): any => unmarshalCustom(ctx, h, pre, defaultCustom);
+
+  expect(unmarshal(obj)).toBe(undefined);
+  expect(pre).toBeCalledTimes(0);
+
+  const date = unmarshal(handle);
+  expect(date).toBeInstanceOf(Date);
+  expect(date.getTime()).toBe(new Date(2022, 7, 26).getTime());
+  expect(pre).toReturnTimes(1);
+  expect(pre.mock.calls[0][0]).toBe(date);
+  expect(pre.mock.calls[0][1] === handle).toBe(true);
+
+  handle.dispose();
+  obj.dispose();
+  ctx.dispose();
+});

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

@@ -2,19 +2,17 @@ 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 = vi.fn((v): [QuickJSHandle, boolean] => [json(vm, v), false]);
-  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
-    false,
-  ]);
-  const preUnmarshal = vi.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);
@@ -34,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 thatHandle = ctx.unwrapResult(ctx.evalCode(`({ a: 1 })`));
   const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
-    v === that ? thatHandle : json(vm, v),
+    v === that ? thatHandle : json(ctx, v),
     false,
   ]);
   const disposables: QuickJSHandle[] = [];
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+    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 = vi.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);
@@ -75,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 = vi.fn((v): [QuickJSHandle, boolean] => [
-    typeof v === "object" ? vm.undefined : json(vm, v),
+    typeof v === "object" ? ctx.undefined : json(ctx, v),
     false,
   ]);
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+    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 = vi.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);
@@ -125,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 ctx = (await getQuickJS()).newContext();
   const marshal = vi.fn((v): [QuickJSHandle, boolean] => [
-    typeof v === "object" ? vm.undefined : json(vm, v),
+    typeof v === "object" ? ctx.undefined : json(ctx, v),
     false,
   ]);
   const disposables: QuickJSHandle[] = [];
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
-    const ty = vm.typeof(v);
+    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 = vi.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);
@@ -174,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 ctx = (await getQuickJS()).newContext();
   const f = vi.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);
+  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 = 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 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,21 +1,22 @@
-import { Disposable, getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import VMMap from "../vmmap";
-import unmarshal from ".";
 import { json } from "../vmutil";
 
+import unmarshal from ".";
+
 test("primitive, array, object", async () => {
-  const { vm, unmarshal, marshal, map, dispose } = await setup();
+  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);
 
@@ -28,18 +29,13 @@ 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");
@@ -50,13 +46,13 @@ test("primitive, array, object", async () => {
 });
 
 test("object with symbol key", async () => {
-  const { vm, unmarshal, dispose } = await setup();
+  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);
 
@@ -67,11 +63,9 @@ test("object with symbol key", async () => {
 });
 
 test("function", async () => {
-  const { vm, unmarshal, marshal, map, dispose } = await setup();
+  const { ctx, unmarshal, marshal, map, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`(function(a) { return a.a + "!"; })`)
-  );
+  const handle = ctx.unwrapResult(ctx.evalCode(`(function(a) { return a.a + "!"; })`));
   const func = unmarshal(handle);
   const arg = { a: "hoge" };
   expect(func(arg)).toBe("hoge!");
@@ -88,18 +82,18 @@ test("function", async () => {
 });
 
 test("promise", async () => {
-  const { vm, unmarshal, dispose } = await setup();
+  const { ctx, unmarshal, dispose } = await setup();
 
-  const deferred = vm.newPromise();
+  const deferred = ctx.newPromise();
   const promise = unmarshal(deferred.handle);
-  deferred.resolve(vm.newString("resolved!"));
-  vm.executePendingJobs();
+  deferred.resolve(ctx.newString("resolved!"));
+  ctx.runtime.executePendingJobs();
   await expect(promise).resolves.toBe("resolved!");
 
-  const deferred2 = vm.newPromise();
+  const deferred2 = ctx.newPromise();
   const promise2 = unmarshal(deferred2.handle);
-  deferred2.reject(vm.newString("rejected!"));
-  vm.executePendingJobs();
+  deferred2.reject(ctx.newString("rejected!"));
+  ctx.runtime.executePendingJobs();
   await expect(promise2).rejects.toBe("rejected!");
 
   deferred.dispose();
@@ -108,10 +102,10 @@ test("promise", async () => {
 });
 
 test("class", async () => {
-  const { vm, unmarshal, dispose } = await setup();
+  const { ctx, unmarshal, dispose } = await setup();
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`{
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`{
       class Cls {
         static hoge = "foo";
 
@@ -122,24 +116,38 @@ test("class", async () => {
       Cls.foo = new Cls(1);
 
       Cls
-    }`)
+    }`),
   );
   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();
   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 vm = (await getQuickJS()).createVm();
-  const map = new VMMap(vm);
+  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);
@@ -147,33 +155,33 @@ const setup = async () => {
 
     const handle2 =
       typeof target === "function"
-        ? vm.newFunction(target.name, (...handles) => {
-            target(...handles.map((h) => vm.dump(h)));
+        ? ctx.newFunction(target.name, (...handles) => {
+            target(...handles.map(h => ctx.dump(h)));
           })
-        : json(vm, target);
-    const ty = vm.typeof(handle2);
+        : json(ctx, target);
+    const ty = ctx.typeof(handle2);
     if (ty === "object" || ty === "function") map.set(target, handle2);
     return [handle2, false];
   });
 
   return {
-    vm,
+    ctx,
     map,
     unmarshal: (handle: QuickJSHandle) =>
       unmarshal(handle, {
-        find: (h) => map.getByHandle(h),
+        find: h => map.getByHandle(h),
         marshal,
         pre: (t, h) => {
           map.set(t, h);
           return t;
         },
-        vm,
+        ctx: ctx,
       }),
     marshal,
     dispose: () => {
-      disposables.forEach((d) => d.dispose());
+      disposables.forEach(d => d.dispose());
       map.dispose();
-      vm.dispose();
+      ctx.dispose();
     },
   };
 };

package/src/unmarshal/index.ts

@@ -1,16 +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 unmarshalPromise from "./promise";
-import unmarshalSymbol from "./symbol";
 
 export type Options = {
-  vm: QuickJSVm;
+  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;
+  custom?: Iterable<(obj: QuickJSHandle, ctx: QuickJSContext) => any>;
 };
 
 export function unmarshal(handle: QuickJSHandle, options: Options): any {
@@ -18,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];
   }
 
@@ -39,10 +38,10 @@ function unmarshalInner(
   const unmarshal2 = (h: QuickJSHandle) => unmarshalInner(h, options);
 
   const result =
-    unmarshalSymbol(vm, handle, pre) ??
-    unmarshalPromise(vm, handle, marshal, 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];
 }