quickjs-emscripten-sync 1.4.0 → 1.5.0

package/dist/quickjs-emscripten-sync.es.js

@@ -1,962 +0,0 @@
-class VMMap {
-  constructor(ctx) {
-    this._map1 = /* @__PURE__ */ new Map();
-    this._map2 = /* @__PURE__ */ new Map();
-    this._map3 = /* @__PURE__ */ new Map();
-    this._map4 = /* @__PURE__ */ new Map();
-    this._counterMap = /* @__PURE__ */ new Map();
-    this._disposables = /* @__PURE__ */ new Set();
-    this._counter = 0;
-    this.ctx = ctx;
-    const result = ctx.unwrapResult(ctx.evalCode(`() => {
-        const mapSym = new Map();
-        let map = new WeakMap();
-        let map2 = new WeakMap();
-        const isObj = o => typeof o === "object" && o !== null || typeof o === "function";
-        return {
-          get: key => mapSym.get(key) ?? map.get(key) ?? map2.get(key) ?? -1,
-          set: (key, value, key2) => {
-            if (typeof key === "symbol") mapSym.set(key, value);
-            if (isObj(key)) map.set(key, value);
-            if (isObj(key2)) map2.set(key2, value);
-          },
-          delete: (key, key2) => {
-            mapSym.delete(key);
-            map.delete(key);
-            map2.delete(key2);
-          },
-          clear: () => {
-            mapSym.clear();
-            map = new WeakMap();
-            map2 = new WeakMap();
-          }
-        };
-      }`)).consume((fn2) => this._call(fn2, void 0));
-    this._mapGet = ctx.getProp(result, "get");
-    this._mapSet = ctx.getProp(result, "set");
-    this._mapDelete = ctx.getProp(result, "delete");
-    this._mapClear = ctx.getProp(result, "clear");
-    result.dispose();
-    this._disposables.add(this._mapGet);
-    this._disposables.add(this._mapSet);
-    this._disposables.add(this._mapDelete);
-    this._disposables.add(this._mapClear);
-  }
-  set(key, handle, key2, handle2) {
-    var _a;
-    if (!handle.alive || handle2 && !handle2.alive)
-      return false;
-    const v = (_a = this.get(key)) != null ? _a : this.get(key2);
-    if (v) {
-      return v === handle || v === handle2;
-    }
-    const counter = this._counter++;
-    this._map1.set(key, counter);
-    this._map3.set(counter, handle);
-    this._counterMap.set(counter, key);
-    if (key2) {
-      this._map2.set(key2, counter);
-      if (handle2) {
-        this._map4.set(counter, handle2);
-      }
-    }
-    this.ctx.newNumber(counter).consume((c) => {
-      this._call(this._mapSet, void 0, handle, c, handle2 != null ? handle2 : this.ctx.undefined);
-    });
-    return true;
-  }
-  merge(iteratable) {
-    if (!iteratable)
-      return;
-    for (const iter of iteratable) {
-      if (!iter)
-        continue;
-      if (iter[1]) {
-        this.set(iter[0], iter[1], iter[2], iter[3]);
-      }
-    }
-  }
-  get(key) {
-    var _a;
-    const num = (_a = this._map1.get(key)) != null ? _a : this._map2.get(key);
-    const handle = typeof num === "number" ? this._map3.get(num) : void 0;
-    if (!handle)
-      return;
-    if (!handle.alive) {
-      this.delete(key);
-      return;
-    }
-    return handle;
-  }
-  getByHandle(handle) {
-    if (!handle.alive) {
-      return;
-    }
-    return this._counterMap.get(this.ctx.getNumber(this._call(this._mapGet, void 0, handle)));
-  }
-  has(key) {
-    return !!this.get(key);
-  }
-  hasHandle(handle) {
-    return typeof this.getByHandle(handle) !== "undefined";
-  }
-  keys() {
-    return this._map1.keys();
-  }
-  delete(key, dispose) {
-    var _a;
-    const num = (_a = this._map1.get(key)) != null ? _a : this._map2.get(key);
-    if (typeof num === "undefined")
-      return;
-    const handle = this._map3.get(num);
-    const handle2 = this._map4.get(num);
-    this._call(this._mapDelete, void 0, ...[handle, handle2].filter((h) => !!(h == null ? void 0 : h.alive)));
-    this._map1.delete(key);
-    this._map2.delete(key);
-    this._map3.delete(num);
-    this._map4.delete(num);
-    for (const [k, v] of this._map1) {
-      if (v === num) {
-        this._map1.delete(k);
-        break;
-      }
-    }
-    for (const [k, v] of this._map2) {
-      if (v === num) {
-        this._map2.delete(k);
-        break;
-      }
-    }
-    for (const [k, v] of this._counterMap) {
-      if (v === key) {
-        this._counterMap.delete(k);
-        break;
-      }
-    }
-    if (dispose) {
-      if (handle == null ? void 0 : handle.alive)
-        handle.dispose();
-      if (handle2 == null ? void 0 : handle2.alive)
-        handle2.dispose();
-    }
-  }
-  deleteByHandle(handle, dispose) {
-    const key = this.getByHandle(handle);
-    if (typeof key !== "undefined") {
-      this.delete(key, dispose);
-    }
-  }
-  clear() {
-    this._counter = 0;
-    this._map1.clear();
-    this._map2.clear();
-    this._map3.clear();
-    this._map4.clear();
-    this._counterMap.clear();
-    if (this._mapClear.alive) {
-      this._call(this._mapClear, void 0);
-    }
-  }
-  dispose() {
-    for (const v of this._disposables.values()) {
-      if (v.alive) {
-        v.dispose();
-      }
-    }
-    for (const v of this._map3.values()) {
-      if (v.alive) {
-        v.dispose();
-      }
-    }
-    for (const v of this._map4.values()) {
-      if (v.alive) {
-        v.dispose();
-      }
-    }
-    this._disposables.clear();
-    this.clear();
-  }
-  get size() {
-    return this._map1.size;
-  }
-  [Symbol.iterator]() {
-    const keys = this._map1.keys();
-    return {
-      next: () => {
-        while (true) {
-          const k1 = keys.next();
-          if (k1.done)
-            return { value: void 0, done: true };
-          const n = this._map1.get(k1.value);
-          if (typeof n === "undefined")
-            continue;
-          const v1 = this._map3.get(n);
-          const v2 = this._map4.get(n);
-          if (!v1)
-            continue;
-          const k2 = this._get2(n);
-          return { value: [k1.value, v1, k2, v2], done: false };
-        }
-      }
-    };
-  }
-  _get2(num) {
-    for (const [k, v] of this._map2) {
-      if (v === num)
-        return k;
-    }
-  }
-  _call(fn2, thisArg, ...args) {
-    return this.ctx.unwrapResult(this.ctx.callFunction(fn2, typeof thisArg === "undefined" ? this.ctx.undefined : thisArg, ...args));
-  }
-}
-function isES2015Class(cls) {
-  return typeof cls === "function" && /^class\s/.test(Function.prototype.toString.call(cls));
-}
-function isObject(value) {
-  return typeof value === "function" || typeof value === "object" && value !== null;
-}
-function walkObject(value, callback) {
-  const set = /* @__PURE__ */ new Set();
-  const walk = (v) => {
-    if (!isObject(v) || set.has(v) || (callback == null ? void 0 : callback(v, set)) === false)
-      return;
-    set.add(v);
-    if (Array.isArray(v)) {
-      for (const e of v) {
-        walk(e);
-      }
-      return;
-    }
-    if (typeof v === "object") {
-      const proto = Object.getPrototypeOf(v);
-      if (proto && proto !== Object.prototype) {
-        walk(proto);
-      }
-    }
-    for (const d of Object.values(Object.getOwnPropertyDescriptors(v))) {
-      if ("value" in d)
-        walk(d.value);
-      if ("get" in d)
-        walk(d.get);
-      if ("set" in d)
-        walk(d.set);
-    }
-  };
-  walk(value);
-  return set;
-}
-function complexity(value, max) {
-  return walkObject(value, max ? (_, set) => set.size < max : void 0).size;
-}
-function newDeferred() {
-  let res = () => {
-  };
-  let rej = () => {
-  };
-  const promise = new Promise((resolve, reject) => {
-    res = resolve;
-    rej = reject;
-  });
-  return {
-    promise,
-    resolve: res,
-    reject: rej
-  };
-}
-function fn(ctx, code) {
-  const handle = ctx.unwrapResult(ctx.evalCode(code));
-  const f = (thisArg, ...args) => {
-    return ctx.unwrapResult(ctx.callFunction(handle, thisArg != null ? thisArg : ctx.undefined, ...args));
-  };
-  f.dispose = () => handle.dispose();
-  f.alive = true;
-  Object.defineProperty(f, "alive", {
-    get: () => handle.alive
-  });
-  return f;
-}
-function call(ctx, code, thisArg, ...args) {
-  const f = fn(ctx, code);
-  try {
-    return f(thisArg, ...args);
-  } finally {
-    f.dispose();
-  }
-}
-function eq(ctx, a, b) {
-  return ctx.dump(call(ctx, "Object.is", void 0, a, b));
-}
-function instanceOf(ctx, a, b) {
-  return ctx.dump(call(ctx, "(a, b) => a instanceof b", void 0, a, b));
-}
-function isHandleObject(ctx, h) {
-  return ctx.dump(call(ctx, `a => typeof a === "object" && a !== null || typeof a === "function"`, void 0, h));
-}
-function json(ctx, target) {
-  const json2 = JSON.stringify(target);
-  if (!json2)
-    return ctx.undefined;
-  return call(ctx, `JSON.parse`, void 0, ctx.newString(json2));
-}
-function consumeAll(handles, cb) {
-  try {
-    return cb(handles);
-  } finally {
-    for (const h of handles) {
-      if (h.alive)
-        h.dispose();
-    }
-  }
-}
-function mayConsume([handle, shouldBeDisposed], fn2) {
-  try {
-    return fn2(handle);
-  } finally {
-    if (shouldBeDisposed) {
-      handle.dispose();
-    }
-  }
-}
-function mayConsumeAll(handles, fn2) {
-  try {
-    return fn2(...handles.map((h) => h[0]));
-  } finally {
-    for (const [handle, shouldBeDisposed] of handles) {
-      if (shouldBeDisposed) {
-        handle.dispose();
-      }
-    }
-  }
-}
-function isQuickJSDeferredPromise(d) {
-  return "handle" in d;
-}
-function handleFrom(d) {
-  return isQuickJSDeferredPromise(d) ? d.handle : d;
-}
-function marshalProperties(ctx, target, handle, marshal2) {
-  const descs = ctx.newObject();
-  const cb = (key, desc2) => {
-    const keyHandle = marshal2(key);
-    const valueHandle = typeof desc2.value === "undefined" ? void 0 : marshal2(desc2.value);
-    const getHandle = typeof desc2.get === "undefined" ? void 0 : marshal2(desc2.get);
-    const setHandle = typeof desc2.set === "undefined" ? void 0 : marshal2(desc2.set);
-    ctx.newObject().consume((descObj) => {
-      Object.entries(desc2).forEach(([k, v]) => {
-        const v2 = k === "value" ? valueHandle : k === "get" ? getHandle : k === "set" ? setHandle : v ? ctx.true : ctx.false;
-        if (v2) {
-          ctx.setProp(descObj, k, v2);
-        }
-      });
-      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[k]));
-  call(ctx, `Object.defineProperties`, void 0, handle, descs).dispose();
-  descs.dispose();
-}
-function marshalFunction(ctx, target, marshal2, unmarshal2, preMarshal, preApply) {
-  var _a;
-  if (typeof target !== "function")
-    return;
-  const raw = ctx.newFunction(target.name, function(...argHandles) {
-    const that = unmarshal2(this);
-    const args = argHandles.map((a) => unmarshal2(a));
-    if (isES2015Class(target) && isObject(that)) {
-      const result = new target(...args);
-      Object.entries(result).forEach(([key, value]) => {
-        ctx.setProp(this, key, marshal2(value));
-      });
-      return this;
-    }
-    return marshal2(preApply ? preApply(target, that, args) : target.apply(that, args));
-  }).consume((handle2) => call(ctx, `Cls => {
-          const fn = function(...args) { return Cls.apply(this, args); };
-          fn.name = Cls.name;
-          fn.length = Cls.length;
-          return fn;
-        }`, void 0, handle2));
-  const handle = (_a = preMarshal(target, raw)) != null ? _a : raw;
-  marshalProperties(ctx, target, raw, marshal2);
-  return handle;
-}
-function marshalObject(ctx, target, marshal2, preMarshal) {
-  var _a;
-  if (typeof target !== "object" || target === null)
-    return;
-  const raw = Array.isArray(target) ? ctx.newArray() : ctx.newObject();
-  const handle = (_a = preMarshal(target, raw)) != null ? _a : raw;
-  const prototype = Object.getPrototypeOf(target);
-  const prototypeHandle = prototype && prototype !== Object.prototype && prototype !== Array.prototype ? marshal2(prototype) : void 0;
-  if (prototypeHandle) {
-    call(ctx, "Object.setPrototypeOf", void 0, handle, prototypeHandle).dispose();
-  }
-  marshalProperties(ctx, target, raw, marshal2);
-  return handle;
-}
-function marshalPrimitive(ctx, target) {
-  switch (typeof target) {
-    case "undefined":
-      return ctx.undefined;
-    case "number":
-      return ctx.newNumber(target);
-    case "string":
-      return ctx.newString(target);
-    case "boolean":
-      return target ? ctx.true : ctx.false;
-    case "object":
-      return target === null ? ctx.null : void 0;
-  }
-  return void 0;
-}
-function marshalSymbol(ctx, target, preMarshal) {
-  var _a;
-  if (typeof target !== "symbol")
-    return;
-  const handle = call(ctx, "d => Symbol(d)", void 0, target.description ? ctx.newString(target.description) : ctx.undefined);
-  return (_a = preMarshal(target, handle)) != null ? _a : handle;
-}
-function marshalJSON(ctx, target, preMarshal) {
-  var _a;
-  const raw = json(ctx, target);
-  const handle = (_a = preMarshal(target, raw)) != null ? _a : raw;
-  return handle;
-}
-function marshalPromise(ctx, target, marshal2, preMarshal) {
-  var _a;
-  if (!(target instanceof Promise))
-    return;
-  const promise = ctx.newPromise();
-  target.then((d) => promise.resolve(marshal2(d)), (d) => promise.reject(marshal2(d)));
-  return (_a = preMarshal(target, promise)) != null ? _a : promise.handle;
-}
-function marshal(target, options) {
-  var _a, _b, _c, _d;
-  const { ctx, unmarshal: unmarshal2, isMarshalable, find, pre } = options;
-  {
-    const primitive = marshalPrimitive(ctx, target);
-    if (primitive) {
-      return primitive;
-    }
-  }
-  {
-    const handle = find(target);
-    if (handle)
-      return handle;
-  }
-  const marshalable = isMarshalable == null ? void 0 : isMarshalable(target);
-  if (marshalable === false) {
-    return ctx.undefined;
-  }
-  const pre2 = (target2, handle) => pre(target2, handle, marshalable);
-  if (marshalable === "json") {
-    return marshalJSON(ctx, target, pre2);
-  }
-  const marshal2 = (t) => marshal(t, options);
-  return (_d = (_c = (_b = (_a = marshalSymbol(ctx, target, pre2)) != null ? _a : marshalPromise(ctx, target, marshal2, pre2)) != null ? _b : marshalFunction(ctx, target, marshal2, unmarshal2, pre2, options.preApply)) != null ? _c : marshalObject(ctx, target, marshal2, pre2)) != null ? _d : ctx.undefined;
-}
-function unmarshalProperties(ctx, handle, target, unmarshal2) {
-  ctx.newFunction("", (key, value) => {
-    const [keyName] = unmarshal2(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]
-    ].reduce((desc2, [key2, unmarshable]) => {
-      const h = ctx.getProp(value, key2);
-      const ty = ctx.typeof(h);
-      if (ty === "undefined")
-        return desc2;
-      if (!unmarshable && ty === "boolean") {
-        desc2[key2] = ctx.dump(ctx.getProp(value, key2));
-        return desc2;
-      }
-      const [v, alreadyExists] = unmarshal2(h);
-      if (alreadyExists) {
-        h.dispose();
-      }
-      desc2[key2] = v;
-      return desc2;
-    }, {});
-    Object.defineProperty(target, keyName, desc);
-  }).consume((fn2) => {
-    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]));
-      }`, void 0, handle, fn2).dispose();
-  });
-}
-function unmarshalFunction(ctx, handle, marshal2, unmarshal2, preUnmarshal) {
-  var _a;
-  if (ctx.typeof(handle) !== "function")
-    return;
-  const raw = function(...args) {
-    return mayConsumeAll([marshal2(this), ...args.map((a) => marshal2(a))], (thisHandle, ...argHandles) => {
-      if (new.target) {
-        const [instance] = unmarshal2(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 [result, alreadyExists] = unmarshal2(resultHandle);
-      if (alreadyExists)
-        resultHandle.dispose();
-      return result;
-    });
-  };
-  const func = (_a = preUnmarshal(raw, handle)) != null ? _a : raw;
-  unmarshalProperties(ctx, handle, raw, unmarshal2);
-  return func;
-}
-function unmarshalObject(ctx, handle, unmarshal2, preUnmarshal) {
-  var _a;
-  if (ctx.typeof(handle) !== "object" || ctx.unwrapResult(ctx.evalCode("o => o === null")).consume((n) => ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle)))))
-    return;
-  const raw = call(ctx, "Array.isArray", void 0, handle).consume((r) => ctx.dump(r)) ? [] : {};
-  const obj = (_a = preUnmarshal(raw, handle)) != null ? _a : raw;
-  const prototype = call(ctx, `o => {
-      const p = Object.getPrototypeOf(o);
-      return !p || p === Object.prototype || p === Array.prototype ? undefined : p;
-    }`, void 0, handle).consume((prototype2) => {
-    if (ctx.typeof(prototype2) === "undefined")
-      return;
-    const [proto] = unmarshal2(prototype2);
-    return proto;
-  });
-  if (typeof prototype === "object") {
-    Object.setPrototypeOf(obj, prototype);
-  }
-  unmarshalProperties(ctx, handle, raw, unmarshal2);
-  return obj;
-}
-function unmarshalPrimitive(ctx, handle) {
-  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 = ctx.unwrapResult(ctx.evalCode("a => a === null")).consume((n) => ctx.dump(ctx.unwrapResult(ctx.callFunction(n, ctx.undefined, handle))));
-    if (isNull) {
-      return [null, true];
-    }
-  }
-  return [void 0, false];
-}
-function unmarshalPromise(ctx, handle, marshal2, preUnmarshal) {
-  var _a;
-  if (!isPromiseHandle(ctx, handle))
-    return;
-  const deferred = newDeferred();
-  const [resHandle, resShouldBeDisposed] = marshal2(deferred.resolve);
-  const [rejHandle, rejShouldBeDisposed] = marshal2(deferred.reject);
-  call(ctx, "(p, res, rej) => { p.then(res, rej); }", void 0, handle, resHandle, rejHandle);
-  if (resShouldBeDisposed)
-    resHandle.dispose();
-  if (rejShouldBeDisposed)
-    rejHandle.dispose();
-  return (_a = preUnmarshal(deferred.promise, handle)) != null ? _a : deferred.promise;
-}
-function isPromiseHandle(ctx, handle) {
-  if (!handle.owner)
-    return false;
-  return ctx.unwrapResult(ctx.evalCode("Promise")).consume((promise) => {
-    if (!handle.owner)
-      return false;
-    return instanceOf(ctx, handle, promise);
-  });
-}
-function unmarshalSymbol(ctx, handle, preUnmarshal) {
-  var _a;
-  if (ctx.typeof(handle) !== "symbol")
-    return;
-  const desc = ctx.getString(ctx.getProp(handle, "description"));
-  const sym = Symbol(desc);
-  return (_a = preUnmarshal(sym, handle)) != null ? _a : sym;
-}
-function unmarshal(handle, options) {
-  const [result] = unmarshalInner(handle, options);
-  return result;
-}
-function unmarshalInner(handle, options) {
-  var _a, _b, _c;
-  const { ctx, marshal: marshal2, find, pre } = options;
-  {
-    const [target, ok] = unmarshalPrimitive(ctx, handle);
-    if (ok)
-      return [target, false];
-  }
-  {
-    const target = find(handle);
-    if (target) {
-      return [target, true];
-    }
-  }
-  const unmarshal2 = (h) => unmarshalInner(h, options);
-  const result = (_c = (_b = (_a = unmarshalSymbol(ctx, handle, pre)) != null ? _a : unmarshalPromise(ctx, handle, marshal2, pre)) != null ? _b : unmarshalFunction(ctx, handle, marshal2, unmarshal2, pre)) != null ? _c : unmarshalObject(ctx, handle, unmarshal2, pre);
-  return [result, false];
-}
-function wrap(ctx, target, proxyKeySymbol, proxyKeySymbolHandle, marshal2, syncMode) {
-  if (!isObject(target) || target instanceof Promise)
-    return void 0;
-  if (isWrapped(target, proxyKeySymbol))
-    return target;
-  const rec = new Proxy(target, {
-    get(obj, key) {
-      return key === proxyKeySymbol ? obj : Reflect.get(obj, key);
-    },
-    set(obj, key, value, receiver) {
-      var _a;
-      const v = unwrap(value, proxyKeySymbol);
-      const sync = (_a = syncMode == null ? void 0 : syncMode(receiver)) != null ? _a : "host";
-      if (sync !== "vm" && !Reflect.set(obj, key, v, receiver) || sync === "host" || !ctx.alive)
-        return true;
-      mayConsumeAll([marshal2(receiver), marshal2(key), marshal2(v)], (receiverHandle, keyHandle, valueHandle) => {
-        const [handle2, unwrapped] = unwrapHandle(ctx, receiverHandle, proxyKeySymbolHandle);
-        if (unwrapped) {
-          handle2.consume((h) => ctx.setProp(h, keyHandle, valueHandle));
-        } else {
-          ctx.setProp(handle2, keyHandle, valueHandle);
-        }
-      });
-      return true;
-    },
-    deleteProperty(obj, key) {
-      var _a;
-      const sync = (_a = syncMode == null ? void 0 : syncMode(rec)) != null ? _a : "host";
-      return mayConsumeAll([marshal2(rec), marshal2(key)], (recHandle, keyHandle) => {
-        const [handle2, unwrapped] = unwrapHandle(ctx, recHandle, proxyKeySymbolHandle);
-        if (sync === "vm" || Reflect.deleteProperty(obj, key)) {
-          if (sync === "host" || !ctx.alive)
-            return true;
-          if (unwrapped) {
-            handle2.consume((h) => call(ctx, `(a, b) => delete a[b]`, void 0, h, keyHandle));
-          } else {
-            call(ctx, `(a, b) => delete a[b]`, void 0, handle2, keyHandle);
-          }
-        }
-        return true;
-      });
-    }
-  });
-  return rec;
-}
-function wrapHandle(ctx, handle, proxyKeySymbol, proxyKeySymbolHandle, unmarshal2, syncMode) {
-  if (!isHandleObject(ctx, handle))
-    return [void 0, false];
-  if (isHandleWrapped(ctx, handle, proxyKeySymbolHandle))
-    return [handle, false];
-  return consumeAll([
-    ctx.newFunction("getSyncMode", (h) => {
-      const res = syncMode == null ? void 0 : syncMode(unmarshal2(h));
-      if (typeof res === "string")
-        return ctx.newString(res);
-      return ctx.undefined;
-    }),
-    ctx.newFunction("setter", (h, keyHandle, valueHandle) => {
-      const target = unmarshal2(h);
-      if (!target)
-        return;
-      const key = unmarshal2(keyHandle);
-      if (key === "__proto__")
-        return;
-      const value = unmarshal2(valueHandle);
-      unwrap(target, proxyKeySymbol)[key] = value;
-    }),
-    ctx.newFunction("deleter", (h, keyHandle) => {
-      const target = unmarshal2(h);
-      if (!target)
-        return;
-      const key = unmarshal2(keyHandle);
-      delete unwrap(target, proxyKeySymbol)[key];
-    })
-  ], (args) => [
-    call(ctx, `(target, sym, getSyncMode, setter, deleter) => {
-          const rec =  new Proxy(target, {
-            get(obj, key, receiver) {
-              return key === sym ? obj : Reflect.get(obj, key, receiver)
-            },
-            set(obj, key, value, receiver) {
-              const v = typeof value === "object" && value !== null || typeof value === "function"
-                ? value[sym] ?? value
-                : value;
-              const sync = getSyncMode(receiver) ?? "vm";
-              if (sync === "host" || Reflect.set(obj, key, v, receiver)) {
-                if (sync !== "vm") {
-                  setter(receiver, key, v);
-                }
-              }
-              return true;
-            },
-            deleteProperty(obj, key) {
-              const sync = getSyncMode(rec) ?? "vm";
-              if (sync === "host" || Reflect.deleteProperty(obj, key)) {
-                if (sync !== "vm") {
-                  deleter(rec, key);
-                }
-              }
-              return true;
-            },
-          });
-          return rec;
-        }`, void 0, handle, proxyKeySymbolHandle, ...args),
-    true
-  ]);
-}
-function unwrap(obj, key) {
-  var _a;
-  return isObject(obj) ? (_a = obj[key]) != null ? _a : obj : obj;
-}
-function unwrapHandle(ctx, handle, key) {
-  if (!isHandleWrapped(ctx, handle, key))
-    return [handle, false];
-  return [ctx.getProp(handle, key), true];
-}
-function isWrapped(obj, key) {
-  return isObject(obj) && !!obj[key];
-}
-function isHandleWrapped(ctx, handle, key) {
-  return !!ctx.dump(call(ctx, `(a, s) => (a instanceof Promise) || (typeof a === "object" && a !== null || typeof a === "function") && !!a[s]`, void 0, handle, key));
-}
-const defaultRegisteredObjects = [
-  [Symbol, "Symbol"],
-  [Symbol.prototype, "Symbol.prototype"],
-  [Object, "Object"],
-  [Object.prototype, "Object.prototype"],
-  [Function, "Function"],
-  [Function.prototype, "Function.prototype"],
-  [Boolean, "Boolean"],
-  [Boolean.prototype, "Boolean.prototype"],
-  [Array, "Array"],
-  [Array.prototype, "Array.prototype"],
-  [Error, "Error"],
-  [Error.prototype, "Error.prototype"],
-  [EvalError, "EvalError"],
-  [EvalError.prototype, "EvalError.prototype"],
-  [RangeError, "RangeError"],
-  [RangeError.prototype, "RangeError.prototype"],
-  [ReferenceError, "ReferenceError"],
-  [ReferenceError.prototype, "ReferenceError.prototype"],
-  [SyntaxError, "SyntaxError"],
-  [SyntaxError.prototype, "SyntaxError.prototype"],
-  [TypeError, "TypeError"],
-  [TypeError.prototype, "TypeError.prototype"],
-  [URIError, "URIError"],
-  [URIError.prototype, "URIError.prototype"],
-  ...Object.getOwnPropertyNames(Symbol).filter((k) => typeof Symbol[k] === "symbol").map((k) => [Symbol[k], `Symbol.${k}`])
-];
-class Arena {
-  constructor(ctx, options) {
-    var _a;
-    this._registeredMapDispose = /* @__PURE__ */ new Set();
-    this._sync = /* @__PURE__ */ new Set();
-    this._temporalSync = /* @__PURE__ */ new Set();
-    this._symbol = Symbol();
-    this._isMarshalable = (t) => {
-      var _a2, _b;
-      const im = (_a2 = this._options) == null ? void 0 : _a2.isMarshalable;
-      return (_b = typeof im === "function" ? im(this._unwrap(t)) : im) != null ? _b : "json";
-    };
-    this._marshalFind = (t) => {
-      var _a2, _b, _c;
-      const unwrappedT = this._unwrap(t);
-      const handle = (_c = (_b = (_a2 = this._registeredMap.get(t)) != null ? _a2 : unwrappedT !== t ? this._registeredMap.get(unwrappedT) : void 0) != null ? _b : this._map.get(t)) != null ? _c : unwrappedT !== t ? this._map.get(unwrappedT) : void 0;
-      return handle;
-    };
-    this._marshalPre = (t, h, mode) => {
-      var _a2;
-      if (mode === "json")
-        return;
-      return (_a2 = this._register(t, handleFrom(h), this._map)) == null ? void 0 : _a2[1];
-    };
-    this._marshalPreApply = (target, that, args) => {
-      const unwrapped = isObject(that) ? this._unwrap(that) : void 0;
-      if (unwrapped)
-        this._temporalSync.add(unwrapped);
-      try {
-        return target.apply(that, args);
-      } finally {
-        if (unwrapped)
-          this._temporalSync.delete(unwrapped);
-      }
-    };
-    this._marshal = (target) => {
-      var _a2;
-      const registered = this._registeredMap.get(target);
-      if (registered) {
-        return [registered, false];
-      }
-      const handle = marshal((_a2 = this._wrap(target)) != null ? _a2 : target, {
-        ctx: this.context,
-        unmarshal: this._unmarshal,
-        isMarshalable: this._isMarshalable,
-        find: this._marshalFind,
-        pre: this._marshalPre,
-        preApply: this._marshalPreApply
-      });
-      return [handle, !this._map.hasHandle(handle)];
-    };
-    this._preUnmarshal = (t, h) => {
-      var _a2;
-      return (_a2 = this._register(t, h, void 0, true)) == null ? void 0 : _a2[0];
-    };
-    this._unmarshalFind = (h) => {
-      var _a2;
-      return (_a2 = this._registeredMap.getByHandle(h)) != null ? _a2 : this._map.getByHandle(h);
-    };
-    this._unmarshal = (handle) => {
-      const registered = this._registeredMap.getByHandle(handle);
-      if (typeof registered !== "undefined") {
-        return registered;
-      }
-      const [wrappedHandle] = this._wrapHandle(handle);
-      return unmarshal(wrappedHandle != null ? wrappedHandle : handle, {
-        ctx: this.context,
-        marshal: this._marshal,
-        find: this._unmarshalFind,
-        pre: this._preUnmarshal
-      });
-    };
-    this._syncMode = (obj) => {
-      const obj2 = this._unwrap(obj);
-      return this._sync.has(obj2) || this._temporalSync.has(obj2) ? "both" : void 0;
-    };
-    this._unwrapIfNotSynced = (target) => {
-      const unwrapped = this._unwrap(target);
-      return unwrapped instanceof Promise || !this._sync.has(unwrapped) ? unwrapped : target;
-    };
-    if ((options == null ? void 0 : options.compat) && !("runtime" in ctx)) {
-      ctx.runtime = {
-        hasPendingJob: () => ctx.hasPendingJob(),
-        executePendingJobs: (maxJobsToExecute) => ctx.executePendingJobs(maxJobsToExecute)
-      };
-    }
-    this.context = ctx;
-    this._options = options;
-    this._symbolHandle = ctx.unwrapResult(ctx.evalCode(`Symbol()`));
-    this._map = new VMMap(ctx);
-    this._registeredMap = new VMMap(ctx);
-    this.registerAll((_a = options == null ? void 0 : options.registeredObjects) != null ? _a : defaultRegisteredObjects);
-  }
-  dispose() {
-    this._map.dispose();
-    this._registeredMap.dispose();
-    this._symbolHandle.dispose();
-  }
-  evalCode(code) {
-    const handle = this.context.evalCode(code);
-    return this._unwrapResultAndUnmarshal(handle);
-  }
-  executePendingJobs(maxJobsToExecute) {
-    const result = this.context.runtime.executePendingJobs(maxJobsToExecute);
-    if ("value" in result) {
-      return result.value;
-    }
-    throw this._unwrapIfNotSynced(result.error.consume(this._unmarshal));
-  }
-  expose(obj) {
-    for (const [key, value] of Object.entries(obj)) {
-      mayConsume(this._marshal(value), (handle) => {
-        this.context.setProp(this.context.global, key, handle);
-      });
-    }
-  }
-  sync(target) {
-    const wrapped = this._wrap(target);
-    if (typeof wrapped === "undefined")
-      return target;
-    walkObject(wrapped, (v) => {
-      const u = this._unwrap(v);
-      this._sync.add(u);
-    });
-    return wrapped;
-  }
-  register(target, handleOrCode) {
-    if (this._registeredMap.has(target))
-      return;
-    const handle = typeof handleOrCode === "string" ? this._unwrapResult(this.context.evalCode(handleOrCode)) : handleOrCode;
-    if (eq(this.context, handle, this.context.undefined))
-      return;
-    if (typeof handleOrCode === "string") {
-      this._registeredMapDispose.add(target);
-    }
-    this._registeredMap.set(target, handle);
-  }
-  registerAll(map) {
-    for (const [k, v] of map) {
-      this.register(k, v);
-    }
-  }
-  unregister(target, dispose) {
-    this._registeredMap.delete(target, this._registeredMapDispose.has(target) || dispose);
-    this._registeredMapDispose.delete(target);
-  }
-  unregisterAll(targets, dispose) {
-    for (const t of targets) {
-      this.unregister(t, dispose);
-    }
-  }
-  startSync(target) {
-    if (!isObject(target))
-      return;
-    const u = this._unwrap(target);
-    this._sync.add(u);
-  }
-  endSync(target) {
-    this._sync.delete(this._unwrap(target));
-  }
-  _unwrapResult(result) {
-    if ("value" in result) {
-      return result.value;
-    }
-    throw this._unwrapIfNotSynced(result.error.consume(this._unmarshal));
-  }
-  _unwrapResultAndUnmarshal(result) {
-    if (!result)
-      return;
-    return this._unwrapIfNotSynced(this._unwrapResult(result).consume(this._unmarshal));
-  }
-  _register(t, h, map = this._map, sync) {
-    if (this._registeredMap.has(t) || this._registeredMap.hasHandle(h)) {
-      return;
-    }
-    let wrappedT = this._wrap(t);
-    const [wrappedH] = this._wrapHandle(h);
-    const isPromise = t instanceof Promise;
-    if (!wrappedH || !wrappedT && !isPromise)
-      return;
-    if (isPromise)
-      wrappedT = t;
-    const unwrappedT = this._unwrap(t);
-    const [unwrappedH, unwrapped] = this._unwrapHandle(h);
-    const res = map.set(wrappedT, wrappedH, unwrappedT, unwrappedH);
-    if (!res) {
-      if (unwrapped)
-        unwrappedH.dispose();
-      throw new Error("already registered");
-    } else if (sync) {
-      this._sync.add(unwrappedT);
-    }
-    return [wrappedT, wrappedH];
-  }
-  _wrap(target) {
-    return wrap(this.context, target, this._symbol, this._symbolHandle, this._marshal, this._syncMode);
-  }
-  _unwrap(target) {
-    return unwrap(target, this._symbol);
-  }
-  _wrapHandle(handle) {
-    return wrapHandle(this.context, handle, this._symbol, this._symbolHandle, this._unmarshal, this._syncMode);
-  }
-  _unwrapHandle(target) {
-    return unwrapHandle(this.context, target, this._symbolHandle);
-  }
-}
-export { Arena, VMMap, call, complexity, consumeAll, defaultRegisteredObjects, eq, isES2015Class, isHandleObject, isObject, json, marshal, unmarshal, walkObject };