quickjs-emscripten-sync 1.2.0 → 1.5.0

package/src/marshal/object.test.ts

@@ -1,70 +1,65 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import { call } from "../vmutil";
+
 import marshalObject from "./object";
 
 test("empty object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const prototypeCheck = vm.unwrapResult(
-    vm.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+  const ctx = (await getQuickJS()).newContext();
+  const prototypeCheck = ctx.unwrapResult(
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`),
   );
 
   const obj = {};
-  const marshal = jest.fn();
-  const preMarshal = jest.fn((_, a) => a);
+  const marshal = vi.fn();
+  const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalObject(vm, obj, marshal, preMarshal);
+  const handle = marshalObject(ctx, obj, marshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
+  expect(ctx.typeof(handle)).toBe("object");
   expect(marshal).toBeCalledTimes(0);
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    vm.dump(
-      vm.unwrapResult(vm.callFunction(prototypeCheck, vm.undefined, handle))
-    )
-  ).toBe(true);
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle)))).toBe(
+    true,
+  );
 
   handle.dispose();
   prototypeCheck.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("normal object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const prototypeCheck = vm.unwrapResult(
-    vm.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+  const ctx = (await getQuickJS()).newContext();
+  const prototypeCheck = ctx.unwrapResult(
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`),
   );
-  const entries = vm.unwrapResult(vm.evalCode(`Object.entries`));
+  const entries = ctx.unwrapResult(ctx.evalCode(`Object.entries`));
 
   const obj = { a: 100, b: "hoge" };
-  const marshal = jest.fn((v) =>
-    typeof v === "number"
-      ? vm.newNumber(v)
-      : typeof v === "string"
-      ? vm.newString(v)
-      : vm.null
+  const marshal = vi.fn(v =>
+    typeof v === "number" ? ctx.newNumber(v) : typeof v === "string" ? ctx.newString(v) : ctx.null,
   );
-  const preMarshal = jest.fn((_, a) => a);
+  const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalObject(vm, obj, marshal, preMarshal);
+  const handle = marshalObject(ctx, obj, marshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
-  expect(vm.getNumber(vm.getProp(handle, "a"))).toBe(100);
-  expect(vm.getString(vm.getProp(handle, "b"))).toBe("hoge");
+  expect(ctx.typeof(handle)).toBe("object");
+  expect(ctx.getNumber(ctx.getProp(handle, "a"))).toBe(100);
+  expect(ctx.getString(ctx.getProp(handle, "b"))).toBe("hoge");
   expect(marshal.mock.calls).toEqual([["a"], [100], ["b"], ["hoge"]]);
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    vm.dump(
-      vm.unwrapResult(vm.callFunction(prototypeCheck, vm.undefined, handle))
-    )
-  ).toBe(true);
-  const e = vm.unwrapResult(vm.callFunction(entries, vm.undefined, handle));
-  expect(vm.dump(e)).toEqual([
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle)))).toBe(
+    true,
+  );
+  const e = ctx.unwrapResult(ctx.callFunction(entries, ctx.undefined, handle));
+  expect(ctx.dump(e)).toEqual([
     ["a", 100],
     ["b", "hoge"],
   ]);
@@ -73,89 +68,69 @@ test("normal object", async () => {
   handle.dispose();
   prototypeCheck.dispose();
   entries.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("array", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const isArray = vm.unwrapResult(vm.evalCode(`Array.isArray`));
+  const ctx = (await getQuickJS()).newContext();
+  const isArray = ctx.unwrapResult(ctx.evalCode(`Array.isArray`));
 
   const array = [1, "aa"];
-  const marshal = jest.fn((v) =>
-    typeof v === "number"
-      ? vm.newNumber(v)
-      : typeof v === "string"
-      ? vm.newString(v)
-      : vm.null
+  const marshal = vi.fn(v =>
+    typeof v === "number" ? ctx.newNumber(v) : typeof v === "string" ? ctx.newString(v) : ctx.null,
   );
-  const preMarshal = jest.fn((_, a) => a);
+  const preMarshal = vi.fn((_, a) => a);
 
-  const handle = marshalObject(vm, array, marshal, preMarshal);
+  const handle = marshalObject(ctx, array, marshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
-  expect(vm.typeof(handle)).toBe("object");
-  expect(vm.getNumber(vm.getProp(handle, 0))).toBe(1);
-  expect(vm.getString(vm.getProp(handle, 1))).toBe("aa");
-  expect(vm.getNumber(vm.getProp(handle, "length"))).toBe(2);
-  expect(marshal.mock.calls).toEqual([
-    ["0"],
-    [1],
-    ["1"],
-    ["aa"],
-    ["length"],
-    [2],
-  ]);
+  expect(ctx.typeof(handle)).toBe("object");
+  expect(ctx.getNumber(ctx.getProp(handle, 0))).toBe(1);
+  expect(ctx.getString(ctx.getProp(handle, 1))).toBe("aa");
+  expect(ctx.getNumber(ctx.getProp(handle, "length"))).toBe(2);
+  expect(marshal.mock.calls).toEqual([["0"], [1], ["1"], ["aa"], ["length"], [2]]);
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(array);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    vm.dump(vm.unwrapResult(vm.callFunction(isArray, vm.undefined, handle)))
-  ).toBe(true);
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(isArray, ctx.undefined, handle)))).toBe(true);
 
   handle.dispose();
   isArray.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("prototype", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
   const proto = { a: 100 };
-  const protoHandle = vm.newObject();
-  vm.setProp(protoHandle, "a", vm.newNumber(100));
-  const preMarshal = jest.fn((_, a) => a);
+  const protoHandle = ctx.newObject();
+  ctx.setProp(protoHandle, "a", ctx.newNumber(100));
+  const preMarshal = vi.fn((_, a) => a);
 
   const obj = Object.create(proto);
   obj.b = "hoge";
   const handle = marshalObject(
-    vm,
+    ctx,
     obj,
-    (v) =>
-      v === proto
-        ? protoHandle
-        : typeof v === "string"
-        ? vm.newString(v)
-        : vm.null,
-    preMarshal
+    v => (v === proto ? protoHandle : typeof v === "string" ? ctx.newString(v) : ctx.null),
+    preMarshal,
   );
   if (!handle) throw new Error("handle is undefined");
 
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(vm.typeof(handle)).toBe("object");
-  expect(vm.getNumber(vm.getProp(handle, "a"))).toBe(100);
-  expect(vm.getString(vm.getProp(handle, "b"))).toBe("hoge");
-  const e = call(vm, "Object.entries", undefined, handle);
-  expect(vm.dump(e)).toEqual([["b", "hoge"]]);
-  const protoHandle2 = call(vm, "Object.getPrototypeOf", vm.undefined, handle);
-  expect(
-    vm.dump(call(vm, `Object.is`, undefined, protoHandle, protoHandle2))
-  ).toBe(true);
+  expect(ctx.typeof(handle)).toBe("object");
+  expect(ctx.getNumber(ctx.getProp(handle, "a"))).toBe(100);
+  expect(ctx.getString(ctx.getProp(handle, "b"))).toBe("hoge");
+  const e = call(ctx, "Object.entries", undefined, handle);
+  expect(ctx.dump(e)).toEqual([["b", "hoge"]]);
+  const protoHandle2 = call(ctx, "Object.getPrototypeOf", ctx.undefined, handle);
+  expect(ctx.dump(call(ctx, `Object.is`, undefined, protoHandle, protoHandle2))).toBe(true);
 
   protoHandle2.dispose();
   e.dispose();
   handle.dispose();
   protoHandle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/object.ts

@@ -1,19 +1,18 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call } from "../vmutil";
+
 import marshalProperties from "./properties";
 
 export default function marshalObject(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: unknown,
   marshal: (target: unknown) => QuickJSHandle,
-  preMarshal: (
-    target: unknown,
-    handle: QuickJSHandle
-  ) => QuickJSHandle | undefined
+  preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined,
 ): QuickJSHandle | undefined {
   if (typeof target !== "object" || target === null) return;
 
-  const raw = Array.isArray(target) ? vm.newArray() : vm.newObject();
+  const raw = Array.isArray(target) ? ctx.newArray() : ctx.newObject();
   const handle = preMarshal(target, raw) ?? raw;
 
   // prototype
@@ -23,16 +22,10 @@ export default function marshalObject(
       ? marshal(prototype)
       : undefined;
   if (prototypeHandle) {
-    call(
-      vm,
-      "Object.setPrototypeOf",
-      undefined,
-      handle,
-      prototypeHandle
-    ).dispose();
+    call(ctx, "Object.setPrototypeOf", undefined, handle, prototypeHandle).dispose();
   }
 
-  marshalProperties(vm, target, raw, marshal);
+  marshalProperties(ctx, target, raw, marshal);
 
   return handle;
 }

package/src/marshal/primitive.test.ts

@@ -1,34 +1,31 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test } from "vitest";
+
 import { eq } from "../vmutil";
+
 import marshalPrimitive from "./primitive";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  expect(marshalPrimitive(vm, undefined)).toBe(vm.undefined);
-  expect(marshalPrimitive(vm, null)).toBe(vm.null);
-  expect(marshalPrimitive(vm, false)).toBe(vm.false);
-  expect(marshalPrimitive(vm, true)).toBe(vm.true);
-  expect(eq(vm, marshalPrimitive(vm, 1) ?? vm.undefined, vm.newNumber(1))).toBe(
-    true
-  );
-  expect(
-    eq(vm, marshalPrimitive(vm, -100) ?? vm.undefined, vm.newNumber(-100))
-  ).toBe(true);
-  expect(
-    eq(vm, marshalPrimitive(vm, "hoge") ?? vm.undefined, vm.newString("hoge"))
-  ).toBe(true);
+  expect(marshalPrimitive(ctx, undefined)).toBe(ctx.undefined);
+  expect(marshalPrimitive(ctx, null)).toBe(ctx.null);
+  expect(marshalPrimitive(ctx, false)).toBe(ctx.false);
+  expect(marshalPrimitive(ctx, true)).toBe(ctx.true);
+  expect(eq(ctx, marshalPrimitive(ctx, 1) ?? ctx.undefined, ctx.newNumber(1))).toBe(true);
+  expect(eq(ctx, marshalPrimitive(ctx, -100) ?? ctx.undefined, ctx.newNumber(-100))).toBe(true);
+  expect(eq(ctx, marshalPrimitive(ctx, "hoge") ?? ctx.undefined, ctx.newString("hoge"))).toBe(true);
   // expect(
   //   eq(
-  //     vm,
-  //     marshalPrimitive(vm, BigInt(1)) ?? vm.undefined,
-  //     vm.unwrapResult(vm.evalCode("BigInt(1)"))
+  //     ctx,
+  //     marshalPrimitive(ctx, BigInt(1)) ?? ctx.undefined,
+  //     ctx.unwrapResult(ctx.evalCode("BigInt(1)"))
   //   )
   // ).toBe(true);
 
-  expect(marshalPrimitive(vm, () => {})).toBe(undefined);
-  expect(marshalPrimitive(vm, [])).toBe(undefined);
-  expect(marshalPrimitive(vm, {})).toBe(undefined);
+  expect(marshalPrimitive(ctx, () => {})).toBe(undefined);
+  expect(marshalPrimitive(ctx, [])).toBe(undefined);
+  expect(marshalPrimitive(ctx, {})).toBe(undefined);
 
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/primitive.ts

@@ -1,29 +1,30 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 // import { call } from "../vmutil";
 
 export default function marshalPrimitive(
-  vm: QuickJSVm,
-  target: unknown
+  ctx: QuickJSContext,
+  target: unknown,
 ): QuickJSHandle | undefined {
   switch (typeof target) {
     case "undefined":
-      return vm.undefined;
+      return ctx.undefined;
     case "number":
-      return vm.newNumber(target);
+      return ctx.newNumber(target);
     case "string":
-      return vm.newString(target);
+      return ctx.newString(target);
     case "boolean":
-      return target ? vm.true : vm.false;
+      return target ? ctx.true : ctx.false;
     case "object":
-      return target === null ? vm.null : undefined;
+      return target === null ? ctx.null : undefined;
 
     // BigInt is not supported by quickjs-emscripten
     // case "bigint":
     //   return call(
-    //     vm,
+    //     ctx,
     //     `s => BigInt(s)`,
     //     undefined,
-    //     vm.newString(target.toString())
+    //     ctx.newString(target.toString())
     //   );
   }
 

package/src/marshal/promise.test.ts

@@ -0,0 +1,85 @@
+import {
+  getQuickJS,
+  type Disposable,
+  type QuickJSDeferredPromise,
+  type QuickJSHandle,
+} from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
+import { newDeferred } from "../util";
+import { fn, json } from "../vmutil";
+
+import marshalPromise from "./promise";
+
+const testPromise = (reject: boolean) => async () => {
+  const ctx = (await getQuickJS()).newContext();
+
+  const disposables: Disposable[] = [];
+  const marshal = vi.fn(v => {
+    const handle = json(ctx, v);
+    disposables.push(handle);
+    return handle;
+  });
+  const preMarshal = vi.fn((_: any, a: QuickJSDeferredPromise): QuickJSHandle => {
+    disposables.push(a);
+    return a.handle;
+  });
+
+  const mockNotify = vi.fn();
+  const notify = ctx.newFunction("notify", (handle1, handle2) => {
+    const arg1 = ctx.dump(handle1);
+    const arg2 = ctx.dump(handle2);
+    mockNotify(arg1, arg2);
+  });
+  disposables.push(notify);
+
+  const notifier = fn(
+    ctx,
+    `(notify, promise) => { promise.then(d => notify("resolved", d), d => notify("rejected", d)); }`,
+  );
+  disposables.push(notifier);
+
+  const deferred = newDeferred();
+  if (reject) {
+    deferred.promise.catch(() => {});
+  }
+  const handle = marshalPromise(ctx, deferred.promise, marshal, preMarshal);
+  if (!handle) throw new Error("handle is undefined");
+
+  expect(marshal).toBeCalledTimes(0);
+  expect(preMarshal).toBeCalledTimes(1);
+  expect(preMarshal.mock.calls[0][0]).toBe(deferred.promise);
+  expect(preMarshal.mock.calls[0][1].handle).toBe(handle);
+
+  notifier(undefined, notify, handle);
+
+  expect(mockNotify).toBeCalledTimes(0);
+  expect(deferred.resolve).not.toBeUndefined();
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
+
+  if (reject) {
+    deferred.reject("hoge");
+  } else {
+    deferred.resolve("hoge");
+  }
+
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
+  if (reject) {
+    await expect(deferred.promise).rejects.toBe("hoge");
+  } else {
+    await expect(deferred.promise).resolves.toBe("hoge");
+  }
+  expect(ctx.runtime.hasPendingJob()).toBe(true);
+  const executed = ctx.unwrapResult(ctx.runtime.executePendingJobs());
+  expect(executed).toBe(1);
+  expect(mockNotify).toBeCalledTimes(1);
+  expect(mockNotify).toBeCalledWith(reject ? "rejected" : "resolved", "hoge");
+  expect(marshal).toBeCalledTimes(1);
+  expect(marshal.mock.calls).toEqual([["hoge"]]);
+
+  disposables.forEach(h => h.dispose());
+  ctx.dispose();
+};
+
+test("resolve", testPromise(false));
+test("reject", testPromise(true));

package/src/marshal/promise.ts

@@ -0,0 +1,19 @@
+import type { QuickJSDeferredPromise, QuickJSHandle, QuickJSContext } from "quickjs-emscripten";
+
+export default function marshalPromise(
+  ctx: QuickJSContext,
+  target: unknown,
+  marshal: (target: unknown) => QuickJSHandle,
+  preMarshal: (target: unknown, handle: QuickJSDeferredPromise) => QuickJSHandle | undefined,
+) {
+  if (!(target instanceof Promise)) return;
+
+  const promise = ctx.newPromise();
+
+  target.then(
+    d => promise.resolve(marshal(d)),
+    d => promise.reject(marshal(d)),
+  );
+
+  return preMarshal(target, promise) ?? promise.handle;
+}

package/src/marshal/properties.test.ts

@@ -1,11 +1,14 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import { json } from "../vmutil";
+
 import marshalProperties from "./properties";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const descTester = vm.unwrapResult(
-    vm.evalCode(`(obj, expected) => {
+  const ctx = (await getQuickJS()).newContext();
+  const descTester = ctx.unwrapResult(
+    ctx.evalCode(`(obj, expected) => {
       const descs = Object.getOwnPropertyDescriptors(obj);
       for (const [k, v] of Object.entries(expected)) {
         const d = descs[k];
@@ -16,18 +19,18 @@ test("works", async () => {
         if (typeof v.configurable === "boolean" && d.configurable !== v.configurable) throw new Error(k + " configurable invalid: " + d.configurable);
         if (typeof v.writable === "boolean" && d.writable !== v.writable) throw new Error(k + " writable invalid: " + d.writable);
       }
-    }`)
+    }`),
   );
 
   const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn((t) => {
-    if (typeof t !== "function") return json(vm, t);
-    const fn = vm.newFunction("", () => {});
+  const marshal = vi.fn(t => {
+    if (typeof t !== "function") return json(ctx, t);
+    const fn = ctx.newFunction("", () => {});
     disposables.push(fn);
     return fn;
   });
 
-  const handle = vm.newObject();
+  const handle = ctx.newObject();
   const obj = {};
   const bar = () => {};
   const fooGet = () => {};
@@ -47,39 +50,33 @@ test("works", async () => {
     },
   });
 
-  marshalProperties(vm, obj, handle, marshal);
-  expect(marshal.mock.calls).toEqual([
-    ["bar"],
-    [bar],
-    ["foo"],
-    [fooGet],
-    [fooSet],
-  ]);
+  marshalProperties(ctx, obj, handle, marshal);
+  expect(marshal.mock.calls).toEqual([["bar"], [bar], ["foo"], [fooGet], [fooSet]]);
 
-  const expected = vm.unwrapResult(
-    vm.evalCode(`({
+  const expected = ctx.unwrapResult(
+    ctx.evalCode(`({
       bar: { valueType: "function", getType: "undefined", setType: "undefined", enumerable: true, configurable: true, writable: true },
       foo: { valueType: "undefined", getType: "function", setType: "function", enumerable: false, configurable: true }
-    })`)
+    })`),
   );
-  vm.unwrapResult(vm.callFunction(descTester, vm.undefined, handle, expected));
+  ctx.unwrapResult(ctx.callFunction(descTester, ctx.undefined, handle, expected));
 
   expected.dispose();
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   handle.dispose();
   descTester.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("empty", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn();
-  const handle = vm.newObject();
+  const ctx = (await getQuickJS()).newContext();
+  const marshal = vi.fn();
+  const handle = ctx.newObject();
   const obj = {};
 
-  marshalProperties(vm, obj, handle, marshal);
+  marshalProperties(ctx, obj, handle, marshal);
   expect(marshal).toHaveBeenCalledTimes(0);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/marshal/properties.ts

@@ -1,23 +1,21 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call } from "../vmutil";
 
 export default function marshalProperties(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   target: object | Function,
   handle: QuickJSHandle,
-  marshal: (target: unknown) => QuickJSHandle
+  marshal: (target: unknown) => QuickJSHandle,
 ): void {
-  const descs = vm.newObject();
+  const descs = ctx.newObject();
   const cb = (key: string | number | symbol, desc: PropertyDescriptor) => {
     const keyHandle = marshal(key);
-    const valueHandle =
-      typeof desc.value === "undefined" ? undefined : marshal(desc.value);
-    const getHandle =
-      typeof desc.get === "undefined" ? undefined : marshal(desc.get);
-    const setHandle =
-      typeof desc.set === "undefined" ? undefined : marshal(desc.set);
+    const valueHandle = typeof desc.value === "undefined" ? undefined : marshal(desc.value);
+    const getHandle = typeof desc.get === "undefined" ? undefined : marshal(desc.get);
+    const setHandle = typeof desc.set === "undefined" ? undefined : marshal(desc.set);
 
-    vm.newObject().consume((descObj) => {
+    ctx.newObject().consume(descObj => {
       Object.entries(desc).forEach(([k, v]) => {
         const v2 =
           k === "value"
@@ -27,21 +25,21 @@ export default function marshalProperties(
             : k === "set"
             ? setHandle
             : v
-            ? vm.true
-            : vm.false;
+            ? ctx.true
+            : ctx.false;
         if (v2) {
-          vm.setProp(descObj, k, v2);
+          ctx.setProp(descObj, k, v2);
         }
       });
-      vm.setProp(descs, keyHandle, descObj);
+      ctx.setProp(descs, keyHandle, descObj);
     });
   };
 
   const desc = Object.getOwnPropertyDescriptors(target);
   Object.entries(desc).forEach(([k, v]) => cb(k, v));
-  Object.getOwnPropertySymbols(desc).forEach((k) => cb(k, (desc as any)[k]));
+  Object.getOwnPropertySymbols(desc).forEach(k => cb(k, (desc as any)[k]));
 
-  call(vm, `Object.defineProperties`, undefined, handle, descs).dispose();
+  call(ctx, `Object.defineProperties`, undefined, handle, descs).dispose();
 
   descs.dispose();
 }

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();
+});