quickjs-emscripten-sync 1.0.0 → 1.3.0

package/src/vmmap.test.ts

@@ -1,4 +1,6 @@
 import { getQuickJS } from "quickjs-emscripten";
+import { expect, test } from "vitest";
+
 import VMMap from "./vmmap";
 import { call } from "./vmutil";
 
@@ -55,6 +57,26 @@ test("getByHandle", async () => {
   vm.dispose();
 });
 
+test("keys", async () => {
+  const quickjs = await getQuickJS();
+  const vm = quickjs.createVm();
+
+  const target = {};
+  const handle = vm.newObject();
+  const handle2 = vm.newObject();
+
+  const map = new VMMap(vm);
+  expect(Array.from(map.keys())).toEqual([]);
+  map.set(target, handle);
+  expect(Array.from(map.keys())).toEqual([target]);
+  handle.dispose();
+  expect(Array.from(map.keys())).toEqual([target]);
+
+  handle2.dispose();
+  map.dispose();
+  vm.dispose();
+});
+
 test("delete", async () => {
   const quickjs = await getQuickJS();
   const vm = quickjs.createVm();

package/src/vmmap.ts

@@ -44,7 +44,7 @@ export default class VMMap {
         };
       }`)
       )
-      .consume(fn => this._call(fn, undefined));
+      .consume((fn) => this._call(fn, undefined));
 
     this._mapGet = vm.getProp(result, "get");
     this._mapSet = vm.getProp(result, "set");
@@ -84,7 +84,7 @@ export default class VMMap {
       }
     }
 
-    this.vm.newNumber(counter).consume(c => {
+    this.vm.newNumber(counter).consume((c) => {
       this._call(
         this._mapSet,
         undefined,
@@ -144,6 +144,10 @@ export default class VMMap {
     return typeof this.getByHandle(handle) !== "undefined";
   }
 
+  keys() {
+    return this._map1.keys();
+  }
+
   delete(key: any, dispose?: boolean) {
     const num = this._map1.get(key) ?? this._map2.get(key);
     if (typeof num === "undefined") return;

package/src/vmutil.test.ts

@@ -1,13 +1,41 @@
-import { getQuickJS } from "quickjs-emscripten";
+import { getQuickJS, QuickJSHandle } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import {
+  fn,
   call,
   consumeAll,
   eq,
   instanceOf,
   isHandleObject,
-  send,
+  json,
+  mayConsume,
+  mayConsumeAll,
+  handleFrom,
 } from "./vmutil";
 
+test("fn", async () => {
+  const quickjs = await getQuickJS();
+  const vm = quickjs.createVm();
+
+  const f = fn(vm, "(a, b) => a + b");
+  expect(vm.getNumber(f(undefined, vm.newNumber(1), vm.newNumber(2)))).toBe(3);
+
+  const obj = vm.newObject();
+  vm.setProp(obj, "a", vm.newNumber(2));
+  const f2 = fn(vm, "(function() { return this.a + 1; })");
+  expect(vm.getNumber(f2(obj))).toBe(3);
+
+  obj.dispose();
+  expect(f.alive).toBe(true);
+  expect(f2.alive).toBe(true);
+  f2.dispose();
+  f.dispose();
+  expect(f.alive).toBe(false);
+  expect(f2.alive).toBe(false);
+  vm.dispose();
+});
+
 test("call", async () => {
   const quickjs = await getQuickJS();
   const vm = quickjs.createVm();
@@ -80,17 +108,17 @@ test("isHandleObject", async () => {
   vm.dispose();
 });
 
-test("send", async () => {
+test("json", async () => {
   const quickjs = await getQuickJS();
   const vm = quickjs.createVm();
 
-  const handle = send(vm, {
+  const handle = json(vm, {
     hoge: { foo: ["bar"] },
   });
   expect(
     vm.dump(call(vm, `a => a.hoge.foo[0] === "bar"`, undefined, handle))
   ).toBe(true);
-  expect(vm.typeof(send(vm, undefined))).toBe("undefined");
+  expect(vm.typeof(json(vm, undefined))).toBe("undefined");
 
   handle.dispose();
   vm.dispose();
@@ -106,10 +134,10 @@ test("consumeAll", async () => {
   expect(
     consumeAll(
       handles,
-      jest.fn(_ => o)
+      vi.fn(() => o)
     )
   ).toBe(o);
-  expect(handles.every(h => !h.alive)).toBe(true);
+  expect(handles.every((h) => !h.alive)).toBe(true);
 
   const handles2 = [vm.newObject(), vm.newObject()];
   expect(() =>
@@ -117,7 +145,87 @@ test("consumeAll", async () => {
       throw new Error("qes error");
     })
   ).toThrow("qes error");
-  expect(handles2.every(h => !h.alive)).toBe(true);
+  expect(handles2.every((h) => !h.alive)).toBe(true);
+
+  vm.dispose();
+});
 
+test("mayConsume", async () => {
+  const quickjs = await getQuickJS();
+  const vm = quickjs.createVm();
+
+  const o = {};
+
+  const handle = vm.newArray();
+  expect(
+    mayConsume(
+      [handle, false],
+      vi.fn(() => o)
+    )
+  ).toBe(o);
+  expect(handle.alive).toBe(true);
+
+  mayConsume([handle, true], () => {});
+  expect(handle.alive).toBe(false);
+
+  const handle2 = vm.newArray();
+  expect(() =>
+    mayConsume([handle2, true], () => {
+      throw new Error("qes error");
+    })
+  ).toThrow("qes error");
+  expect(handle.alive).toBe(false);
+
+  vm.dispose();
+});
+
+test("mayConsumeAll", async () => {
+  const quickjs = await getQuickJS();
+  const vm = quickjs.createVm();
+
+  const o = {};
+
+  const handles: [QuickJSHandle, boolean][] = [
+    [vm.newObject(), false],
+    [vm.newObject(), true],
+  ];
+  expect(
+    mayConsumeAll(
+      handles,
+      vi.fn((..._: any[]) => o)
+    )
+  ).toBe(o);
+  expect(handles[0][0].alive).toBe(true);
+  expect(handles[1][0].alive).toBe(false);
+
+  const handles2: [QuickJSHandle, boolean][] = [
+    [vm.newObject(), false],
+    [vm.newObject(), true],
+  ];
+  expect(() =>
+    mayConsumeAll(handles2, (..._args) => {
+      throw new Error("qes error");
+    })
+  ).toThrow("qes error");
+  expect(handles2[0][0].alive).toBe(true);
+  expect(handles2[1][0].alive).toBe(false);
+
+  handles[0][0].dispose();
+  handles2[0][0].dispose();
+  vm.dispose();
+});
+
+test("handleFrom", async () => {
+  const quickjs = await getQuickJS();
+  const vm = quickjs.createVm();
+
+  const handle = vm.newObject();
+  const promise = vm.newPromise();
+
+  expect(handleFrom(handle) === handle).toBe(true);
+  expect(handleFrom(promise) === promise.handle).toBe(true);
+
+  handle.dispose();
+  promise.dispose();
   vm.dispose();
 });

package/src/vmutil.ts

@@ -1,4 +1,34 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
+import type {
+  Disposable,
+  QuickJSVm,
+  QuickJSHandle,
+  QuickJSDeferredPromise,
+} from "quickjs-emscripten";
+
+export function fn(
+  vm: QuickJSVm,
+  code: string
+): ((
+  thisArg: QuickJSHandle | undefined,
+  ...args: QuickJSHandle[]
+) => QuickJSHandle) &
+  Disposable {
+  const handle = vm.unwrapResult(vm.evalCode(code));
+  const f = (
+    thisArg: QuickJSHandle | undefined,
+    ...args: QuickJSHandle[]
+  ): any => {
+    return vm.unwrapResult(
+      vm.callFunction(handle, thisArg ?? vm.undefined, ...args)
+    );
+  };
+  f.dispose = () => handle.dispose();
+  f.alive = true;
+  Object.defineProperty(f, "alive", {
+    get: () => handle.alive,
+  });
+  return f;
+}
 
 export function call(
   vm: QuickJSVm,
@@ -6,12 +36,12 @@ export function call(
   thisArg?: QuickJSHandle,
   ...args: QuickJSHandle[]
 ): QuickJSHandle {
-  return vm.unwrapResult(vm.evalCode(code)).consume(f => {
-    if (typeof thisArg === "undefined" && args.length === 0) return f;
-    return vm.unwrapResult(
-      vm.callFunction(f, thisArg ?? vm.undefined, ...args)
-    );
-  });
+  const f = fn(vm, code);
+  try {
+    return f(thisArg, ...args);
+  } finally {
+    f.dispose();
+  }
 }
 
 export function eq(vm: QuickJSVm, a: QuickJSHandle, b: QuickJSHandle): boolean {
@@ -37,7 +67,7 @@ export function isHandleObject(vm: QuickJSVm, a: QuickJSHandle): boolean {
   );
 }
 
-export function send(vm: QuickJSVm, target: any): QuickJSHandle {
+export function json(vm: QuickJSVm, target: any): QuickJSHandle {
   const json = JSON.stringify(target);
   if (!json) return vm.undefined;
   return call(vm, `JSON.parse`, undefined, vm.newString(json));
@@ -55,3 +85,41 @@ export function consumeAll<T extends QuickJSHandle[], K>(
     }
   }
 }
+
+export function mayConsume<T>(
+  [handle, shouldBeDisposed]: [QuickJSHandle, boolean],
+  fn: (h: QuickJSHandle) => T
+) {
+  try {
+    return fn(handle);
+  } finally {
+    if (shouldBeDisposed) {
+      handle.dispose();
+    }
+  }
+}
+
+export function mayConsumeAll<T, H extends QuickJSHandle[]>(
+  handles: { [P in keyof H]: [QuickJSHandle, boolean] },
+  fn: (...args: H) => T
+) {
+  try {
+    return fn(...(handles.map((h) => h[0]) as H));
+  } finally {
+    for (const [handle, shouldBeDisposed] of handles) {
+      if (shouldBeDisposed) {
+        handle.dispose();
+      }
+    }
+  }
+}
+
+function isQuickJSDeferredPromise(d: Disposable): d is QuickJSDeferredPromise {
+  return "handle" in d;
+}
+
+export function handleFrom(
+  d: QuickJSDeferredPromise | QuickJSHandle
+): QuickJSHandle {
+  return isQuickJSDeferredPromise(d) ? d.handle : d;
+}

package/src/wrapper.test.ts

@@ -1,4 +1,6 @@
 import { QuickJSHandle, getQuickJS } from "quickjs-emscripten";
+import { expect, test, vi } from "vitest";
+
 import {
   wrap,
   unwrap,
@@ -8,7 +10,7 @@ import {
   isHandleWrapped,
   SyncMode,
 } from "./wrapper";
-import { call, eq, send } from "./vmutil";
+import { call, eq, json } from "./vmutil";
 
 test("wrap, unwrap, isWrapped", async () => {
   const vm = (await getQuickJS()).createVm();
@@ -16,8 +18,8 @@ test("wrap, unwrap, isWrapped", async () => {
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn();
-  const syncMode = jest.fn();
+  const marshal = vi.fn();
+  const syncMode = vi.fn();
 
   expect(isWrapped(target, proxyKeySymbol)).toBe(false);
   expect(unwrap(target, proxyKeySymbol)).toBe(target);
@@ -51,8 +53,8 @@ test("wrap without sync", async () => {
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn();
-  const syncMode = jest.fn();
+  const marshal = vi.fn();
+  const syncMode = vi.fn();
 
   const wrapped = wrap(
     vm,
@@ -78,6 +80,9 @@ test("wrap without sync", async () => {
   proxyKeySymbolHandle.dispose();
   handle.dispose();
   vm.dispose();
+
+  wrapped.a = 3; // no error even if vm is disposed
+  expect(wrapped.a).toBe(3);
 });
 
 test("wrap with both sync", async () => {
@@ -86,10 +91,11 @@ test("wrap with both sync", async () => {
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn(
-    (t: any): QuickJSHandle => (t === wrapped ? handle : send(vm, t))
-  );
-  const syncMode = jest.fn((): SyncMode => "both");
+  const marshal = vi.fn((t: any): [QuickJSHandle, boolean] => [
+    t === wrapped ? handle : json(vm, t),
+    false,
+  ]);
+  const syncMode = vi.fn((): SyncMode => "both");
 
   const wrapped = wrap(
     vm,
@@ -121,6 +127,9 @@ test("wrap with both sync", async () => {
   proxyKeySymbolHandle.dispose();
   handle.dispose();
   vm.dispose();
+
+  wrapped.a = 3; // no error even if vm is disposed
+  expect(wrapped.a).toBe(3);
 });
 
 test("wrap with vm sync", async () => {
@@ -129,10 +138,11 @@ test("wrap with vm sync", async () => {
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn(
-    (t: any): QuickJSHandle => (t === wrapped ? handle : send(vm, t))
-  );
-  const syncMode = jest.fn((): SyncMode => "vm");
+  const marshal = vi.fn((t: any): [QuickJSHandle, boolean] => [
+    t === wrapped ? handle : json(vm, t),
+    false,
+  ]);
+  const syncMode = vi.fn((): SyncMode => "vm");
 
   const wrapped = wrap(
     vm,
@@ -164,6 +174,9 @@ test("wrap with vm sync", async () => {
   proxyKeySymbolHandle.dispose();
   handle.dispose();
   vm.dispose();
+
+  wrapped.a = 3; // no error even after vm is disposed
+  expect(wrapped.a).toBe(1); // vm mode cannot modify obj in host
 });
 
 test("wrapHandle, unwrapHandle, isHandleWrapped", async () => {
@@ -172,8 +185,8 @@ test("wrapHandle, unwrapHandle, isHandleWrapped", async () => {
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const unmarshal = jest.fn();
-  const syncMode = jest.fn();
+  const unmarshal = vi.fn();
+  const syncMode = vi.fn();
 
   expect(isHandleWrapped(vm, handle, proxyKeySymbolHandle)).toBe(false);
   expect(unwrapHandle(vm, handle, proxyKeySymbolHandle)).toEqual([
@@ -197,7 +210,7 @@ test("wrapHandle, unwrapHandle, isHandleWrapped", async () => {
 
   const [handle2, unwrapped2] = unwrapHandle(vm, wrapped, proxyKeySymbolHandle);
   expect(unwrapped2).toBe(true);
-  handle2.consume(h => {
+  handle2.consume((h) => {
     expect(eq(vm, handle, h)).toBe(true);
   });
 
@@ -223,10 +236,10 @@ test("wrapHandle without sync", async () => {
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const unmarshal = jest.fn((h: QuickJSHandle) =>
+  const unmarshal = vi.fn((h: QuickJSHandle) =>
     wrapped && eq(vm, h, wrapped) ? target : vm.dump(h)
   );
-  const syncMode = jest.fn();
+  const syncMode = vi.fn();
 
   const [wrapped, w] = wrapHandle(
     vm,
@@ -262,10 +275,10 @@ test("wrapHandle with both sync", async () => {
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const unmarshal = jest.fn((h: QuickJSHandle) => {
+  const unmarshal = vi.fn((h: QuickJSHandle) => {
     return wrapped && eq(vm, h, wrapped) ? target : vm.dump(h);
   });
-  const syncMode = jest.fn((): SyncMode => "both");
+  const syncMode = vi.fn((): SyncMode => "both");
 
   const [wrapped, w] = wrapHandle(
     vm,
@@ -314,10 +327,10 @@ test("wrapHandle with host sync", async () => {
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const unmarshal = jest.fn((handle: QuickJSHandle) =>
+  const unmarshal = vi.fn((handle: QuickJSHandle) =>
     wrapped && eq(vm, handle, wrapped) ? target : vm.dump(handle)
   );
-  const syncMode = jest.fn((): SyncMode => "host");
+  const syncMode = vi.fn((): SyncMode => "host");
 
   const [wrapped, w] = wrapHandle(
     vm,
@@ -359,14 +372,14 @@ test("wrap and wrapHandle", async () => {
   const handle = vm.unwrapResult(vm.evalCode(`({ a: 1 })`));
   const proxyKeySymbol = Symbol();
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
-  const marshal = jest.fn(
-    (t: any): QuickJSHandle =>
-      wrappedHandle && t === wrapped ? wrappedHandle : send(vm, t)
-  );
-  const unmarshal = jest.fn((handle: QuickJSHandle) =>
+  const marshal = vi.fn((t: any): [QuickJSHandle, boolean] => [
+    wrappedHandle && t === wrapped ? wrappedHandle : json(vm, t),
+    false,
+  ]);
+  const unmarshal = vi.fn((handle: QuickJSHandle) =>
     wrappedHandle && eq(vm, handle, wrappedHandle) ? wrapped : vm.dump(handle)
   );
-  const syncMode = jest.fn((): SyncMode => "both");
+  const syncMode = vi.fn((): SyncMode => "both");
 
   const wrapped = wrap(
     vm,
@@ -424,7 +437,7 @@ test("non object", async () => {
   const proxyKeySymbolHandle = vm.unwrapResult(vm.evalCode(`Symbol()`));
 
   expect(
-    wrap(vm, target, proxyKeySymbol, proxyKeySymbolHandle, jest.fn(), jest.fn())
+    wrap(vm, target, proxyKeySymbol, proxyKeySymbolHandle, vi.fn(), vi.fn())
   ).toBe(undefined);
 
   expect(
@@ -433,8 +446,8 @@ test("non object", async () => {
       handle,
       proxyKeySymbol,
       proxyKeySymbolHandle,
-      jest.fn(),
-      jest.fn()
+      vi.fn(),
+      vi.fn()
     )
   ).toEqual([undefined, false]);
 

package/src/wrapper.ts

@@ -1,6 +1,6 @@
 import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
 import { isObject } from "./util";
-import { call, isHandleObject, consumeAll } from "./vmutil";
+import { call, isHandleObject, consumeAll, mayConsumeAll } from "./vmutil";
 
 export type SyncMode = "both" | "vm" | "host";
 
@@ -11,7 +11,7 @@ export function wrap<T = any>(
   target: T,
   proxyKeySymbol: symbol,
   proxyKeySymbolHandle: QuickJSHandle,
-  marshal: (target: any) => QuickJSHandle,
+  marshal: (target: any) => [QuickJSHandle, boolean],
   syncMode?: (target: T) => SyncMode | undefined
 ): Wrapped<T> | undefined {
   if (!isObject(target)) return undefined;
@@ -24,39 +24,56 @@ export function wrap<T = any>(
     set(obj, key, value, receiver) {
       const v = unwrap(value, proxyKeySymbol);
       const sync = syncMode?.(receiver) ?? "host";
-      if (sync === "vm" || Reflect.set(obj, key, v, receiver)) {
-        if (sync === "host") return true;
-        const [handle2, unwrapped] = unwrapHandle(
-          vm,
-          marshal(receiver),
-          proxyKeySymbolHandle
-        );
-        if (unwrapped) {
-          handle2.consume(h => vm.setProp(h, marshal(key), marshal(v)));
-        } else {
-          vm.setProp(handle2, marshal(key), marshal(v));
+      if (
+        (sync !== "vm" && !Reflect.set(obj, key, v, receiver)) ||
+        sync === "host" ||
+        !vm.alive
+      )
+        return true;
+
+      mayConsumeAll(
+        [marshal(receiver), marshal(key), marshal(v)],
+        (receiverHandle, keyHandle, valueHandle) => {
+          const [handle2, unwrapped] = unwrapHandle(
+            vm,
+            receiverHandle,
+            proxyKeySymbolHandle
+          );
+          if (unwrapped) {
+            handle2.consume((h) => vm.setProp(h, keyHandle, valueHandle));
+          } else {
+            vm.setProp(handle2, keyHandle, valueHandle);
+          }
         }
-      }
+      );
+
       return true;
     },
     deleteProperty(obj, key) {
       const sync = syncMode?.(rec) ?? "host";
-      const [handle2, unwrapped] = unwrapHandle(
-        vm,
-        marshal(rec),
-        proxyKeySymbolHandle
-      );
-      if (sync === "vm" || Reflect.deleteProperty(obj, key)) {
-        if (sync === "host") return true;
-        if (unwrapped) {
-          handle2.consume(h =>
-            call(vm, `(a, b) => delete a[b]`, undefined, h, marshal(key))
+      return mayConsumeAll(
+        [marshal(rec), marshal(key)],
+        (recHandle, keyHandle) => {
+          const [handle2, unwrapped] = unwrapHandle(
+            vm,
+            recHandle,
+            proxyKeySymbolHandle
           );
-        } else {
-          call(vm, `(a, b) => delete a[b]`, undefined, handle2, marshal(key));
+
+          if (sync === "vm" || Reflect.deleteProperty(obj, key)) {
+            if (sync === "host" || !vm.alive) return true;
+
+            if (unwrapped) {
+              handle2.consume((h) =>
+                call(vm, `(a, b) => delete a[b]`, undefined, h, keyHandle)
+              );
+            } else {
+              call(vm, `(a, b) => delete a[b]`, undefined, handle2, keyHandle);
+            }
+          }
+          return true;
         }
-      }
-      return true;
+      );
     },
   }) as Wrapped<T>;
   return rec;
@@ -75,7 +92,7 @@ export function wrapHandle(
 
   return consumeAll(
     [
-      vm.newFunction("getSyncMode", h => {
+      vm.newFunction("getSyncMode", (h) => {
         const res = syncMode?.(unmarshal(h));
         if (typeof res === "string") return vm.newString(res);
         return vm.undefined;
@@ -95,7 +112,7 @@ export function wrapHandle(
         delete unwrap(target, proxyKeySymbol)[key];
       }),
     ],
-    args => [
+    (args) => [
       call(
         vm,
         `(target, sym, getSyncMode, setter, deleter) => {

package/dist/default.d.ts

@@ -1,4 +0,0 @@
-/**
- * Default value of registeredObjects option of the Arena class constructor.
- */
-export declare const defaultRegisteredObjects: [any, string][];

package/dist/index.js

@@ -1,8 +0,0 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./quickjs-emscripten-sync.cjs.production.min.js')
-} else {
-  module.exports = require('./quickjs-emscripten-sync.cjs.development.js')
-}

package/dist/marshal/array.d.ts

@@ -1,2 +0,0 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-export default function marshalArray(vm: QuickJSVm, target: unknown, marshal: (target: any) => QuickJSHandle, preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined): QuickJSHandle | undefined;

package/dist/marshal/function.d.ts

@@ -1,2 +0,0 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-export default function marshalFunction(vm: QuickJSVm, 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): QuickJSHandle | undefined;

package/dist/marshal/index.d.ts

@@ -1,11 +0,0 @@
-import { QuickJSHandle, QuickJSVm } from "quickjs-emscripten";
-export declare type Options = {
-    vm: QuickJSVm;
-    unmarshal: (handle: QuickJSHandle) => unknown;
-    isMarshalable?: (target: unknown) => boolean;
-    find: (target: unknown) => QuickJSHandle | undefined;
-    pre: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined;
-    preApply?: (target: Function, thisArg: unknown, args: unknown[]) => any;
-};
-export declare function marshal(target: unknown, options: Options): QuickJSHandle;
-export default marshal;

package/dist/marshal/object.d.ts

@@ -1,2 +0,0 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-export default function marshalObject(vm: QuickJSVm, target: unknown, marshal: (target: unknown) => QuickJSHandle, preMarshal: (target: unknown, handle: QuickJSHandle) => QuickJSHandle | undefined): QuickJSHandle | undefined;

package/dist/marshal/primitive.d.ts

@@ -1,2 +0,0 @@
-import { QuickJSVm, QuickJSHandle } from "quickjs-emscripten";
-export default function marshalPrimitive(vm: QuickJSVm, target: unknown): QuickJSHandle | undefined;