quickjs-emscripten-sync 1.2.0 → 1.5.0

package/dist/quickjs-emscripten-sync.mjs

@@ -0,0 +1,842 @@
+const F = [
+  [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((t) => typeof Symbol[t] == "symbol").map((t) => [Symbol[t], `Symbol.${t}`])
+];
+function A(t, e) {
+  const r = t.unwrapResult(t.evalCode(e)), o = (n, ...s) => t.unwrapResult(t.callFunction(r, n != null ? n : t.undefined, ...s));
+  return o.dispose = () => r.dispose(), o.alive = !0, Object.defineProperty(o, "alive", {
+    get: () => r.alive
+  }), o;
+}
+function d(t, e, r, ...o) {
+  const n = A(t, e);
+  try {
+    return n(r, ...o);
+  } finally {
+    n.dispose();
+  }
+}
+function N(t, e, r) {
+  return t.dump(d(t, "Object.is", void 0, e, r));
+}
+function B(t, e, r) {
+  return t.dump(d(t, "(a, b) => a instanceof b", void 0, e, r));
+}
+function J(t, e) {
+  return t.dump(
+    d(t, 'a => typeof a === "object" && a !== null || typeof a === "function"', void 0, e)
+  );
+}
+function I(t, e) {
+  const r = JSON.stringify(e);
+  return r ? d(t, "JSON.parse", void 0, t.newString(r)) : t.undefined;
+}
+function T(t, e) {
+  try {
+    return e(t);
+  } finally {
+    for (const r of t)
+      r.alive && r.dispose();
+  }
+}
+function U([t, e], r) {
+  try {
+    return r(t);
+  } finally {
+    e && t.dispose();
+  }
+}
+function w(t, e) {
+  try {
+    return e(...t.map((r) => r[0]));
+  } finally {
+    for (const [r, o] of t)
+      o && r.dispose();
+  }
+}
+function W(t) {
+  return "handle" in t;
+}
+function z(t) {
+  return W(t) ? t.handle : t;
+}
+function $(t, e, r, o) {
+  var s;
+  let n;
+  for (const i of o)
+    if (n = i(e, t), n)
+      break;
+  return n ? (s = r(e, n)) != null ? s : n : void 0;
+}
+function G(t, e) {
+  return typeof t != "symbol" ? void 0 : d(
+    e,
+    "d => Symbol(d)",
+    void 0,
+    t.description ? e.newString(t.description) : e.undefined
+  );
+}
+function q(t, e) {
+  return t instanceof Date ? d(e, "d => new Date(d)", void 0, e.newNumber(t.getTime())) : void 0;
+}
+const Q = [G, q];
+function V(t) {
+  return typeof t == "function" && /^class\s/.test(Function.prototype.toString.call(t));
+}
+function v(t) {
+  return typeof t == "function" || typeof t == "object" && t !== null;
+}
+function S(t, e) {
+  const r = /* @__PURE__ */ new Set(), o = (n) => {
+    if (!(!v(n) || r.has(n) || (e == null ? void 0 : e(n, r)) === !1)) {
+      if (r.add(n), Array.isArray(n)) {
+        for (const s of n)
+          o(s);
+        return;
+      }
+      if (typeof n == "object") {
+        const s = Object.getPrototypeOf(n);
+        s && s !== Object.prototype && o(s);
+      }
+      for (const s of Object.values(Object.getOwnPropertyDescriptors(n)))
+        "value" in s && o(s.value), "get" in s && o(s.get), "set" in s && o(s.set);
+    }
+  };
+  return o(t), r;
+}
+function de(t, e) {
+  return S(t, e ? (r, o) => o.size < e : void 0).size;
+}
+function L() {
+  let t = () => {
+  }, e = () => {
+  };
+  return {
+    promise: new Promise((o, n) => {
+      t = o, e = n;
+    }),
+    resolve: t,
+    reject: e
+  };
+}
+function E(t, e, r, o) {
+  const n = t.newObject(), s = (u, a) => {
+    const p = o(u), l = typeof a.value == "undefined" ? void 0 : o(a.value), f = typeof a.get == "undefined" ? void 0 : o(a.get), c = typeof a.set == "undefined" ? void 0 : o(a.set);
+    t.newObject().consume((h) => {
+      Object.entries(a).forEach(([m, y]) => {
+        const _ = m === "value" ? l : m === "get" ? f : m === "set" ? c : y ? t.true : t.false;
+        _ && t.setProp(h, m, _);
+      }), t.setProp(n, p, h);
+    });
+  }, i = Object.getOwnPropertyDescriptors(e);
+  Object.entries(i).forEach(([u, a]) => s(u, a)), Object.getOwnPropertySymbols(i).forEach((u) => s(u, i[u])), d(t, "Object.defineProperties", void 0, r, n).dispose(), n.dispose();
+}
+function X(t, e, r, o, n, s) {
+  var a;
+  if (typeof e != "function")
+    return;
+  const i = t.newFunction(e.name, function(...p) {
+    const l = o(this), f = p.map((c) => o(c));
+    if (V(e) && v(l)) {
+      const c = new e(...f);
+      return Object.entries(c).forEach(([h, m]) => {
+        t.setProp(this, h, r(m));
+      }), this;
+    }
+    return r(s ? s(e, l, f) : e.apply(l, f));
+  }).consume(
+    (p) => d(
+      t,
+      `Cls => {
+          const fn = function(...args) { return Cls.apply(this, args); };
+          fn.name = Cls.name;
+          fn.length = Cls.length;
+          return fn;
+        }`,
+      void 0,
+      p
+    )
+  ), u = (a = n(e, i)) != null ? a : i;
+  return E(t, e, i, r), u;
+}
+function Y(t, e, r) {
+  var s;
+  const o = I(t, e);
+  return (s = r(e, o)) != null ? s : o;
+}
+function Z(t, e, r, o) {
+  var a;
+  if (typeof e != "object" || e === null)
+    return;
+  const n = Array.isArray(e) ? t.newArray() : t.newObject(), s = (a = o(e, n)) != null ? a : n, i = Object.getPrototypeOf(e), u = i && i !== Object.prototype && i !== Array.prototype ? r(i) : void 0;
+  return u && d(t, "Object.setPrototypeOf", void 0, s, u).dispose(), E(t, e, n, r), s;
+}
+function K(t, e) {
+  switch (typeof e) {
+    case "undefined":
+      return t.undefined;
+    case "number":
+      return t.newNumber(e);
+    case "string":
+      return t.newString(e);
+    case "boolean":
+      return e ? t.true : t.false;
+    case "object":
+      return e === null ? t.null : void 0;
+  }
+}
+function x(t, e, r, o) {
+  var s;
+  if (!(e instanceof Promise))
+    return;
+  const n = t.newPromise();
+  return e.then(
+    (i) => n.resolve(r(i)),
+    (i) => n.reject(r(i))
+  ), (s = o(e, n)) != null ? s : n.handle;
+}
+function R(t, e) {
+  var l, f, c, h, m;
+  const { ctx: r, unmarshal: o, isMarshalable: n, find: s, pre: i } = e;
+  {
+    const y = K(r, t);
+    if (y)
+      return y;
+  }
+  {
+    const y = s(t);
+    if (y)
+      return y;
+  }
+  const u = n == null ? void 0 : n(t);
+  if (u === !1)
+    return r.undefined;
+  const a = (y, _) => i(y, _, u);
+  if (u === "json")
+    return Y(r, t, a);
+  const p = (y) => R(y, e);
+  return (m = (h = (c = (f = $(r, t, a, [...Q, ...(l = e.custom) != null ? l : []])) != null ? f : x(r, t, p, a)) != null ? c : X(r, t, p, o, a, e.preApply)) != null ? h : Z(r, t, p, a)) != null ? m : r.undefined;
+}
+function ee(t, e, r, o) {
+  var s;
+  let n;
+  for (const i of o)
+    if (n = i(e, t), n)
+      break;
+  return n ? (s = r(n, e)) != null ? s : n : void 0;
+}
+function te(t, e) {
+  if (e.typeof(t) !== "symbol")
+    return;
+  const r = e.getString(e.getProp(t, "description"));
+  return Symbol(r);
+}
+function re(t, e) {
+  if (!e.dump(d(e, "a => a instanceof Date", void 0, t)))
+    return;
+  const r = e.getNumber(d(e, "a => a.getTime()", void 0, t));
+  return new Date(r);
+}
+const ne = [te, re];
+function k(t, e, r, o) {
+  t.newFunction("", (n, s) => {
+    const [i] = o(n);
+    if (typeof i != "string" && typeof i != "number" && typeof i != "symbol")
+      return;
+    const u = [
+      ["value", !0],
+      ["get", !0],
+      ["set", !0],
+      ["configurable", !1],
+      ["enumerable", !1],
+      ["writable", !1]
+    ].reduce((a, [p, l]) => {
+      const f = t.getProp(s, p), c = t.typeof(f);
+      if (c === "undefined")
+        return a;
+      if (!l && c === "boolean")
+        return a[p] = t.dump(t.getProp(s, p)), a;
+      const [h, m] = o(f);
+      return m && f.dispose(), a[p] = h, a;
+    }, {});
+    Object.defineProperty(r, i, u);
+  }).consume((n) => {
+    d(
+      t,
+      `(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,
+      e,
+      n
+    ).dispose();
+  });
+}
+function se(t, e, r, o, n) {
+  var u;
+  if (t.typeof(e) !== "function")
+    return;
+  const s = function(...a) {
+    return w(
+      [r(this), ...a.map((p) => r(p))],
+      (p, ...l) => {
+        if (new.target) {
+          const [m] = o(
+            d(t, "(Cls, ...args) => new Cls(...args)", p, e, ...l)
+          );
+          return Object.defineProperties(this, Object.getOwnPropertyDescriptors(m)), this;
+        }
+        const f = t.unwrapResult(t.callFunction(e, p, ...l)), [c, h] = o(f);
+        return h && f.dispose(), c;
+      }
+    );
+  }, i = (u = n(s, e)) != null ? u : s;
+  return k(t, e, s, o), i;
+}
+function oe(t, e, r, o) {
+  var u;
+  if (t.typeof(e) !== "object" || t.unwrapResult(t.evalCode("o => o === null")).consume((a) => t.dump(t.unwrapResult(t.callFunction(a, t.undefined, e)))))
+    return;
+  const n = d(t, "Array.isArray", void 0, e).consume((a) => t.dump(a)) ? [] : {}, s = (u = o(n, e)) != null ? u : n, i = d(
+    t,
+    `o => {
+      const p = Object.getPrototypeOf(o);
+      return !p || p === Object.prototype || p === Array.prototype ? undefined : p;
+    }`,
+    void 0,
+    e
+  ).consume((a) => {
+    if (t.typeof(a) === "undefined")
+      return;
+    const [p] = r(a);
+    return p;
+  });
+  return typeof i == "object" && Object.setPrototypeOf(s, i), k(t, e, n, r), s;
+}
+function ie(t, e) {
+  const r = t.typeof(e);
+  return r === "undefined" || r === "number" || r === "string" || r === "boolean" ? [t.dump(e), !0] : r === "object" && t.unwrapResult(t.evalCode("a => a === null")).consume((n) => t.dump(t.unwrapResult(t.callFunction(n, t.undefined, e)))) ? [null, !0] : [void 0, !1];
+}
+function ue(t, e, r, o) {
+  var p;
+  if (!ae(t, e))
+    return;
+  const n = L(), [s, i] = r(n.resolve), [u, a] = r(n.reject);
+  return d(t, "(p, res, rej) => { p.then(res, rej); }", void 0, e, s, u), i && s.dispose(), a && u.dispose(), (p = o(n.promise, e)) != null ? p : n.promise;
+}
+function ae(t, e) {
+  return e.owner ? t.unwrapResult(t.evalCode("Promise")).consume((r) => e.owner ? B(t, e, r) : !1) : !1;
+}
+function pe(t, e) {
+  const [r] = M(t, e);
+  return r;
+}
+function M(t, e) {
+  var a, p, l, f;
+  const { ctx: r, marshal: o, find: n, pre: s } = e;
+  {
+    const [c, h] = ie(r, t);
+    if (h)
+      return [c, !1];
+  }
+  {
+    const c = n(t);
+    if (c)
+      return [c, !0];
+  }
+  const i = (c) => M(c, e);
+  return [(f = (l = (p = ee(r, t, s, [...ne, ...(a = e.custom) != null ? a : []])) != null ? p : ue(r, t, o, s)) != null ? l : se(r, t, o, i, s)) != null ? f : oe(r, t, i, s), !1];
+}
+class O {
+  constructor(e) {
+    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 = e;
+    const r = e.unwrapResult(
+      e.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((o) => this._call(o, void 0));
+    this._mapGet = e.getProp(r, "get"), this._mapSet = e.getProp(r, "set"), this._mapDelete = e.getProp(r, "delete"), this._mapClear = e.getProp(r, "clear"), r.dispose(), this._disposables.add(this._mapGet), this._disposables.add(this._mapSet), this._disposables.add(this._mapDelete), this._disposables.add(this._mapClear);
+  }
+  set(e, r, o, n) {
+    var u;
+    if (!r.alive || n && !n.alive)
+      return !1;
+    const s = (u = this.get(e)) != null ? u : this.get(o);
+    if (s)
+      return s === r || s === n;
+    const i = this._counter++;
+    return this._map1.set(e, i), this._map3.set(i, r), this._counterMap.set(i, e), o && (this._map2.set(o, i), n && this._map4.set(i, n)), this.ctx.newNumber(i).consume((a) => {
+      this._call(this._mapSet, void 0, r, a, n != null ? n : this.ctx.undefined);
+    }), !0;
+  }
+  merge(e) {
+    if (!!e)
+      for (const r of e)
+        !r || r[1] && this.set(r[0], r[1], r[2], r[3]);
+  }
+  get(e) {
+    var n;
+    const r = (n = this._map1.get(e)) != null ? n : this._map2.get(e), o = typeof r == "number" ? this._map3.get(r) : void 0;
+    if (!!o) {
+      if (!o.alive) {
+        this.delete(e);
+        return;
+      }
+      return o;
+    }
+  }
+  getByHandle(e) {
+    if (!!e.alive)
+      return this._counterMap.get(this.ctx.getNumber(this._call(this._mapGet, void 0, e)));
+  }
+  has(e) {
+    return !!this.get(e);
+  }
+  hasHandle(e) {
+    return typeof this.getByHandle(e) != "undefined";
+  }
+  keys() {
+    return this._map1.keys();
+  }
+  delete(e, r) {
+    var i;
+    const o = (i = this._map1.get(e)) != null ? i : this._map2.get(e);
+    if (typeof o == "undefined")
+      return;
+    const n = this._map3.get(o), s = this._map4.get(o);
+    this._call(
+      this._mapDelete,
+      void 0,
+      ...[n, s].filter((u) => !!(u != null && u.alive))
+    ), this._map1.delete(e), this._map2.delete(e), this._map3.delete(o), this._map4.delete(o);
+    for (const [u, a] of this._map1)
+      if (a === o) {
+        this._map1.delete(u);
+        break;
+      }
+    for (const [u, a] of this._map2)
+      if (a === o) {
+        this._map2.delete(u);
+        break;
+      }
+    for (const [u, a] of this._counterMap)
+      if (a === e) {
+        this._counterMap.delete(u);
+        break;
+      }
+    r && (n != null && n.alive && n.dispose(), s != null && s.alive && s.dispose());
+  }
+  deleteByHandle(e, r) {
+    const o = this.getByHandle(e);
+    typeof o != "undefined" && this.delete(o, r);
+  }
+  clear() {
+    this._counter = 0, this._map1.clear(), this._map2.clear(), this._map3.clear(), this._map4.clear(), this._counterMap.clear(), this._mapClear.alive && this._call(this._mapClear, void 0);
+  }
+  dispose() {
+    for (const e of this._disposables.values())
+      e.alive && e.dispose();
+    for (const e of this._map3.values())
+      e.alive && e.dispose();
+    for (const e of this._map4.values())
+      e.alive && e.dispose();
+    this._disposables.clear(), this.clear();
+  }
+  get size() {
+    return this._map1.size;
+  }
+  [Symbol.iterator]() {
+    const e = this._map1.keys();
+    return {
+      next: () => {
+        for (; ; ) {
+          const r = e.next();
+          if (r.done)
+            return { value: void 0, done: !0 };
+          const o = this._map1.get(r.value);
+          if (typeof o == "undefined")
+            continue;
+          const n = this._map3.get(o), s = this._map4.get(o);
+          if (!n)
+            continue;
+          const i = this._get2(o);
+          return { value: [r.value, n, i, s], done: !1 };
+        }
+      }
+    };
+  }
+  _get2(e) {
+    for (const [r, o] of this._map2)
+      if (o === e)
+        return r;
+  }
+  _call(e, r, ...o) {
+    return this.ctx.unwrapResult(
+      this.ctx.callFunction(
+        e,
+        typeof r == "undefined" ? this.ctx.undefined : r,
+        ...o
+      )
+    );
+  }
+}
+function fe(t, e, r, o, n, s, i) {
+  if (!v(e) || e instanceof Promise || e instanceof Date || i && !i(e))
+    return;
+  if (ce(e, r))
+    return e;
+  const u = new Proxy(e, {
+    get(a, p) {
+      return p === r ? a : Reflect.get(a, p);
+    },
+    set(a, p, l, f) {
+      var m;
+      const c = b(l, r), h = (m = s == null ? void 0 : s(f)) != null ? m : "host";
+      return h !== "vm" && !Reflect.set(a, p, c, f) || h === "host" || !t.alive || w(
+        [n(f), n(p), n(c)],
+        (y, _, j) => {
+          const [P, C] = g(t, y, o);
+          C ? P.consume((D) => t.setProp(D, _, j)) : t.setProp(P, _, j);
+        }
+      ), !0;
+    },
+    deleteProperty(a, p) {
+      var f;
+      const l = (f = s == null ? void 0 : s(u)) != null ? f : "host";
+      return w([n(u), n(p)], (c, h) => {
+        const [m, y] = g(t, c, o);
+        if (l === "vm" || Reflect.deleteProperty(a, p)) {
+          if (l === "host" || !t.alive)
+            return !0;
+          y ? m.consume((_) => d(t, "(a, b) => delete a[b]", void 0, _, h)) : d(t, "(a, b) => delete a[b]", void 0, m, h);
+        }
+        return !0;
+      });
+    }
+  });
+  return u;
+}
+function le(t, e, r, o, n, s, i) {
+  return !J(t, e) || i && !i(e, t) ? [void 0, !1] : H(t, e, o) ? [e, !1] : T(
+    [
+      t.newFunction("getSyncMode", (u) => {
+        const a = s == null ? void 0 : s(n(u));
+        return typeof a == "string" ? t.newString(a) : t.undefined;
+      }),
+      t.newFunction("setter", (u, a, p) => {
+        const l = n(u);
+        if (!l)
+          return;
+        const f = n(a);
+        if (f === "__proto__")
+          return;
+        const c = n(p);
+        b(l, r)[f] = c;
+      }),
+      t.newFunction("deleter", (u, a) => {
+        const p = n(u);
+        if (!p)
+          return;
+        const l = n(a);
+        delete b(p, r)[l];
+      })
+    ],
+    (u) => [
+      d(
+        t,
+        `(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,
+        e,
+        o,
+        ...u
+      ),
+      !0
+    ]
+  );
+}
+function b(t, e) {
+  var r;
+  return v(t) && (r = t[e]) != null ? r : t;
+}
+function g(t, e, r) {
+  return H(t, e, r) ? [t.getProp(e, r), !0] : [e, !1];
+}
+function ce(t, e) {
+  return v(t) && !!t[e];
+}
+function H(t, e, r) {
+  return !!t.dump(
+    d(
+      t,
+      '(a, s) => (a instanceof Promise) || (a instanceof Date) || (typeof a === "object" && a !== null || typeof a === "function") && !!a[s]',
+      void 0,
+      e,
+      r
+    )
+  );
+}
+class he {
+  constructor(e, r) {
+    var o;
+    this._registeredMapDispose = /* @__PURE__ */ new Set(), this._sync = /* @__PURE__ */ new Set(), this._temporalSync = /* @__PURE__ */ new Set(), this._symbol = Symbol(), this._isMarshalable = (n) => {
+      var i, u;
+      const s = (i = this._options) == null ? void 0 : i.isMarshalable;
+      return (u = typeof s == "function" ? s(this._unwrap(n)) : s) != null ? u : "json";
+    }, this._marshalFind = (n) => {
+      var u, a, p;
+      const s = this._unwrap(n);
+      return (p = (a = (u = this._registeredMap.get(n)) != null ? u : s !== n ? this._registeredMap.get(s) : void 0) != null ? a : this._map.get(n)) != null ? p : s !== n ? this._map.get(s) : void 0;
+    }, this._marshalPre = (n, s, i) => {
+      var u;
+      if (i !== "json")
+        return (u = this._register(n, z(s), this._map)) == null ? void 0 : u[1];
+    }, this._marshalPreApply = (n, s, i) => {
+      const u = v(s) ? this._unwrap(s) : void 0;
+      u && this._temporalSync.add(u);
+      try {
+        return n.apply(s, i);
+      } finally {
+        u && this._temporalSync.delete(u);
+      }
+    }, this._marshal = (n) => {
+      var u, a;
+      const s = this._registeredMap.get(n);
+      if (s)
+        return [s, !1];
+      const i = R((u = this._wrap(n)) != null ? u : n, {
+        ctx: this.context,
+        unmarshal: this._unmarshal,
+        isMarshalable: this._isMarshalable,
+        find: this._marshalFind,
+        pre: this._marshalPre,
+        preApply: this._marshalPreApply,
+        custom: (a = this._options) == null ? void 0 : a.customMarshaller
+      });
+      return [i, !this._map.hasHandle(i)];
+    }, this._preUnmarshal = (n, s) => {
+      var i;
+      return (i = this._register(n, s, void 0, !0)) == null ? void 0 : i[0];
+    }, this._unmarshalFind = (n) => {
+      var s;
+      return (s = this._registeredMap.getByHandle(n)) != null ? s : this._map.getByHandle(n);
+    }, this._unmarshal = (n) => {
+      var u;
+      const s = this._registeredMap.getByHandle(n);
+      if (typeof s != "undefined")
+        return s;
+      const [i] = this._wrapHandle(n);
+      return pe(i != null ? i : n, {
+        ctx: this.context,
+        marshal: this._marshal,
+        find: this._unmarshalFind,
+        pre: this._preUnmarshal,
+        custom: (u = this._options) == null ? void 0 : u.customUnmarshaller
+      });
+    }, this._syncMode = (n) => {
+      const s = this._unwrap(n);
+      return this._sync.has(s) || this._temporalSync.has(s) ? "both" : void 0;
+    }, this._unwrapIfNotSynced = (n) => {
+      const s = this._unwrap(n);
+      return s instanceof Promise || !this._sync.has(s) ? s : n;
+    }, (r == null ? void 0 : r.compat) && !("runtime" in e) && (e.runtime = {
+      hasPendingJob: () => e.hasPendingJob(),
+      executePendingJobs: (n) => e.executePendingJobs(n)
+    }), this.context = e, this._options = r, this._symbolHandle = e.unwrapResult(e.evalCode("Symbol()")), this._map = new O(e), this._registeredMap = new O(e), this.registerAll((o = r == null ? void 0 : r.registeredObjects) != null ? o : F);
+  }
+  dispose() {
+    this._map.dispose(), this._registeredMap.dispose(), this._symbolHandle.dispose();
+  }
+  evalCode(e) {
+    const r = this.context.evalCode(e);
+    return this._unwrapResultAndUnmarshal(r);
+  }
+  executePendingJobs(e) {
+    const r = this.context.runtime.executePendingJobs(e);
+    if ("value" in r)
+      return r.value;
+    throw this._unwrapIfNotSynced(r.error.consume(this._unmarshal));
+  }
+  expose(e) {
+    for (const [r, o] of Object.entries(e))
+      U(this._marshal(o), (n) => {
+        this.context.setProp(this.context.global, r, n);
+      });
+  }
+  sync(e) {
+    const r = this._wrap(e);
+    return typeof r == "undefined" ? e : (S(r, (o) => {
+      const n = this._unwrap(o);
+      this._sync.add(n);
+    }), r);
+  }
+  register(e, r) {
+    if (this._registeredMap.has(e))
+      return;
+    const o = typeof r == "string" ? this._unwrapResult(this.context.evalCode(r)) : r;
+    N(this.context, o, this.context.undefined) || (typeof r == "string" && this._registeredMapDispose.add(e), this._registeredMap.set(e, o));
+  }
+  registerAll(e) {
+    for (const [r, o] of e)
+      this.register(r, o);
+  }
+  unregister(e, r) {
+    this._registeredMap.delete(e, this._registeredMapDispose.has(e) || r), this._registeredMapDispose.delete(e);
+  }
+  unregisterAll(e, r) {
+    for (const o of e)
+      this.unregister(o, r);
+  }
+  startSync(e) {
+    if (!v(e))
+      return;
+    const r = this._unwrap(e);
+    this._sync.add(r);
+  }
+  endSync(e) {
+    this._sync.delete(this._unwrap(e));
+  }
+  _unwrapResult(e) {
+    if ("value" in e)
+      return e.value;
+    throw this._unwrapIfNotSynced(e.error.consume(this._unmarshal));
+  }
+  _unwrapResultAndUnmarshal(e) {
+    if (!!e)
+      return this._unwrapIfNotSynced(this._unwrapResult(e).consume(this._unmarshal));
+  }
+  _register(e, r, o = this._map, n) {
+    if (this._registeredMap.has(e) || this._registeredMap.hasHandle(r))
+      return;
+    let s = this._wrap(e);
+    const [i] = this._wrapHandle(r), u = e instanceof Promise;
+    if (!i || !s && !u)
+      return;
+    u && (s = e);
+    const a = this._unwrap(e), [p, l] = this._unwrapHandle(r);
+    if (o.set(s, i, a, p))
+      n && this._sync.add(a);
+    else
+      throw l && p.dispose(), new Error("already registered");
+    return [s, i];
+  }
+  _wrap(e) {
+    var r;
+    return fe(
+      this.context,
+      e,
+      this._symbol,
+      this._symbolHandle,
+      this._marshal,
+      this._syncMode,
+      (r = this._options) == null ? void 0 : r.isWrappable
+    );
+  }
+  _unwrap(e) {
+    return b(e, this._symbol);
+  }
+  _wrapHandle(e) {
+    var r;
+    return le(
+      this.context,
+      e,
+      this._symbol,
+      this._symbolHandle,
+      this._unmarshal,
+      this._syncMode,
+      (r = this._options) == null ? void 0 : r.isHandleWrappable
+    );
+  }
+  _unwrapHandle(e) {
+    return g(this.context, e, this._symbolHandle);
+  }
+}
+export {
+  he as Arena,
+  O as VMMap,
+  d as call,
+  de as complexity,
+  T as consumeAll,
+  F as defaultRegisteredObjects,
+  N as eq,
+  V as isES2015Class,
+  J as isHandleObject,
+  v as isObject,
+  I as json,
+  R as marshal,
+  pe as unmarshal,
+  S as walkObject
+};