quickjs-emscripten-sync 1.3.0 → 1.5.1

package/src/unmarshal/object.test.ts

@@ -4,15 +4,12 @@ import { expect, test, vi } from "vitest";
 import unmarshalObject from "./object";
 
 test("normal object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
-    false,
-  ]);
-  const preUnmarshal = vi.fn((a) => a);
+  const ctx = (await getQuickJS()).newContext();
+  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: 1, b: true })`));
-  const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
+  const handle = ctx.unwrapResult(ctx.evalCode(`({ a: 1, b: true })`));
+  const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   if (!obj) throw new Error("obj is undefined");
   expect(obj).toEqual({ a: 1, b: true });
   expect(unmarshal).toReturnTimes(4);
@@ -24,20 +21,20 @@ test("normal object", async () => {
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("properties", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: QuickJSHandle[] = [];
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     disposables.push(v);
-    return [vm.typeof(v) === "function" ? () => {} : vm.dump(v), false];
+    return [ctx.typeof(v) === "function" ? () => {} : ctx.dump(v), false];
   });
-  const preUnmarshal = vi.fn((a) => a);
+  const preUnmarshal = vi.fn(a => a);
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`{
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`{
       const obj = {};
       Object.defineProperties(obj, {
         a: { value: 1, writable: true, configurable: true, enumerable: true },
@@ -45,9 +42,9 @@ test("properties", async () => {
         c: { get: () => {}, set: () => {} },
       });
       obj
-    }`)
+    }`),
   );
-  const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
+  const obj = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   if (!obj) throw new Error("obj is undefined");
   expect(obj).toEqual({
     a: 1,
@@ -72,21 +69,18 @@ test("properties", async () => {
   expect(preUnmarshal).toBeCalledTimes(1);
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("array", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.dump(v),
-    false,
-  ]);
-  const preUnmarshal = vi.fn((a) => a);
+  const ctx = (await getQuickJS()).newContext();
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [ctx.dump(v), false]);
+  const preUnmarshal = vi.fn(a => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`[1, true, "a"]`));
-  const array = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
+  const handle = ctx.unwrapResult(ctx.evalCode(`[1, true, "a"]`));
+  const array = unmarshalObject(ctx, handle, unmarshal, preUnmarshal);
   expect((array as any)[0]).toEqual(1);
   expect(Array.isArray(array)).toBe(true);
   expect(unmarshal.mock.results[0].value).toEqual(["0", false]);
@@ -100,19 +94,19 @@ test("array", async () => {
   expect(preUnmarshal).toBeCalledWith(array, handle);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("prototype", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
-    vm.typeof(v) === "object" ? { a: () => 1 } : vm.dump(v),
+    ctx.typeof(v) === "object" ? { a: () => 1 } : ctx.dump(v),
     false,
   ]);
-  const preUnmarshal = vi.fn((a) => a);
+  const preUnmarshal = vi.fn(a => a);
 
-  const handle = vm.unwrapResult(vm.evalCode(`Object.create({ a: () => 1 })`));
-  const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal) as any;
+  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) });
   expect(obj.a()).toBe(1);
@@ -122,25 +116,25 @@ test("prototype", async () => {
   expect(preUnmarshal).toBeCalledWith(obj, handle);
 
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });
 
 test("undefined", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const f = vi.fn();
 
-  expect(unmarshalObject(vm, vm.undefined, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.true, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.false, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.null, f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.newString("hoge"), f, f)).toEqual(undefined);
-  expect(unmarshalObject(vm, vm.newNumber(-10), f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.undefined, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.true, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.false, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.null, f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.newString("hoge"), f, f)).toEqual(undefined);
+  expect(unmarshalObject(ctx, ctx.newNumber(-10), f, f)).toEqual(undefined);
 
-  const func = vm.newFunction("", () => {});
-  expect(unmarshalObject(vm, func, f, f)).toEqual(undefined);
+  const func = ctx.newFunction("", () => {});
+  expect(unmarshalObject(ctx, func, f, f)).toEqual(undefined);
 
   expect(f).toBeCalledTimes(0);
 
   func.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/object.ts

@@ -1,41 +1,37 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-import unmarshalProperties from "./properties";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call } from "../vmutil";
 
+import unmarshalProperties from "./properties";
+
 export default function unmarshalObject(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
-  preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
+  preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined,
 ): object | undefined {
   if (
-    vm.typeof(handle) !== "object" ||
+    ctx.typeof(handle) !== "object" ||
     // null check
-    vm
-      .unwrapResult(vm.evalCode("o => o === null"))
-      .consume((n) =>
-        vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle)))
-      )
+    ctx
+      .unwrapResult(ctx.evalCode("o => o === null"))
+      .consume(n => ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle))))
   )
     return;
 
-  const raw = call(vm, "Array.isArray", undefined, handle).consume((r) =>
-    vm.dump(r)
-  )
-    ? []
-    : {};
+  const raw = call(ctx, "Array.isArray", undefined, handle).consume(r => ctx.dump(r)) ? [] : {};
   const obj = preUnmarshal(raw, handle) ?? raw;
 
   const prototype = call(
-    vm,
+    ctx,
     `o => {
       const p = Object.getPrototypeOf(o);
       return !p || p === Object.prototype || p === Array.prototype ? undefined : p;
     }`,
     undefined,
-    handle
-  ).consume((prototype) => {
-    if (vm.typeof(prototype) === "undefined") return;
+    handle,
+  ).consume(prototype => {
+    if (ctx.typeof(prototype) === "undefined") return;
     const [proto] = unmarshal(prototype);
     return proto;
   });
@@ -43,7 +39,7 @@ export default function unmarshalObject(
     Object.setPrototypeOf(obj, prototype);
   }
 
-  unmarshalProperties(vm, handle, raw, unmarshal);
+  unmarshalProperties(ctx, handle, raw, unmarshal);
 
   return obj;
 }

package/src/unmarshal/primitive.test.ts

@@ -4,27 +4,27 @@ import { expect, test } from "vitest";
 import unmarshalPrimitive from "./primitive";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
 
-  expect(unmarshalPrimitive(vm, vm.undefined)).toEqual([undefined, true]);
-  expect(unmarshalPrimitive(vm, vm.true)).toEqual([true, true]);
-  expect(unmarshalPrimitive(vm, vm.false)).toEqual([false, true]);
-  expect(unmarshalPrimitive(vm, vm.null)).toEqual([null, true]);
-  expect(unmarshalPrimitive(vm, vm.newString("hoge"))).toEqual(["hoge", true]);
-  expect(unmarshalPrimitive(vm, vm.newNumber(-10))).toEqual([-10, true]);
+  expect(unmarshalPrimitive(ctx, ctx.undefined)).toEqual([undefined, true]);
+  expect(unmarshalPrimitive(ctx, ctx.true)).toEqual([true, true]);
+  expect(unmarshalPrimitive(ctx, ctx.false)).toEqual([false, true]);
+  expect(unmarshalPrimitive(ctx, ctx.null)).toEqual([null, true]);
+  expect(unmarshalPrimitive(ctx, ctx.newString("hoge"))).toEqual(["hoge", true]);
+  expect(unmarshalPrimitive(ctx, ctx.newNumber(-10))).toEqual([-10, true]);
   // expect(
-  //   unmarshalPrimitive(vm, vm.unwrapResult(vm.evalCode(`BigInt(1)`)))
+  //   unmarshalPrimitive(ctx, ctx.unwrapResult(vm.evalCode(`BigInt(1)`)))
   // ).toEqual([BigInt(1), true]);
 
-  const obj = vm.newObject();
-  expect(unmarshalPrimitive(vm, obj)).toEqual([undefined, false]);
-  const array = vm.newArray();
-  expect(unmarshalPrimitive(vm, array)).toEqual([undefined, false]);
-  const func = vm.newFunction("", () => {});
-  expect(unmarshalPrimitive(vm, func)).toEqual([undefined, false]);
+  const obj = ctx.newObject();
+  expect(unmarshalPrimitive(ctx, obj)).toEqual([undefined, false]);
+  const array = ctx.newArray();
+  expect(unmarshalPrimitive(ctx, array)).toEqual([undefined, false]);
+  const func = ctx.newFunction("", () => {});
+  expect(unmarshalPrimitive(ctx, func)).toEqual([undefined, false]);
 
   obj.dispose();
   array.dispose();
   func.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/primitive.ts

@@ -1,23 +1,16 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 export default function unmarshalPrimitive(
-  vm: QuickJSVm,
-  handle: QuickJSHandle
+  ctx: QuickJSContext,
+  handle: QuickJSHandle,
 ): [any, boolean] {
-  const ty = vm.typeof(handle);
-  if (
-    ty === "undefined" ||
-    ty === "number" ||
-    ty === "string" ||
-    ty === "boolean"
-  ) {
-    return [vm.dump(handle), true];
+  const ty = ctx.typeof(handle);
+  if (ty === "undefined" || ty === "number" || ty === "string" || ty === "boolean") {
+    return [ctx.dump(handle), true];
   } else if (ty === "object") {
-    const isNull = vm
-      .unwrapResult(vm.evalCode("a => a === null"))
-      .consume((n) =>
-        vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle)))
-      );
+    const isNull = ctx
+      .unwrapResult(ctx.evalCode("a => a === null"))
+      .consume(n => ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle))));
     if (isNull) {
       return [null, true];
     }
@@ -25,10 +18,10 @@ export default function unmarshalPrimitive(
 
   // BigInt is not supported by quickjs-emscripten
   // if (ty === "bigint") {
-  //   const str = vm
+  //   const str = ctx
   //     .getProp(handle, "toString")
   //     .consume(toString => vm.unwrapResult(vm.callFunction(toString, handle)))
-  //     .consume(str => vm.getString(str));
+  //     .consume(str => ctx.getString(str));
   //   const bi = BigInt(str);
   //   return [bi, true];
   // }

package/src/unmarshal/promise.test.ts

@@ -4,40 +4,40 @@ import { expect, test, vi } from "vitest";
 import unmarshalPromise from "./promise";
 
 const testPromise = (reject: boolean) => async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: Disposable[] = [];
   const marshal = vi.fn((v): [QuickJSHandle, boolean] => {
-    const f = vm.newFunction(v.name, (h) => {
-      v(vm.dump(h));
+    const f = ctx.newFunction(v.name, h => {
+      v(ctx.dump(h));
     });
     disposables.push(f);
     return [f, false];
   });
-  const preUnmarshal = vi.fn((a) => a);
+  const preUnmarshal = vi.fn(a => a);
 
-  const deferred = vm.newPromise();
+  const deferred = ctx.newPromise();
   disposables.push(deferred);
-  const promise = unmarshalPromise(vm, deferred.handle, marshal, preUnmarshal);
+  const promise = unmarshalPromise(ctx, deferred.handle, marshal, preUnmarshal);
 
   expect(marshal).toBeCalledTimes(2);
   expect(preUnmarshal).toBeCalledTimes(1);
-  expect(vm.hasPendingJob()).toBe(false);
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
 
   if (reject) {
-    deferred.reject(vm.newString("hoge"));
+    deferred.reject(ctx.newString("hoge"));
   } else {
-    deferred.resolve(vm.newString("hoge"));
+    deferred.resolve(ctx.newString("hoge"));
   }
-  expect(vm.hasPendingJob()).toBe(true);
-  expect(vm.unwrapResult(vm.executePendingJobs())).toBe(1);
+  expect(ctx.runtime.hasPendingJob()).toBe(true);
+  expect(ctx.unwrapResult(ctx.runtime.executePendingJobs())).toBe(1);
   if (reject) {
     expect(promise).rejects.toThrow("hoge");
   } else {
     expect(promise).resolves.toBe("hoge");
   }
 
-  disposables.forEach((d) => d.dispose());
-  vm.dispose();
+  disposables.forEach(d => d.dispose());
+  ctx.dispose();
 };
 
 test("resolve", testPromise(false));

package/src/unmarshal/promise.ts

@@ -1,40 +1,31 @@
-import type { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
 
 import { newDeferred } from "../util";
 import { call, instanceOf } from "../vmutil";
 
 export default function unmarshalPromise<T = unknown>(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   /** marshal returns handle and boolean indicates that the handle should be disposed after use */
   marshal: (value: unknown) => [QuickJSHandle, boolean],
-  preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined
+  preUnmarshal: <T>(target: T, handle: QuickJSHandle) => T | undefined,
 ): Promise<T> | undefined {
-  if (!isPromiseHandle(handle)) return;
+  if (!isPromiseHandle(ctx, handle)) return;
 
   const deferred = newDeferred<T>();
   const [resHandle, resShouldBeDisposed] = marshal(deferred.resolve);
   const [rejHandle, rejShouldBeDisposed] = marshal(deferred.reject);
-  call(
-    vm,
-    "(p, res, rej) => { p.then(res, rej); }",
-    undefined,
-    handle,
-    resHandle,
-    rejHandle
-  );
+  call(ctx, "(p, res, rej) => { p.then(res, rej); }", undefined, handle, resHandle, rejHandle);
   if (resShouldBeDisposed) resHandle.dispose();
   if (rejShouldBeDisposed) rejHandle.dispose();
 
   return preUnmarshal(deferred.promise, handle) ?? deferred.promise;
 }
 
-function isPromiseHandle(handle: QuickJSHandle): boolean {
+function isPromiseHandle(ctx: QuickJSContext, handle: QuickJSHandle): boolean {
   if (!handle.owner) return false;
-  return handle.owner
-    .unwrapResult(handle.owner.evalCode("Promise"))
-    .consume((promise) => {
-      if (!handle.owner) return false;
-      return instanceOf(handle.owner, handle, promise);
-    });
+  return ctx.unwrapResult(ctx.evalCode("Promise")).consume(promise => {
+    if (!handle.owner) return false;
+    return instanceOf(ctx, handle, promise);
+  });
 }

package/src/unmarshal/properties.test.ts

@@ -4,16 +4,16 @@ import { expect, test, vi } from "vitest";
 import unmarshalProperties from "./properties";
 
 test("works", async () => {
-  const vm = (await getQuickJS()).createVm();
+  const ctx = (await getQuickJS()).newContext();
   const disposables: QuickJSHandle[] = [];
   const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     disposables.push(v);
-    return [vm.typeof(v) === "function" ? () => {} : vm.dump(v), false];
+    return [ctx.typeof(v) === "function" ? () => {} : ctx.dump(v), false];
   });
   const obj = {};
 
-  const handle = vm.unwrapResult(
-    vm.evalCode(`{
+  const handle = ctx.unwrapResult(
+    ctx.evalCode(`{
       const obj = {};
       Object.defineProperties(obj, {
         a: { value: 1, writable: true, configurable: true, enumerable: true },
@@ -21,10 +21,10 @@ test("works", async () => {
         c: { get: () => {}, set: () => {} },
       });
       obj
-    }`)
+    }`),
   );
 
-  unmarshalProperties(vm, handle, obj, unmarshal);
+  unmarshalProperties(ctx, handle, obj, unmarshal);
 
   expect(obj).toEqual({
     a: 1,
@@ -47,7 +47,7 @@ test("works", async () => {
   expect(unmarshal).toReturnWith(["c", false]);
   expect(unmarshal).toReturnWith([expect.any(Function), false]); // get, set
 
-  disposables.forEach((d) => d.dispose());
+  disposables.forEach(d => d.dispose());
   handle.dispose();
-  vm.dispose();
+  ctx.dispose();
 });

package/src/unmarshal/properties.ts

@@ -1,61 +1,60 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+
 import { call } from "../vmutil";
 
 export default function unmarshalProperties(
-  vm: QuickJSVm,
+  ctx: QuickJSContext,
   handle: QuickJSHandle,
   target: object | Function,
-  unmarshal: (handle: QuickJSHandle) => [unknown, boolean]
+  unmarshal: (handle: QuickJSHandle) => [unknown, boolean],
 ) {
-  vm.newFunction("", (key, value) => {
-    const [keyName] = unmarshal(key);
-    if (
-      typeof keyName !== "string" &&
-      typeof keyName !== "number" &&
-      typeof keyName !== "symbol"
-    )
-      return;
+  ctx
+    .newFunction("", (key, value) => {
+      const [keyName] = unmarshal(key);
+      if (typeof keyName !== "string" && typeof keyName !== "number" && typeof keyName !== "symbol")
+        return;
 
-    const desc = (
-      [
-        ["value", true],
-        ["get", true],
-        ["set", true],
-        ["configurable", false],
-        ["enumerable", false],
-        ["writable", false],
-      ] as const
-    ).reduce<PropertyDescriptor>((desc, [key, unmarshable]) => {
-      const h = vm.getProp(value, key);
-      const ty = vm.typeof(h);
+      const desc = (
+        [
+          ["value", true],
+          ["get", true],
+          ["set", true],
+          ["configurable", false],
+          ["enumerable", false],
+          ["writable", false],
+        ] as const
+      ).reduce<PropertyDescriptor>((desc, [key, unmarshable]) => {
+        const h = ctx.getProp(value, key);
+        const ty = ctx.typeof(h);
 
-      if (ty === "undefined") return desc;
-      if (!unmarshable && ty === "boolean") {
-        desc[key] = vm.dump(vm.getProp(value, key));
-        return desc;
-      }
+        if (ty === "undefined") return desc;
+        if (!unmarshable && ty === "boolean") {
+          desc[key] = ctx.dump(ctx.getProp(value, key));
+          return desc;
+        }
 
-      const [v, alreadyExists] = unmarshal(h);
-      if (alreadyExists) {
-        h.dispose();
-      }
-      desc[key] = v;
+        const [v, alreadyExists] = unmarshal(h);
+        if (alreadyExists) {
+          h.dispose();
+        }
+        desc[key] = v;
 
-      return desc;
-    }, {});
+        return desc;
+      }, {});
 
-    Object.defineProperty(target, keyName, desc);
-  }).consume((fn) => {
-    call(
-      vm,
-      `(o, fn) => {
+      Object.defineProperty(target, keyName, desc);
+    })
+    .consume(fn => {
+      call(
+        ctx,
+        `(o, fn) => {
         const descs = Object.getOwnPropertyDescriptors(o);
         Object.entries(descs).forEach(([k, v]) => fn(k, v));
         Object.getOwnPropertySymbols(descs).forEach(k => fn(k, descs[k]));
       }`,
-      undefined,
-      handle,
-      fn
-    ).dispose();
-  });
+        undefined,
+        handle,
+        fn,
+      ).dispose();
+    });
 }

package/src/util.test.ts

@@ -1,11 +1,6 @@
 import { expect, test, vi } from "vitest";
-import {
-  isES2015Class,
-  isObject,
-  walkObject,
-  complexity,
-  newDeferred,
-} from "./util";
+
+import { isES2015Class, isObject, walkObject, complexity, newDeferred } from "./util";
 
 test("isES2015Class", () => {
   expect(isES2015Class(class {})).toBe(true);

package/src/util.ts

@@ -1,19 +1,14 @@
 export function isES2015Class(cls: any): cls is new (...args: any[]) => any {
-  return (
-    typeof cls === "function" &&
-    /^class\s/.test(Function.prototype.toString.call(cls))
-  );
+  return typeof cls === "function" && /^class\s/.test(Function.prototype.toString.call(cls));
 }
 
 export function isObject(value: any): value is object | Function {
-  return (
-    typeof value === "function" || (typeof value === "object" && value !== null)
-  );
+  return typeof value === "function" || (typeof value === "object" && value !== null);
 }
 
 export function walkObject(
   value: any,
-  callback?: (target: any, set: Set<any>) => boolean | void
+  callback?: (target: any, set: Set<any>) => boolean | void,
 ): Set<any> {
   const set = new Set<any>();
   const walk = (v: any) => {