quickjs-emscripten-sync 1.0.0 → 1.3.0

package/src/unmarshal/index.test.ts

@@ -1,16 +1,12 @@
-import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { Disposable, getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import VMMap from "../vmmap";
 import unmarshal from ".";
+import { json } from "../vmutil";
 
 test("primitive, array, object", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const marshal = jest.fn(() => vm.undefined);
-  const map = new VMMap(vm);
-  const find = jest.fn(h => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
+  const { vm, unmarshal, marshal, map, dispose } = await setup();
 
   const handle = vm.unwrapResult(
     vm.evalCode(`({
@@ -21,7 +17,7 @@ test("primitive, array, object", async () => {
       bbb: () => "bar"
     })`)
   );
-  const target = unmarshal(handle, { vm, pre, find, marshal });
+  const target = unmarshal(handle);
 
   expect(target).toEqual({
     hoge: "foo",
@@ -32,16 +28,16 @@ test("primitive, array, object", async () => {
   });
   expect(map.size).toBe(5);
   expect(map.getByHandle(handle)).toBe(target);
-  vm.getProp(handle, "aaa").consume(h =>
+  vm.getProp(handle, "aaa").consume((h) =>
     expect(map.getByHandle(h)).toBe(target.aaa)
   );
   vm.getProp(handle, "aaa")
-    .consume(h => vm.getProp(h, 2))
-    .consume(h => expect(map.getByHandle(h)).toBe(target.aaa[2]));
-  vm.getProp(handle, "nested").consume(h =>
+    .consume((h) => vm.getProp(h, 2))
+    .consume((h) => expect(map.getByHandle(h)).toBe(target.aaa[2]));
+  vm.getProp(handle, "nested").consume((h) =>
     expect(map.getByHandle(h)).toBe(target.nested)
   );
-  vm.getProp(handle, "bbb").consume(h =>
+  vm.getProp(handle, "bbb").consume((h) =>
     expect(map.getByHandle(h)).toBe(target.bbb)
   );
 
@@ -50,18 +46,11 @@ test("primitive, array, object", async () => {
   expect(marshal).toBeCalledTimes(1);
   expect(marshal).toBeCalledWith(target); // thisArg of target.bbb()
 
-  handle.dispose();
-  map.dispose();
-  vm.dispose();
+  dispose();
 });
 
 test("object with symbol key", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const map = new VMMap(vm);
-  const pre = (t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  };
+  const { vm, unmarshal, dispose } = await setup();
 
   const handle = vm.unwrapResult(
     vm.evalCode(`({
@@ -69,79 +58,57 @@ test("object with symbol key", async () => {
       [Symbol("a")]: "bar"
     })`)
   );
-  const target = unmarshal(handle, {
-    vm,
-    pre,
-    find: () => undefined,
-    marshal: () => vm.undefined,
-  });
+  const target = unmarshal(handle);
 
   expect(target.hoge).toBe("foo");
   expect(target[Object.getOwnPropertySymbols(target)[0]]).toBe("bar");
 
-  handle.dispose();
-  map.dispose();
-  vm.dispose();
+  dispose();
 });
 
-test("func", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const jsonParse = vm.unwrapResult(vm.evalCode(`JSON.parse`));
-  const disposables: QuickJSHandle[] = [];
-  const marshal = jest.fn((t: unknown) => {
-    const h =
-      t === undefined
-        ? vm.undefined
-        : vm.unwrapResult(
-            vm.callFunction(
-              jsonParse,
-              vm.undefined,
-              vm.newString(JSON.stringify(t))
-            )
-          );
-    const ty = vm.typeof(h);
-    if (ty === "object" || ty === "function") disposables.push(h);
-    return h;
-  });
+test("function", async () => {
+  const { vm, unmarshal, marshal, map, dispose } = await setup();
 
   const handle = vm.unwrapResult(
     vm.evalCode(`(function(a) { return a.a + "!"; })`)
   );
-  const map = new VMMap(vm);
-  const find = jest.fn(h => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
-  const func = unmarshal(handle, { vm, find, pre, marshal });
+  const func = unmarshal(handle);
   const arg = { a: "hoge" };
   expect(func(arg)).toBe("hoge!");
   expect(marshal).toBeCalledTimes(2);
   expect(marshal).toBeCalledWith(undefined); // this
   expect(marshal).toBeCalledWith(arg); // arg
-  expect(map.size).toBe(2);
+  expect(map.size).toBe(3);
   expect(map.getByHandle(handle)).toBe(func);
+  expect(map.has(func)).toBe(true);
   expect(map.has(func.prototype)).toBe(true);
+  expect(map.has(arg)).toBe(true);
+
+  dispose();
+});
+
+test("promise", async () => {
+  const { vm, unmarshal, dispose } = await setup();
+
+  const deferred = vm.newPromise();
+  const promise = unmarshal(deferred.handle);
+  deferred.resolve(vm.newString("resolved!"));
+  vm.executePendingJobs();
+  await expect(promise).resolves.toBe("resolved!");
 
-  map.dispose();
-  disposables.forEach(d => d.dispose());
-  jsonParse.dispose();
-  vm.dispose();
+  const deferred2 = vm.newPromise();
+  const promise2 = unmarshal(deferred2.handle);
+  deferred2.reject(vm.newString("rejected!"));
+  vm.executePendingJobs();
+  await expect(promise2).rejects.toBe("rejected!");
+
+  deferred.dispose();
+  deferred2.dispose();
+  dispose();
 });
 
 test("class", async () => {
-  const vm = (await getQuickJS()).createVm();
-  const jsonParse = vm.unwrapResult(vm.evalCode(`JSON.parse`));
-  const disposables: QuickJSHandle[] = [];
-  const map = new VMMap(vm);
-  const marshal = jest.fn((t: unknown) => {
-    const h = vm.unwrapResult(
-      vm.callFunction(jsonParse, vm.undefined, vm.newString(JSON.stringify(t)))
-    );
-    const ty = vm.typeof(h);
-    if (ty === "object" || ty === "function") disposables.push(h);
-    return h;
-  });
+  const { vm, unmarshal, dispose } = await setup();
 
   const handle = vm.unwrapResult(
     vm.evalCode(`{
@@ -157,12 +124,7 @@ test("class", async () => {
       Cls
     }`)
   );
-  const find = jest.fn(h => map.getByHandle(h));
-  const pre = jest.fn((t: any, h: QuickJSHandle) => {
-    map.set(t, h);
-    return t;
-  });
-  const Cls = unmarshal(handle, { vm, find, pre, marshal });
+  const Cls = unmarshal(handle);
 
   expect(Cls.hoge).toBe("foo");
   expect(Cls.foo instanceof Cls).toBe(true);
@@ -172,8 +134,46 @@ test("class", async () => {
   expect(cls.foo).toBe(4);
 
   handle.dispose();
-  map.dispose();
-  disposables.forEach(d => d.dispose());
-  jsonParse.dispose();
-  vm.dispose();
+  dispose();
 });
+
+const setup = async () => {
+  const vm = (await getQuickJS()).createVm();
+  const map = new VMMap(vm);
+  const disposables: QuickJSHandle[] = [];
+  const marshal = vi.fn((target: unknown): [QuickJSHandle, boolean] => {
+    const handle = map.get(target);
+    if (handle) return [handle, false];
+
+    const handle2 =
+      typeof target === "function"
+        ? vm.newFunction(target.name, (...handles) => {
+            target(...handles.map((h) => vm.dump(h)));
+          })
+        : json(vm, target);
+    const ty = vm.typeof(handle2);
+    if (ty === "object" || ty === "function") map.set(target, handle2);
+    return [handle2, false];
+  });
+
+  return {
+    vm,
+    map,
+    unmarshal: (handle: QuickJSHandle) =>
+      unmarshal(handle, {
+        find: (h) => map.getByHandle(h),
+        marshal,
+        pre: (t, h) => {
+          map.set(t, h);
+          return t;
+        },
+        vm,
+      }),
+    marshal,
+    dispose: () => {
+      disposables.forEach((d) => d.dispose());
+      map.dispose();
+      vm.dispose();
+    },
+  };
+};

package/src/unmarshal/index.ts

@@ -1,15 +1,16 @@
 import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-import unmarshalArray from "./array";
 import unmarshalFunction from "./function";
 import unmarshalObject from "./object";
 import unmarshalPrimitive from "./primitive";
+import unmarshalPromise from "./promise";
 import unmarshalSymbol from "./symbol";
 
 export type Options = {
   vm: QuickJSVm;
-  marshal: (target: unknown) => QuickJSHandle;
+  /** marshal returns handle and boolean indicates that the handle should be disposed after use */
+  marshal: (target: unknown) => [QuickJSHandle, boolean];
   find: (handle: QuickJSHandle) => unknown | undefined;
-  pre: <T>(target: T, handle: QuickJSHandle) => T | undefined;
+  pre: <T = unknown>(target: T, handle: QuickJSHandle) => T | undefined;
 };
 
 export function unmarshal(handle: QuickJSHandle, options: Options): any {
@@ -39,7 +40,7 @@ function unmarshalInner(
 
   const result =
     unmarshalSymbol(vm, handle, pre) ??
-    unmarshalArray(vm, handle, unmarshal2, pre) ??
+    unmarshalPromise(vm, handle, marshal, pre) ??
     unmarshalFunction(vm, handle, marshal, unmarshal2, pre) ??
     unmarshalObject(vm, handle, unmarshal2, pre);
 

package/src/unmarshal/object.test.ts

@@ -1,13 +1,15 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import unmarshalObject from "./object";
 
 test("normal object", async () => {
   const vm = (await getQuickJS()).createVm();
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
     vm.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1, b: true })`));
   const obj = unmarshalObject(vm, handle, unmarshal, preUnmarshal);
@@ -28,11 +30,11 @@ test("normal object", async () => {
 test("properties", async () => {
   const vm = (await getQuickJS()).createVm();
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     disposables.push(v);
     return [vm.typeof(v) === "function" ? () => {} : vm.dump(v), false];
   });
-  const preUnmarshal = jest.fn(a => a);
+  const preUnmarshal = vi.fn((a) => a);
 
   const handle = vm.unwrapResult(
     vm.evalCode(`{
@@ -70,18 +72,44 @@ 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();
+});
+
+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 handle = vm.unwrapResult(vm.evalCode(`[1, true, "a"]`));
+  const array = unmarshalObject(vm, 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]);
+  expect(unmarshal.mock.results[1].value).toEqual([1, false]);
+  expect(unmarshal.mock.results[2].value).toEqual(["1", false]);
+  expect(unmarshal.mock.results[3].value).toEqual([true, false]);
+  expect(unmarshal.mock.results[4].value).toEqual(["2", false]);
+  expect(unmarshal.mock.results[5].value).toEqual(["a", false]);
+  expect(unmarshal.mock.results[6].value).toEqual(["length", false]);
+  expect(unmarshal.mock.results[7].value).toEqual([3, false]);
+  expect(preUnmarshal).toBeCalledWith(array, handle);
+
   handle.dispose();
   vm.dispose();
 });
 
 test("prototype", async () => {
   const vm = (await getQuickJS()).createVm();
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => [
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => [
     vm.typeof(v) === "object" ? { a: () => 1 } : vm.dump(v),
     false,
   ]);
-  const preUnmarshal = jest.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;
@@ -99,7 +127,7 @@ test("prototype", async () => {
 
 test("undefined", async () => {
   const vm = (await getQuickJS()).createVm();
-  const f = jest.fn();
+  const f = vi.fn();
 
   expect(unmarshalObject(vm, vm.undefined, f, f)).toEqual(undefined);
   expect(unmarshalObject(vm, vm.true, f, f)).toEqual(undefined);

package/src/unmarshal/object.ts

@@ -13,24 +13,28 @@ export default function unmarshalObject(
     // null check
     vm
       .unwrapResult(vm.evalCode("o => o === null"))
-      .consume(n =>
+      .consume((n) =>
         vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle)))
       )
   )
     return;
 
-  const raw = {};
+  const raw = call(vm, "Array.isArray", undefined, handle).consume((r) =>
+    vm.dump(r)
+  )
+    ? []
+    : {};
   const obj = preUnmarshal(raw, handle) ?? raw;
 
   const prototype = call(
     vm,
     `o => {
       const p = Object.getPrototypeOf(o);
-      return !p || p === Object.prototype ? undefined : p;
+      return !p || p === Object.prototype || p === Array.prototype ? undefined : p;
     }`,
     undefined,
     handle
-  ).consume(prototype => {
+  ).consume((prototype) => {
     if (vm.typeof(prototype) === "undefined") return;
     const [proto] = unmarshal(prototype);
     return proto;

package/src/unmarshal/primitive.test.ts

@@ -1,4 +1,6 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test } from "vitest";
+
 import unmarshalPrimitive from "./primitive";
 
 test("works", async () => {

package/src/unmarshal/primitive.ts

@@ -15,7 +15,7 @@ export default function unmarshalPrimitive(
   } else if (ty === "object") {
     const isNull = vm
       .unwrapResult(vm.evalCode("a => a === null"))
-      .consume(n =>
+      .consume((n) =>
         vm.dump(vm.unwrapResult(vm.callFunction(n, vm.undefined, handle)))
       );
     if (isNull) {
@@ -33,6 +33,5 @@ export default function unmarshalPrimitive(
   //   return [bi, true];
   // }
 
-  // symbol is not supported yet
   return [undefined, false];
 }

package/src/unmarshal/promise.test.ts

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

package/src/unmarshal/promise.ts

@@ -0,0 +1,40 @@
+import type { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+
+import { newDeferred } from "../util";
+import { call, instanceOf } from "../vmutil";
+
+export default function unmarshalPromise<T = unknown>(
+  vm: QuickJSVm,
+  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
+): Promise<T> | undefined {
+  if (!isPromiseHandle(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
+  );
+  if (resShouldBeDisposed) resHandle.dispose();
+  if (rejShouldBeDisposed) rejHandle.dispose();
+
+  return preUnmarshal(deferred.promise, handle) ?? deferred.promise;
+}
+
+function isPromiseHandle(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);
+    });
+}

package/src/unmarshal/properties.test.ts

@@ -1,10 +1,12 @@
 import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import unmarshalProperties from "./properties";
 
 test("works", async () => {
   const vm = (await getQuickJS()).createVm();
   const disposables: QuickJSHandle[] = [];
-  const unmarshal = jest.fn((v: QuickJSHandle): [unknown, boolean] => {
+  const unmarshal = vi.fn((v: QuickJSHandle): [unknown, boolean] => {
     disposables.push(v);
     return [vm.typeof(v) === "function" ? () => {} : vm.dump(v), false];
   });
@@ -45,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();
 });

package/src/unmarshal/properties.ts

@@ -16,14 +16,16 @@ export default function unmarshalProperties(
     )
       return;
 
-    const desc = ([
-      ["value", true],
-      ["get", true],
-      ["set", true],
-      ["configurable", false],
-      ["enumerable", false],
-      ["writable", false],
-    ] as const).reduce<PropertyDescriptor>((desc, [key, unmarshable]) => {
+    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);
 
@@ -43,7 +45,7 @@ export default function unmarshalProperties(
     }, {});
 
     Object.defineProperty(target, keyName, desc);
-  }).consume(fn => {
+  }).consume((fn) => {
     call(
       vm,
       `(o, fn) => {

package/src/unmarshal/symbol.test.ts

@@ -1,9 +1,11 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import unmarshalSymbol from "./symbol";
 
 test("works", async () => {
   const vm = (await getQuickJS()).createVm();
-  const pre = jest.fn();
+  const pre = vi.fn();
   const obj = vm.newObject();
   const handle = vm.unwrapResult(vm.evalCode(`Symbol("foobar")`));
 

package/src/util.test.ts

@@ -1,9 +1,16 @@
-import { isES2015Class, isObject, walkObject, complexity } from "./util";
+import { expect, test, vi } from "vitest";
+import {
+  isES2015Class,
+  isObject,
+  walkObject,
+  complexity,
+  newDeferred,
+} from "./util";
 
 test("isES2015Class", () => {
   expect(isES2015Class(class {})).toBe(true);
   expect(isES2015Class(class A {})).toBe(true);
-  expect(isES2015Class(function() {})).toBe(false);
+  expect(isES2015Class(function () {})).toBe(false);
   expect(isES2015Class(function A() {})).toBe(false);
   expect(isES2015Class(() => {})).toBe(false);
   expect(isES2015Class({})).toBe(false);
@@ -14,7 +21,7 @@ test("isES2015Class", () => {
 test("isObject", () => {
   expect(isObject({})).toBe(true);
   expect(isObject(Object.create(null))).toBe(true);
-  expect(isObject(function() {})).toBe(true);
+  expect(isObject(function () {})).toBe(true);
   expect(isObject(function A() {})).toBe(true);
   expect(isObject(() => {})).toBe(true);
   expect(isObject(class {})).toBe(true);
@@ -25,7 +32,7 @@ test("isObject", () => {
 });
 
 test("walkObject", () => {
-  const cb = jest.fn();
+  const cb = vi.fn();
   const obj = { a: { b: 1, c: () => {} } };
   const set = new Set<any>([obj, obj.a, obj.a.c]);
   expect(walkObject(obj, cb)).toEqual(set);
@@ -47,8 +54,18 @@ test("complexity", () => {
   expect(complexity({ a: 1 })).toBe(1);
   expect(complexity(() => {})).toBe(1);
   expect(complexity([{}])).toBe(2);
-  expect(complexity(function() {})).toBe(2);
+  expect(complexity(function () {})).toBe(2);
   expect(complexity(class {})).toBe(2);
   expect(complexity({ a: {} })).toBe(2);
   expect(complexity({ a: {} }, 1)).toBe(1);
 });
+
+test("newDeferred", () => {
+  const deferred = newDeferred();
+  deferred.resolve("foo");
+  expect(deferred.promise).resolves.toBe("foo");
+
+  const deferred2 = newDeferred();
+  deferred2.reject("bar");
+  expect(deferred2.promise).rejects.toBe("bar");
+});

package/src/util.ts

@@ -51,3 +51,18 @@ export function walkObject(
 export function complexity(value: any, max?: number): number {
   return walkObject(value, max ? (_, set) => set.size < max : undefined).size;
 }
+
+export function newDeferred<T = unknown>() {
+  let res: (v: T | PromiseLike<T>) => void = () => {};
+  let rej: (v: T | PromiseLike<T>) => void = () => {};
+  const promise = new Promise<T>((resolve, reject) => {
+    res = resolve;
+    rej = reject;
+  });
+
+  return {
+    promise,
+    resolve: res,
+    reject: rej,
+  };
+}