quickjs-emscripten-sync 1.4.0 → 1.5.0

package/src/marshal/function.test.ts

@@ -1,16 +1,15 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
 
 import { json, eq, call } from "../vmutil";
+
 import marshalFunction from "./function";
-import { expect, test, vi } from "vitest";
 
 test("normal func", async () => {
   const ctx = (await getQuickJS()).newContext();
 
-  const marshal = vi.fn((v) => json(ctx, v));
-  const unmarshal = vi.fn((v) =>
-    eq(ctx, v, ctx.global) ? undefined : ctx.dump(v)
-  );
+  const marshal = vi.fn(v => json(ctx, v));
+  const unmarshal = vi.fn(v => (eq(ctx, v, ctx.global) ? undefined : ctx.dump(v)));
   const preMarshal = vi.fn((_, a) => a);
   const innerfn = vi.fn((..._args: any[]) => "hoge");
   const fn = (...args: any[]) => innerfn(...args);
@@ -25,7 +24,7 @@ test("normal func", async () => {
   expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("fn");
 
   const result = ctx.unwrapResult(
-    ctx.callFunction(handle, ctx.undefined, ctx.newNumber(1), ctx.true)
+    ctx.callFunction(handle, ctx.undefined, ctx.newNumber(1), ctx.true),
   );
 
   expect(ctx.dump(result)).toBe("hoge");
@@ -42,7 +41,7 @@ test("normal func", async () => {
 
 test("func which has properties", async () => {
   const ctx = (await getQuickJS()).newContext();
-  const marshal = vi.fn((v) => json(ctx, v));
+  const marshal = vi.fn(v => json(ctx, v));
 
   const fn = () => {};
   fn.hoge = "foo";
@@ -51,8 +50,8 @@ test("func which has properties", async () => {
     ctx,
     fn,
     marshal,
-    (v) => ctx.dump(v),
-    (_, a) => a
+    v => ctx.dump(v),
+    (_, a) => a,
   );
   if (!handle) throw new Error("handle is undefined");
 
@@ -92,20 +91,16 @@ test("class", async () => {
   if (!handle) throw new Error("handle is undefined");
 
   const newA = ctx.unwrapResult(ctx.evalCode(`A => new A(100)`));
-  const instance = ctx.unwrapResult(
-    ctx.callFunction(newA, ctx.undefined, handle)
-  );
+  const instance = ctx.unwrapResult(ctx.callFunction(newA, ctx.undefined, handle));
 
   expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("A");
   expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(1);
-  expect(
-    ctx.dump(
-      call(ctx, "(cls, i) => i instanceof cls", undefined, handle, instance)
-    )
-  ).toBe(true);
+  expect(ctx.dump(call(ctx, "(cls, i) => i instanceof cls", undefined, handle, instance))).toBe(
+    true,
+  );
   expect(ctx.dump(ctx.getProp(instance, "a"))).toBe(100);
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   instance.dispose();
   newA.dispose();
   handle.dispose();
@@ -120,34 +115,19 @@ test("preApply", async () => {
     if (typeof v === "number") return ctx.newNumber(v);
     return ctx.null;
   };
-  const unmarshal = (v: QuickJSHandle) =>
-    ctx.typeof(v) === "object" ? that : ctx.dump(v);
-  const preApply = vi.fn(
-    (a: Function, b: any, c: any[]) => a.apply(b, c) + "!"
-  );
+  const unmarshal = (v: QuickJSHandle) => (ctx.typeof(v) === "object" ? that : ctx.dump(v));
+  const preApply = vi.fn((a: Function, b: any, c: any[]) => a.apply(b, c) + "!");
   const that = {};
   const thatHandle = ctx.newObject();
 
   const fn = () => "foo";
-  const handle = marshalFunction(
-    ctx,
-    fn,
-    marshal,
-    unmarshal,
-    (_, a) => a,
-    preApply
-  );
+  const handle = marshalFunction(ctx, fn, marshal, unmarshal, (_, a) => a, preApply);
   if (!handle) throw new Error("handle is undefined");
 
   expect(preApply).toBeCalledTimes(0);
 
   const res = ctx.unwrapResult(
-    ctx.callFunction(
-      handle,
-      thatHandle,
-      ctx.newNumber(100),
-      ctx.newString("hoge")
-    )
+    ctx.callFunction(handle, thatHandle, ctx.newNumber(100), ctx.newString("hoge")),
   );
 
   expect(preApply).toBeCalledTimes(1);

package/src/marshal/function.ts

@@ -2,6 +2,7 @@ import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 import { isES2015Class, isObject } from "../util";
 import { call } from "../vmutil";
+
 import marshalProperties from "./properties";
 
 export default function marshalFunction(
@@ -9,18 +10,15 @@ export default function marshalFunction(
   target: unknown,
   marshal: (target: unknown) => QuickJSHandle,
   unmarshal: (handle: QuickJSHandle) => unknown,
-  preMarshal: (
-    target: unknown,
-    handle: QuickJSHandle
-  ) => QuickJSHandle | undefined,
-  preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any
+  preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined,
+  preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any,
 ): QuickJSHandle | undefined {
   if (typeof target !== "function") return;
 
   const raw = ctx
     .newFunction(target.name, function (...argHandles) {
       const that = unmarshal(this);
-      const args = argHandles.map((a) => unmarshal(a));
+      const args = argHandles.map(a => unmarshal(a));
 
       if (isES2015Class(target) && isObject(that)) {
         // Class constructors cannot be invoked without new expression, and new.target is not changed
@@ -31,11 +29,9 @@ export default function marshalFunction(
         return this;
       }
 
-      return marshal(
-        preApply ? preApply(target, that, args) : target.apply(that, args)
-      );
+      return marshal(preApply ? preApply(target, that, args) : target.apply(that, args));
     })
-    .consume((handle2) =>
+    .consume(handle2 =>
       // fucntions created by vm.newFunction are not callable as a class constrcutor
       call(
         ctx,
@@ -46,8 +42,8 @@ export default function marshalFunction(
           return fn;
         }`,
         undefined,
-        handle2
-      )
+        handle2,
+      ),
     );
 
   const handle = preMarshal(target, raw) ?? raw;

package/src/marshal/index.test.ts

@@ -1,10 +1,11 @@
 import { getQuickJS } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
+import { newDeferred } from "../util";
 import VMMap from "../vmmap";
 import { instanceOf, call, handleFrom, fn } from "../vmutil";
+
 import marshal from ".";
-import { newDeferred } from "../util";
 
 test("primitive, array, object", async () => {
   const { ctx, map, marshal, dispose } = await setup();
@@ -36,11 +37,9 @@ test("object with symbol key", async () => {
   };
   const handle = marshal(target);
   expect(ctx.dump(call(ctx, `a => a.foo`, undefined, handle))).toBe("hoge");
-  expect(
-    ctx.dump(
-      call(ctx, `a => a[Object.getOwnPropertySymbols(a)[0]]`, undefined, handle)
-    )
-  ).toBe(1);
+  expect(ctx.dump(call(ctx, `a => a[Object.getOwnPropertySymbols(a)[0]]`, undefined, handle))).toBe(
+    1,
+  );
 
   dispose();
 });
@@ -56,9 +55,7 @@ test("arrow function", async () => {
   expect(ctx.dump(ctx.getProp(handle, "name"))).toBe("hoge");
   const foo = ctx.getProp(handle, "foo");
   expect(ctx.dump(foo)).toEqual({ bar: 1 });
-  expect(
-    ctx.dump(ctx.unwrapResult(ctx.callFunction(handle, ctx.undefined)))
-  ).toBe("foo");
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(handle, ctx.undefined)))).toBe("foo");
   expect(map.size).toBe(2);
   expect(map.get(hoge)).toBe(handle);
   expect(map.has(hoge.foo)).toBe(true);
@@ -84,11 +81,7 @@ test("function", async () => {
 
   const b = ctx.unwrapResult(ctx.evalCode(`({ hoge: 2 })`));
   expect(
-    ctx.dump(
-      ctx.unwrapResult(
-        ctx.callFunction(handle, ctx.undefined, ctx.newNumber(1), b)
-      )
-    )
+    ctx.dump(ctx.unwrapResult(ctx.callFunction(handle, ctx.undefined, ctx.newNumber(1), b))),
   ).toBe(3);
 
   b.dispose();
@@ -99,15 +92,15 @@ test("promise", async () => {
   const { ctx, marshal, dispose } = await setup();
   const register = fn(
     ctx,
-    `promise => { promise.then(d => notify("resolve", d), d => notify("reject", d)); }`
+    `promise => { promise.then(d => notify("resolve", d), d => notify("reject", d)); }`,
   );
 
   let notified: any;
   ctx
     .newFunction("notify", (...handles) => {
-      notified = handles.map((h) => ctx.dump(h));
+      notified = handles.map(h => ctx.dump(h));
     })
-    .consume((h) => {
+    .consume(h => {
       ctx.setProp(ctx.global, "notify", h);
     });
 
@@ -169,12 +162,8 @@ test("class", async () => {
   expect(map.has(A.prototype)).toBe(true);
   expect(map.has(A.a)).toBe(true);
   expect(map.has(A.prototype.hoge)).toBe(true);
-  expect(
-    map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.get)
-  ).toBe(true);
-  expect(
-    map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.set)
-  ).toBe(true);
+  expect(map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.get)).toBe(true);
+  expect(map.has(Object.getOwnPropertyDescriptor(A.prototype, "foo")?.set)).toBe(true);
 
   expect(ctx.typeof(handle)).toBe("function");
   expect(ctx.dump(ctx.getProp(handle, "length"))).toBe(1);
@@ -185,28 +174,20 @@ test("class", async () => {
   expect(ctx.dump(ctx.getProp(staticA, "b"))).toBe("a!");
 
   const newA = ctx.unwrapResult(ctx.evalCode(`A => new A("foo")`));
-  const instance = ctx.unwrapResult(
-    ctx.callFunction(newA, ctx.undefined, handle)
-  );
+  const instance = ctx.unwrapResult(ctx.callFunction(newA, ctx.undefined, handle));
   expect(instanceOf(ctx, instance, handle)).toBe(true);
   expect(ctx.dump(ctx.getProp(instance, "a"))).toBe(100);
   expect(ctx.dump(ctx.getProp(instance, "b"))).toBe("foo!");
   const methodHoge = ctx.getProp(instance, "hoge");
-  expect(
-    ctx.dump(ctx.unwrapResult(ctx.callFunction(methodHoge, instance)))
-  ).toBe(101);
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(methodHoge, instance)))).toBe(101);
   expect(ctx.dump(ctx.getProp(instance, "a"))).toBe(100); // not synced
 
   const getter = ctx.unwrapResult(ctx.evalCode(`a => a.foo`));
   const setter = ctx.unwrapResult(ctx.evalCode(`(a, b) => a.foo = b`));
-  expect(
-    ctx.dump(
-      ctx.unwrapResult(ctx.callFunction(getter, ctx.undefined, instance))
-    )
-  ).toBe("foo!");
-  ctx.unwrapResult(
-    ctx.callFunction(setter, ctx.undefined, instance, ctx.newString("b"))
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(getter, ctx.undefined, instance)))).toBe(
+    "foo!",
   );
+  ctx.unwrapResult(ctx.callFunction(setter, ctx.undefined, instance, ctx.newString("b")));
   expect(ctx.dump(ctx.getProp(instance, "b"))).toBe("foo!"); // not synced
 
   staticA.dispose();
@@ -215,7 +196,22 @@ test("class", async () => {
   methodHoge.dispose();
   getter.dispose();
   setter.dispose();
-  map.dispose();
+  dispose();
+});
+
+test("date", async () => {
+  const { ctx, map, marshal, dispose } = await setup();
+
+  const date = new Date(2022, 7, 26);
+  const handle = marshal(date);
+  if (!map) throw new Error("map is undefined");
+
+  expect(map.size).toBe(1);
+  expect(map.get(date)).toBe(handle);
+
+  expect(ctx.dump(call(ctx, "d => d instanceof Date", undefined, handle))).toBe(true);
+  expect(ctx.dump(call(ctx, "d => d.getTime()", undefined, handle))).toBe(date.getTime());
+
   dispose();
 });
 
@@ -271,14 +267,14 @@ const setup = async ({
     marshal: (v: any) =>
       marshal(v, {
         ctx: ctx,
-        unmarshal: (h) => map.getByHandle(h) ?? ctx.dump(h),
+        unmarshal: h => map.getByHandle(h) ?? ctx.dump(h),
         isMarshalable,
         pre: (t, d) => {
           const h = handleFrom(d);
           map.set(t, h);
           return h;
         },
-        find: (t) => map.get(t),
+        find: t => map.get(t),
       }),
     dispose: () => {
       map.dispose();

package/src/marshal/index.ts

@@ -1,14 +1,10 @@
-import type {
-  QuickJSDeferredPromise,
-  QuickJSHandle,
-  QuickJSContext,
-} from "quickjs-emscripten";
+import type { QuickJSDeferredPromise, QuickJSHandle, QuickJSContext } from "quickjs-emscripten";
 
+import marshalCustom, { defaultCustom } from "./custom";
 import marshalFunction from "./function";
+import marshalJSON from "./json";
 import marshalObject from "./object";
 import marshalPrimitive from "./primitive";
-import marshalSymbol from "./symbol";
-import marshalJSON from "./json";
 import marshalPromise from "./promise";
 
 export type Options = {
@@ -19,9 +15,10 @@ export type Options = {
   pre: (
     target: unknown,
     handle: QuickJSHandle | QuickJSDeferredPromise,
-    mode: true | "json" | undefined
+    mode: true | "json" | undefined,
   ) => QuickJSHandle | undefined;
   preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any;
+  custom?: Iterable<(obj: unknown, ctx: QuickJSContext) => QuickJSHandle | undefined>;
 };
 
 export function marshal(target: unknown, options: Options): QuickJSHandle {
@@ -52,7 +49,7 @@ export function marshal(target: unknown, options: Options): QuickJSHandle {
 
   const marshal2 = (t: unknown) => marshal(t, options);
   return (
-    marshalSymbol(ctx, target, pre2) ??
+    marshalCustom(ctx, target, pre2, [...defaultCustom, ...(options.custom ?? [])]) ??
     marshalPromise(ctx, target, marshal2, pre2) ??
     marshalFunction(ctx, target, marshal2, unmarshal, pre2, options.preApply) ??
     marshalObject(ctx, target, marshal2, pre2) ??

package/src/marshal/json.test.ts

@@ -6,7 +6,7 @@ import marshalJSON from "./json";
 test("empty object", async () => {
   const ctx = (await getQuickJS()).newContext();
   const prototypeCheck = ctx.unwrapResult(
-    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`),
   );
 
   const obj = {};
@@ -19,11 +19,9 @@ test("empty object", async () => {
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    ctx.dump(
-      ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle))
-    )
-  ).toBe(true);
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle)))).toBe(
+    true,
+  );
 
   handle.dispose();
   prototypeCheck.dispose();
@@ -33,7 +31,7 @@ test("empty object", async () => {
 test("normal object", async () => {
   const ctx = (await getQuickJS()).newContext();
   const prototypeCheck = ctx.unwrapResult(
-    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`),
   );
   const entries = ctx.unwrapResult(ctx.evalCode(`Object.entries`));
 
@@ -49,11 +47,9 @@ test("normal object", async () => {
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    ctx.dump(
-      ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle))
-    )
-  ).toBe(true);
+  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],
@@ -84,9 +80,7 @@ test("array", async () => {
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(array);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    ctx.dump(ctx.unwrapResult(ctx.callFunction(isArray, ctx.undefined, handle)))
-  ).toBe(true);
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(isArray, ctx.undefined, handle)))).toBe(true);
 
   handle.dispose();
   isArray.dispose();

package/src/marshal/json.ts

@@ -5,10 +5,7 @@ import { json } from "../vmutil";
 export default function marshalJSON(
   ctx: QuickJSContext,
   target: unknown,
-  preMarshal: (
-    target: unknown,
-    handle: QuickJSHandle
-  ) => QuickJSHandle | undefined
+  preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined,
 ): QuickJSHandle {
   const raw = json(ctx, target);
   const handle = preMarshal(target, raw) ?? raw;

package/src/marshal/object.test.ts

@@ -2,12 +2,13 @@ import { getQuickJS } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import { call } from "../vmutil";
+
 import marshalObject from "./object";
 
 test("empty object", async () => {
   const ctx = (await getQuickJS()).newContext();
   const prototypeCheck = ctx.unwrapResult(
-    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`),
   );
 
   const obj = {};
@@ -22,11 +23,9 @@ test("empty object", async () => {
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    ctx.dump(
-      ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle))
-    )
-  ).toBe(true);
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle)))).toBe(
+    true,
+  );
 
   handle.dispose();
   prototypeCheck.dispose();
@@ -36,17 +35,13 @@ test("empty object", async () => {
 test("normal object", async () => {
   const ctx = (await getQuickJS()).newContext();
   const prototypeCheck = ctx.unwrapResult(
-    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`)
+    ctx.evalCode(`o => Object.getPrototypeOf(o) === Object.prototype`),
   );
   const entries = ctx.unwrapResult(ctx.evalCode(`Object.entries`));
 
   const obj = { a: 100, b: "hoge" };
-  const marshal = vi.fn((v) =>
-    typeof v === "number"
-      ? ctx.newNumber(v)
-      : typeof v === "string"
-      ? ctx.newString(v)
-      : ctx.null
+  const marshal = vi.fn(v =>
+    typeof v === "number" ? ctx.newNumber(v) : typeof v === "string" ? ctx.newString(v) : ctx.null,
   );
   const preMarshal = vi.fn((_, a) => a);
 
@@ -60,11 +55,9 @@ test("normal object", async () => {
   expect(preMarshal).toBeCalledTimes(1);
   expect(preMarshal.mock.calls[0][0]).toBe(obj);
   expect(preMarshal.mock.calls[0][1] === handle).toBe(true); // avoid freeze
-  expect(
-    ctx.dump(
-      ctx.unwrapResult(ctx.callFunction(prototypeCheck, ctx.undefined, handle))
-    )
-  ).toBe(true);
+  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],
@@ -83,12 +76,8 @@ test("array", async () => {
   const isArray = ctx.unwrapResult(ctx.evalCode(`Array.isArray`));
 
   const array = [1, "aa"];
-  const marshal = vi.fn((v) =>
-    typeof v === "number"
-      ? ctx.newNumber(v)
-      : typeof v === "string"
-      ? ctx.newString(v)
-      : ctx.null
+  const marshal = vi.fn(v =>
+    typeof v === "number" ? ctx.newNumber(v) : typeof v === "string" ? ctx.newString(v) : ctx.null,
   );
   const preMarshal = vi.fn((_, a) => a);
 
@@ -99,20 +88,11 @@ test("array", async () => {
   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(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(
-    ctx.dump(ctx.unwrapResult(ctx.callFunction(isArray, ctx.undefined, handle)))
-  ).toBe(true);
+  expect(ctx.dump(ctx.unwrapResult(ctx.callFunction(isArray, ctx.undefined, handle)))).toBe(true);
 
   handle.dispose();
   isArray.dispose();
@@ -132,13 +112,8 @@ test("prototype", async () => {
   const handle = marshalObject(
     ctx,
     obj,
-    (v) =>
-      v === proto
-        ? protoHandle
-        : typeof v === "string"
-        ? ctx.newString(v)
-        : ctx.null,
-    preMarshal
+    v => (v === proto ? protoHandle : typeof v === "string" ? ctx.newString(v) : ctx.null),
+    preMarshal,
   );
   if (!handle) throw new Error("handle is undefined");
 
@@ -150,15 +125,8 @@ test("prototype", async () => {
   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);
+  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();

package/src/marshal/object.ts

@@ -1,16 +1,14 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 import { call } from "../vmutil";
+
 import marshalProperties from "./properties";
 
 export default function marshalObject(
   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;
 
@@ -24,13 +22,7 @@ export default function marshalObject(
       ? marshal(prototype)
       : undefined;
   if (prototypeHandle) {
-    call(
-      ctx,
-      "Object.setPrototypeOf",
-      undefined,
-      handle,
-      prototypeHandle
-    ).dispose();
+    call(ctx, "Object.setPrototypeOf", undefined, handle, prototypeHandle).dispose();
   }
 
   marshalProperties(ctx, target, raw, marshal);

package/src/marshal/primitive.test.ts

@@ -2,6 +2,7 @@ import { getQuickJS } from "quickjs-emscripten";
 import { expect, test } from "vitest";
 
 import { eq } from "../vmutil";
+
 import marshalPrimitive from "./primitive";
 
 test("works", async () => {
@@ -11,19 +12,9 @@ test("works", async () => {
   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(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(
   //     ctx,

package/src/marshal/primitive.ts

@@ -4,7 +4,7 @@ import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 export default function marshalPrimitive(
   ctx: QuickJSContext,
-  target: unknown
+  target: unknown,
 ): QuickJSHandle | undefined {
   switch (typeof target) {
     case "undefined":