quickjs-emscripten-sync 1.3.0 → 1.5.1

package/src/marshal/object.test.ts

@@ -2,71 +2,64 @@ 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 = 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 = vi.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 = 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"],
   ]);
@@ -75,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 = vi.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 = 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 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

@@ -2,35 +2,30 @@ 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

@@ -5,38 +5,37 @@ import {
   type QuickJSHandle,
 } from "quickjs-emscripten";
 import { expect, test, vi } from "vitest";
-import { newDeferred } from "../util";
 
+import { newDeferred } from "../util";
 import { fn, json } from "../vmutil";
+
 import marshalPromise 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) => {
-    const handle = json(vm, 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 = vm.newFunction("notify", (handle1, handle2) => {
-    const arg1 = vm.dump(handle1);
-    const arg2 = vm.dump(handle2);
+  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(
-    vm,
-    `(notify, promise) => { promise.then(d => notify("resolved", d), d => notify("rejected", d)); }`
+    ctx,
+    `(notify, promise) => { promise.then(d => notify("resolved", d), d => notify("rejected", d)); }`,
   );
   disposables.push(notifier);
 
@@ -44,7 +43,7 @@ const testPromise = (reject: boolean) => async () => {
   if (reject) {
     deferred.promise.catch(() => {});
   }
-  const handle = marshalPromise(vm, deferred.promise, marshal, preMarshal);
+  const handle = marshalPromise(ctx, deferred.promise, marshal, preMarshal);
   if (!handle) throw new Error("handle is undefined");
 
   expect(marshal).toBeCalledTimes(0);
@@ -56,7 +55,7 @@ const testPromise = (reject: boolean) => async () => {
 
   expect(mockNotify).toBeCalledTimes(0);
   expect(deferred.resolve).not.toBeUndefined();
-  expect(vm.hasPendingJob()).toBe(false);
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
 
   if (reject) {
     deferred.reject("hoge");
@@ -64,22 +63,22 @@ const testPromise = (reject: boolean) => async () => {
     deferred.resolve("hoge");
   }
 
-  expect(vm.hasPendingJob()).toBe(false);
+  expect(ctx.runtime.hasPendingJob()).toBe(false);
   if (reject) {
     await expect(deferred.promise).rejects.toBe("hoge");
   } else {
     await expect(deferred.promise).resolves.toBe("hoge");
   }
-  expect(vm.hasPendingJob()).toBe(true);
-  const executed = vm.unwrapResult(vm.executePendingJobs());
+  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());
-  vm.dispose();
+  disposables.forEach(h => h.dispose());
+  ctx.dispose();
 };
 
 test("resolve", testPromise(false));

package/src/marshal/promise.ts

@@ -1,25 +1,18 @@
-import type {
-  QuickJSDeferredPromise,
-  QuickJSHandle,
-  QuickJSVm,
-} from "quickjs-emscripten";
+import type { QuickJSDeferredPromise, QuickJSHandle, QuickJSContext } from "quickjs-emscripten";
 
 export default function marshalPromise(
-  vm: QuickJSVm,
+  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 = vm.newPromise();
+  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,12 +2,13 @@ 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];
@@ -18,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 = vi.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 = () => {};
@@ -49,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 ctx = (await getQuickJS()).newContext();
   const marshal = vi.fn();
-  const handle = vm.newObject();
+  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();
 }