quickjs-emscripten-sync 1.4.0 → 1.5.0

package/src/marshal/promise.test.ts

@@ -6,25 +6,24 @@ import {
 } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
-import marshalPromise from "./promise";
 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 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 preMarshal = vi.fn((_: any, a: QuickJSDeferredPromise): QuickJSHandle => {
+    disposables.push(a);
+    return a.handle;
+  });
 
   const mockNotify = vi.fn();
   const notify = ctx.newFunction("notify", (handle1, handle2) => {
@@ -36,7 +35,7 @@ const testPromise = (reject: boolean) => async () => {
 
   const notifier = fn(
     ctx,
-    `(notify, promise) => { promise.then(d => notify("resolved", d), d => notify("rejected", d)); }`
+    `(notify, promise) => { promise.then(d => notify("resolved", d), d => notify("rejected", d)); }`,
   );
   disposables.push(notifier);
 
@@ -78,7 +77,7 @@ const testPromise = (reject: boolean) => async () => {
   expect(marshal).toBeCalledTimes(1);
   expect(marshal.mock.calls).toEqual([["hoge"]]);
 
-  disposables.forEach((h) => h.dispose());
+  disposables.forEach(h => h.dispose());
   ctx.dispose();
 };
 

package/src/marshal/promise.ts

@@ -1,25 +1,18 @@
-import type {
-  QuickJSDeferredPromise,
-  QuickJSHandle,
-  QuickJSContext,
-} from "quickjs-emscripten";
+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
+  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))
+    d => promise.resolve(marshal(d)),
+    d => promise.reject(marshal(d)),
   );
 
   return preMarshal(target, promise) ?? promise.handle;

package/src/marshal/properties.test.ts

@@ -2,6 +2,7 @@ import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
 
 import { json } from "../vmutil";
+
 import marshalProperties from "./properties";
 
 test("works", async () => {
@@ -18,11 +19,11 @@ 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 = vi.fn((t) => {
+  const marshal = vi.fn(t => {
     if (typeof t !== "function") return json(ctx, t);
     const fn = ctx.newFunction("", () => {});
     disposables.push(fn);
@@ -50,26 +51,18 @@ test("works", async () => {
   });
 
   marshalProperties(ctx, obj, handle, marshal);
-  expect(marshal.mock.calls).toEqual([
-    ["bar"],
-    [bar],
-    ["foo"],
-    [fooGet],
-    [fooSet],
-  ]);
+  expect(marshal.mock.calls).toEqual([["bar"], [bar], ["foo"], [fooGet], [fooSet]]);
 
   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 }
-    })`)
-  );
-  ctx.unwrapResult(
-    ctx.callFunction(descTester, ctx.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();
   ctx.dispose();

package/src/marshal/properties.ts

@@ -6,19 +6,16 @@ export default function marshalProperties(
   ctx: QuickJSContext,
   target: object | Function,
   handle: QuickJSHandle,
-  marshal: (target: unknown) => QuickJSHandle
+  marshal: (target: unknown) => QuickJSHandle,
 ): void {
   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);
 
-    ctx.newObject().consume((descObj) => {
+    ctx.newObject().consume(descObj => {
       Object.entries(desc).forEach(([k, v]) => {
         const v2 =
           k === "value"
@@ -40,7 +37,7 @@ export default function marshalProperties(
 
   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(ctx, `Object.defineProperties`, undefined, handle, 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();
+});

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,16 +2,14 @@ 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 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 unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [ctx.dump(v), false]);
+  const preUnmarshal = vi.fn(a => a);
 
   const handle = ctx.unwrapResult(ctx.evalCode(`(a, b) => a + b`));
   const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
@@ -51,11 +49,9 @@ test("function", async () => {
     if (ty === "object" || ty === "function") disposables.push(v);
     return [ctx.dump(v), false];
   });
-  const preUnmarshal = vi.fn((a) => a);
+  const preUnmarshal = vi.fn(a => a);
 
-  const handle = ctx.unwrapResult(
-    ctx.evalCode(`(function (a) { return this.a + a; })`)
-  );
+  const handle = ctx.unwrapResult(ctx.evalCode(`(function (a) { return this.a + a; })`));
 
   const func = unmarshalFunction(ctx, handle, marshal, unmarshal, preUnmarshal);
   if (!func) throw new Error("func is undefined");
@@ -75,7 +71,7 @@ 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();
   ctx.dispose();
@@ -93,19 +89,11 @@ test("constructor", async () => {
     if (ty === "object" || ty === "function") disposables.push(v);
     return [ctx.dump(v), false];
   });
-  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;
+  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,7 +113,7 @@ test("constructor", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(Cls, handle);
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   handle.dispose();
   ctx.dispose();
 });
@@ -142,19 +130,11 @@ test("class", async () => {
     if (ty === "object" || ty === "function") disposables.push(v);
     return [ctx.dump(v), false];
   });
-  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;
+  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,7 +154,7 @@ test("class", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(Cls, handle);
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   handle.dispose();
   ctx.dispose();
 });
@@ -187,12 +167,8 @@ test("undefined", async () => {
   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
-  );
+  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);

package/src/unmarshal/function.ts

@@ -1,6 +1,7 @@
 import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 import { call, mayConsumeAll } from "../vmutil";
+
 import unmarshalProperties from "./properties";
 
 export default function unmarshalFunction(
@@ -9,40 +10,29 @@ export default function unmarshalFunction(
   /** 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 (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(
-              ctx,
-              `(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 = ctx.unwrapResult(
-          ctx.callFunction(handle, thisHandle, ...argHandles)
-        );
+        const resultHandle = ctx.unwrapResult(ctx.callFunction(handle, thisHandle, ...argHandles));
 
         const [result, alreadyExists] = unmarshal(resultHandle);
         if (alreadyExists) resultHandle.dispose();
 
         return result;
-      }
+      },
     );
   };
 

package/src/unmarshal/index.test.ts

@@ -2,9 +2,10 @@ 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 { ctx, unmarshal, marshal, map, dispose } = await setup();
 
@@ -15,7 +16,7 @@ test("primitive, array, object", async () => {
       aaa: [1, true, {}],
       nested: { aa: null, hoge: undefined },
       bbb: () => "bar"
-    })`)
+    })`),
   );
   const target = unmarshal(handle);
 
@@ -28,19 +29,13 @@ test("primitive, array, object", async () => {
   });
   expect(map.size).toBe(5);
   expect(map.getByHandle(handle)).toBe(target);
+  ctx.getProp(handle, "aaa").consume(h => expect(map.getByHandle(h)).toBe(target.aaa));
   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));
+    .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");
@@ -57,7 +52,7 @@ test("object with symbol key", async () => {
     ctx.evalCode(`({
       hoge: "foo",
       [Symbol("a")]: "bar"
-    })`)
+    })`),
   );
   const target = unmarshal(handle);
 
@@ -70,9 +65,7 @@ test("object with symbol key", async () => {
 test("function", async () => {
   const { ctx, unmarshal, marshal, map, dispose } = await setup();
 
-  const handle = ctx.unwrapResult(
-    ctx.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!");
@@ -123,21 +116,35 @@ 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 ctx = (await getQuickJS()).newContext();
   const map = new VMMap(ctx);
@@ -149,7 +156,7 @@ const setup = async () => {
     const handle2 =
       typeof target === "function"
         ? ctx.newFunction(target.name, (...handles) => {
-            target(...handles.map((h) => ctx.dump(h)));
+            target(...handles.map(h => ctx.dump(h)));
           })
         : json(ctx, target);
     const ty = ctx.typeof(handle2);
@@ -162,7 +169,7 @@ const setup = async () => {
     map,
     unmarshal: (handle: QuickJSHandle) =>
       unmarshal(handle, {
-        find: (h) => map.getByHandle(h),
+        find: h => map.getByHandle(h),
         marshal,
         pre: (t, h) => {
           map.set(t, h);
@@ -172,7 +179,7 @@ const setup = async () => {
       }),
     marshal,
     dispose: () => {
-      disposables.forEach((d) => d.dispose());
+      disposables.forEach(d => d.dispose());
       map.dispose();
       ctx.dispose();
     },

package/src/unmarshal/index.ts

@@ -1,10 +1,10 @@
 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 = {
   ctx: QuickJSContext;
@@ -12,6 +12,7 @@ export type Options = {
   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 {
@@ -19,10 +20,7 @@ export function unmarshal(handle: QuickJSHandle, options: Options): any {
   return result;
 }
 
-function unmarshalInner(
-  handle: QuickJSHandle,
-  options: Options
-): [any, boolean] {
+function unmarshalInner(handle: QuickJSHandle, options: Options): [any, boolean] {
   const { ctx, marshal, find, pre } = options;
 
   {
@@ -40,7 +38,7 @@ function unmarshalInner(
   const unmarshal2 = (h: QuickJSHandle) => unmarshalInner(h, options);
 
   const result =
-    unmarshalSymbol(ctx, handle, pre) ??
+    unmarshalCustom(ctx, handle, pre, [...defaultCustom, ...(options.custom ?? [])]) ??
     unmarshalPromise(ctx, handle, marshal, pre) ??
     unmarshalFunction(ctx, handle, marshal, unmarshal2, pre) ??
     unmarshalObject(ctx, handle, unmarshal2, pre);

package/src/unmarshal/object.test.ts

@@ -5,11 +5,8 @@ import unmarshalObject from "./object";
 
 test("normal object", async () => {
   const ctx = (await getQuickJS()).newContext();
-  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    ctx.dump(v),
-    false,
-  ]);
-  const preUnmarshal = vi.fn((a) => a);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [ctx.dump(v), false]);
+  const preUnmarshal = vi.fn(a => a);
 
   const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1, b: true })`));
   const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
@@ -34,7 +31,7 @@ test("properties", async () => {
     disposables.push(v);
     return [ctx.typeof(v) === "function" ? () => {} : ctx.dump(v), false];
   });
-  const preUnmarshal = vi.fn((a) => a);
+  const preUnmarshal = vi.fn(a => a);
 
   const handle = ctx.unwrapResult(
     ctx.evalCode(`{
@@ -45,7 +42,7 @@ test("properties", async () => {
         c: { get: () => {}, set: () => {} },
       });
       obj
-    }`)
+    }`),
   );
   const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   if (!obj) throw new Error("obj is undefined");
@@ -72,18 +69,15 @@ test("properties", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   handle.dispose();
   ctx.dispose();
 });
 
 test("array", async () => {
   const ctx = (await getQuickJS()).newContext();
-  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    ctx.dump(v),
-    false,
-  ]);
-  const preUnmarshal = vi.fn((a) => a);
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [ctx.dump(v), false]);
+  const preUnmarshal = vi.fn(a => a);
 
   const handle = ctx.unwrapResult(ctx.evalCode(`[1, true, "a"]`));
   const array = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
@@ -109,11 +103,9 @@ test("prototype", async () => {
     ctx.typeof(v) === "object" ? { a: () => 1 } : ctx.dump(v),
     false,
   ]);
-  const preUnmarshal = vi.fn((a) => a);
+  const preUnmarshal = vi.fn(a => a);
 
-  const handle = ctx.unwrapResult(
-    ctx.evalCode(`Object.create({ a: () => 1 })`)
-  );
+  const handle = ctx.unwrapResult(ctx.evalCode(`Object.create({ a: () => 1 })`));
   const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal) as any;
   if (!obj) throw new Error("obj is undefined");
   expect(Object.getPrototypeOf(obj)).toEqual({ a: expect.any(Function) });