@daneren2005/shared-memory-objects 0.0.11 → 0.0.13

package/dist/shared-memory-objects.js

@@ -1,48 +1,45 @@
-var Pt = Object.defineProperty;
-var Nt = (s, t, e) => t in s ? Pt(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
-var l = (s, t, e) => (Nt(s, typeof t != "symbol" ? t + "" : t, e), e);
-const Vt = 20, te = 12, q = Math.pow(2, 20), J = Math.pow(2, 12);
-function h(s, t = 0) {
-  return S(Atomics.load(s, t));
+const ie = 20, se = 12, J = Math.pow(2, 20), Q = Math.pow(2, 12);
+function c(s, t = 0) {
+  return A(Atomics.load(s, t));
 }
 function O(s, t = 0) {
   return Atomics.load(s, t);
 }
-function A(s, t = 0, e, r) {
-  Atomics.store(s, t, w(e, r));
+function m(s, t = 0, e, r) {
+  Atomics.store(s, t, T(e, r));
 }
 function W(s, t = 0, e) {
   Atomics.store(s, t, e);
 }
-function ee(s, t, e, r, i, o) {
-  let a = w(i, o);
-  return Atomics.compareExchange(s, t, a, w(e, r)) === a;
+function oe(s, t, e, r, i, o) {
+  let a = T(i, o);
+  return Atomics.compareExchange(s, t, a, T(e, r)) === a;
 }
-function $(s, t, e, r) {
+function z(s, t, e, r) {
   return Atomics.compareExchange(s, t, r, e) === r;
 }
-function S(s) {
+function A(s) {
   return {
     bufferPosition: s & 4095,
     bufferByteOffset: s >>> 12
   };
 }
-function w(s, t) {
+function T(s, t) {
   return s + (t << 12);
 }
-class c {
-  constructor(t, e) {
-    l(this, "memory");
-    l(this, "bufferPosition");
-    l(this, "buffer");
-    l(this, "data");
-    this.memory = t, "buffer" in e ? (this.data = e.data, this.buffer = e.buffer, this.bufferPosition = this.memory.buffers.indexOf(e.buffer)) : (this.bufferPosition = e.bufferPosition, this.buffer = t.buffers[e.bufferPosition], this.data = new Uint32Array(this.buffer.buf, e.bufferByteOffset));
-  }
+class h {
+  memory;
+  bufferPosition;
   get bufferByteOffset() {
     return this.data.byteOffset;
   }
   get pointer() {
-    return w(this.bufferPosition, this.bufferByteOffset);
+    return T(this.bufferPosition, this.bufferByteOffset);
+  }
+  buffer;
+  data;
+  constructor(t, e) {
+    this.memory = t, "buffer" in e ? (this.data = e.data, this.buffer = e.buffer, this.bufferPosition = this.memory.buffers.indexOf(e.buffer)) : (this.bufferPosition = e.bufferPosition, this.buffer = t.buffers[e.bufferPosition], this.data = new Uint32Array(this.buffer.buf, e.bufferByteOffset));
   }
   getArray(t, e, r) {
     return new t(this.data.buffer, this.data.byteOffset + e * t.BYTES_PER_ELEMENT, r);
@@ -63,15 +60,15 @@ class c {
     };
   }
 }
-const Z = 0, U = 1;
-function C(s, t = 0) {
-  for (; Atomics.compareExchange(s, t, Z, U) !== Z; )
-    "WorkerGlobalScope" in self && Atomics.wait(s, t, U);
+const v = 0, F = 1;
+function x(s, t = 0) {
+  for (; Atomics.compareExchange(s, t, v, F) !== v; )
+    "WorkerGlobalScope" in self && Atomics.wait(s, t, F);
 }
-function B(s, t = 0) {
-  Atomics.compareExchange(s, t, U, Z) !== U && console.warn("We are unlocking when it was not locked!"), Atomics.notify(s, t);
+function k(s, t = 0) {
+  Atomics.compareExchange(s, t, F, v) !== F && console.warn("We are unlocking when it was not locked!"), Atomics.notify(s, t);
 }
-const re = 1, It = {
+const ae = 1, Ft = {
   5120: "i8",
   5121: "u8",
   5122: "i16",
@@ -79,45 +76,43 @@ const re = 1, It = {
   5124: "i32",
   5125: "u32",
   5126: "f32"
-}, Ut = {
+}, xt = {
   f32: Float32Array,
   f64: Float64Array
-}, Ct = {
+}, Rt = {
   i8: Int8Array,
   i16: Int16Array,
   i32: Int32Array
-}, Dt = {
+}, $t = {
   u8: Uint8Array,
   u8c: Uint8ClampedArray,
   u16: Uint16Array,
   u32: Uint32Array
-}, Ft = {
-  // eslint-disable-next-line
+}, zt = {
   i64: BigInt64Array,
-  // eslint-disable-next-line
   u64: BigUint64Array
-}, xt = {
-  ...Ut,
-  ...Ct,
-  ...Dt
-}, Rt = (s) => {
-  const t = It[s];
+}, Yt = {
+  ...xt,
+  ...Rt,
+  ...$t
+}, Ht = (s) => {
+  const t = Ft[s];
   return t !== void 0 ? t : s;
 };
-function $t(s, ...t) {
-  const e = Ft[s];
-  return new (e || xt[Rt(s)])(...t);
+function Kt(s, ...t) {
+  const e = zt[s];
+  return new (e || Yt[Ht(s)])(...t);
 }
-const Q = 0, V = 1, tt = 2, et = 3, rt = 4, k = 5, it = 6, Y = 1, H = 2, st = 8 * 4, z = 0, K = 1, y = 2 * 4;
-class G {
+const tt = 0, et = 1, rt = 2, it = 3, st = 4, g = 5, ot = 6, Y = 1, H = 2, at = 32, K = 0, G = 1, d = 8;
+class V {
+  buf;
+  start;
+  u8;
+  u32;
+  state;
+  lock;
   constructor(t = {}) {
-    l(this, "buf");
-    l(this, "start");
-    l(this, "u8");
-    l(this, "u32");
-    l(this, "state");
-    l(this, "lock");
-    if (this.buf = t.buf ? t.buf : new ArrayBuffer(t.size || 4096), this.start = t.start != null ? M(Math.max(t.start, 0), 4) : 0, this.u8 = new Uint8Array(this.buf), this.u32 = new Uint32Array(this.buf), this.state = new Uint32Array(this.buf, this.start, st / 4), this.lock = new Int32Array(this.buf, this.start + this.state.byteLength - 4, 1), !t.skipInitialization) {
+    if (this.buf = t.buf ? t.buf : new ArrayBuffer(t.size || 4096), this.start = t.start != null ? N(Math.max(t.start, 0), 4) : 0, this.u8 = new Uint8Array(this.buf), this.u32 = new Uint32Array(this.buf), this.state = new Uint32Array(this.buf, this.start, at / 4), this.lock = new Int32Array(this.buf, this.start + this.state.byteLength - 4, 1), !t.skipInitialization) {
       const e = t.align || 8;
       if (e < 8)
         throw new Error(`invalid alignment: ${e}, must be a pow2 and >= 8`);
@@ -154,8 +149,8 @@ class G {
     return i && i.fill(r), i;
   }
   mallocAs(t, e) {
-    const r = this.malloc(e * Yt[t]);
-    return r ? $t(t, this.buf, r, e) : void 0;
+    const r = this.malloc(e * Gt[t]);
+    return r ? Kt(t, this.buf, r, e) : void 0;
   }
   calloc(t, e = 0) {
     const r = this.malloc(t);
@@ -164,33 +159,32 @@ class G {
   malloc(t) {
     if (t <= 0)
       return 0;
-    C(this.lock);
-    const e = M(t + y, this.align), r = this.end;
+    x(this.lock);
+    const e = N(t + d, this.align), r = this.end;
     let i = this.top, o = this._free, a = 0;
     for (; o; ) {
-      const n = this.blockSize(o), f = o + n >= i;
-      if (f || n >= e) {
-        let u = this.mallocTop(
+      const f = this.blockSize(o), n = o + f >= i;
+      if (n || f >= e) {
+        let l = this.mallocTop(
           o,
           a,
-          n,
+          f,
           e,
-          f
+          n
         );
-        return B(this.lock), u;
+        return k(this.lock), l;
       }
       a = o, o = this.blockNext(o);
     }
     if (o = i, i = o + e, i <= r) {
       this.initBlock(o, e, this._used), this._used = o, this.top = i;
-      let n = _(o);
-      return B(this.lock), n;
+      let f = _(o);
+      return k(this.lock), f;
     }
-    return B(this.lock), 0;
+    return k(this.lock), 0;
   }
   mallocTop(t, e, r, i, o) {
-    if (o && t + i > this.end)
-      return 0;
+    if (o && t + i > this.end) return 0;
     if (e ? this.unlinkBlock(e, t) : this._free = this.blockNext(t), this.setBlockNext(t, this._used), this._used = t, o)
       this.top = t + this.setBlockSize(t, i);
     else if (this.doSplit) {
@@ -202,7 +196,7 @@ class G {
   realloc(t, e) {
     if (e <= 0)
       return 0;
-    const r = L(t);
+    const r = P(t);
     let i = 0, o = this._used, a = 0;
     for (; o; ) {
       if (o === r) {
@@ -218,16 +212,15 @@ class G {
     ), _(i);
   }
   reallocBlock(t, e) {
-    const r = this.blockSize(t), i = t + r, o = i >= this.top, a = M(e + y, this.align);
+    const r = this.blockSize(t), i = t + r, o = i >= this.top, a = N(e + d, this.align);
     if (a <= r) {
       if (this.doSplit) {
-        const n = r - a;
-        n >= this.minSplit ? this.splitBlock(t, a, n) : o && (this.top = t + a);
-      } else
-        o && (this.top = t + a);
+        const f = r - a;
+        f >= this.minSplit ? this.splitBlock(t, a, f) : o && (this.top = t + a);
+      } else o && (this.top = t + a);
       return [t, i];
     }
-    return o && t + a < this.end ? (this.top = t + this.setBlockSize(t, a), [t, i]) : (this.free(t), [L(this.malloc(e)), i]);
+    return o && t + a < this.end ? (this.top = t + this.setBlockSize(t, a), [t, i]) : (this.free(t), [P(this.malloc(e)), i]);
   }
   reallocArray(t, e) {
     if (t.buffer !== this.buf)
@@ -246,11 +239,11 @@ class G {
       e = t.byteOffset;
     } else
       e = t;
-    e = L(e);
+    e = P(e);
     let r = this._used;
     for (; r; ) {
       if (r === e)
-        return this.blockSize(e) - y;
+        return this.blockSize(e) - d;
       r = this.blockNext(r);
     }
   }
@@ -267,14 +260,14 @@ class G {
       e = t.byteOffset;
     } else
       e = t;
-    C(this.lock), e = L(e);
+    x(this.lock), e = P(e);
     let r = this._used, i = 0;
     for (; r; ) {
       if (r === e)
-        return i ? this.unlinkBlock(i, r) : this._used = this.blockNext(r), this.insert(r), this.doCompact && this.compact(), B(this.lock), !0;
+        return i ? this.unlinkBlock(i, r) : this._used = this.blockNext(r), this.insert(r), this.doCompact && this.compact(), k(this.lock), !0;
       i = r, r = this.blockNext(r);
     }
-    return B(this.lock), !1;
+    return k(this.lock), !1;
   }
   freeAll() {
     this._free = 0, this._used = 0, this.top = this.initialTop();
@@ -283,57 +276,57 @@ class G {
     return delete this.u8, delete this.u32, delete this.state, delete this.buf, !0;
   }
   get align() {
-    return this.state[rt];
+    return this.state[st];
   }
   set align(t) {
-    this.state[rt] = t;
+    this.state[st] = t;
   }
   get end() {
-    return this.state[et];
+    return this.state[it];
   }
   set end(t) {
-    this.state[et] = t;
+    this.state[it] = t;
   }
   get top() {
-    return Atomics.load(this.state, tt);
+    return Atomics.load(this.state, rt);
   }
   set top(t) {
-    Atomics.store(this.state, tt, t);
+    Atomics.store(this.state, rt, t);
   }
   get _free() {
-    return Atomics.load(this.state, Q);
+    return Atomics.load(this.state, tt);
   }
   set _free(t) {
-    Atomics.store(this.state, Q, t);
+    Atomics.store(this.state, tt, t);
   }
   get _used() {
-    return Atomics.load(this.state, V);
+    return Atomics.load(this.state, et);
   }
   set _used(t) {
-    Atomics.store(this.state, V, t);
+    Atomics.store(this.state, et, t);
   }
   get doCompact() {
-    return !!(this.state[k] & Y);
+    return !!(this.state[g] & Y);
   }
   set doCompact(t) {
-    t ? this.state[k] |= 1 << Y - 1 : this.state[k] &= ~Y;
+    t ? this.state[g] |= 1 << Y - 1 : this.state[g] &= ~Y;
   }
   get doSplit() {
-    return !!(this.state[k] & H);
+    return !!(this.state[g] & H);
   }
   set doSplit(t) {
-    t ? this.state[k] |= 1 << H - 1 : this.state[k] &= ~H;
+    t ? this.state[g] |= 1 << H - 1 : this.state[g] &= ~H;
   }
   get minSplit() {
-    return this.state[it];
+    return this.state[ot];
   }
   set minSplit(t) {
-    if (t <= y)
-      throw new Error(`illegal min split threshold: ${t}, require at least ${y + 1}`);
-    this.state[it] = t;
+    if (t <= d)
+      throw new Error(`illegal min split threshold: ${t}, require at least ${d + 1}`);
+    this.state[ot] = t;
   }
   blockSize(t) {
-    return Atomics.load(this.u32, (t >> 2) + z);
+    return Atomics.load(this.u32, (t >> 2) + K);
   }
   /**
    * Sets & returns given block size.
@@ -342,10 +335,10 @@ class G {
    * @param size -
    */
   setBlockSize(t, e) {
-    return Atomics.store(this.u32, (t >> 2) + z, e), e;
+    return Atomics.store(this.u32, (t >> 2) + K, e), e;
   }
   blockNext(t) {
-    return Atomics.load(this.u32, (t >> 2) + K);
+    return Atomics.load(this.u32, (t >> 2) + G);
   }
   /**
    * Sets block next pointer to `next`. Use zero to indicate list end.
@@ -353,7 +346,7 @@ class G {
    * @param block -
    */
   setBlockNext(t, e) {
-    Atomics.store(this.u32, (t >> 2) + K, e);
+    Atomics.store(this.u32, (t >> 2) + G, e);
   }
   /**
    * Initializes block header with given `size` and `next` pointer. Returns `block`.
@@ -364,7 +357,7 @@ class G {
    */
   initBlock(t, e, r) {
     const i = t >>> 2;
-    return Atomics.store(this.u32, i + z, e), Atomics.store(this.u32, i + K, r), t;
+    return Atomics.store(this.u32, i + K, e), Atomics.store(this.u32, i + G, r), t;
   }
   unlinkBlock(t, e) {
     this.setBlockNext(t, this.blockNext(e));
@@ -379,7 +372,7 @@ class G {
     ), this.doCompact && this.compact();
   }
   initialTop(t = this.align) {
-    return M(this.start + st + y, t) - y;
+    return N(this.start + at + d, t) - d;
   }
   /**
    * Traverses free list and attempts to recursively merge blocks
@@ -394,13 +387,13 @@ class G {
       if (i !== t) {
         const a = i - t + this.blockSize(i);
         this.setBlockSize(t, a);
-        const n = this.blockNext(i);
-        let f = this.blockNext(t);
-        for (; f && f !== n; ) {
-          const u = this.blockNext(f);
-          this.setBlockNext(f, 0), f = u;
+        const f = this.blockNext(i);
+        let n = this.blockNext(t);
+        for (; n && n !== f; ) {
+          const l = this.blockNext(n);
+          this.setBlockNext(n, 0), n = l;
         }
-        this.setBlockNext(t, n), o = !0;
+        this.setBlockNext(t, f), o = !0;
       }
       t + this.blockSize(t) >= this.top && (this.top = t, e ? this.unlinkBlock(e, t) : this._free = this.blockNext(t)), e = t, t = this.blockNext(t);
     }
@@ -418,7 +411,7 @@ class G {
     r ? this.setBlockNext(r, t) : this._free = t, this.setBlockNext(t, e);
   }
 }
-const _ = (s) => s > 0 ? s + y : 0, L = (s) => s > 0 ? s - y : 0, M = (s, t) => (t--, s + t & ~t), Yt = {
+const _ = (s) => s > 0 ? s + d : 0, P = (s) => s > 0 ? s - d : 0, N = (s, t) => (t--, s + t & ~t), Gt = {
   u8: 1,
   u8c: 1,
   i8: 1,
@@ -430,7 +423,7 @@ const _ = (s) => s > 0 ? s + y : 0, L = (s) => s > 0 ? s - y : 0, M = (s, t) =>
   u64: 8,
   f32: 4,
   f64: 8
-}, Ht = [
+}, Vt = [
   "B",
   "kB",
   "MB",
@@ -440,7 +433,7 @@ const _ = (s) => s > 0 ? s + y : 0, L = (s) => s > 0 ? s - y : 0, M = (s, t) =>
   "EB",
   "ZB",
   "YB"
-], zt = [
+], Xt = [
   "B",
   "KiB",
   "MiB",
@@ -450,7 +443,7 @@ const _ = (s) => s > 0 ? s + y : 0, L = (s) => s > 0 ? s - y : 0, M = (s, t) =>
   "EiB",
   "ZiB",
   "YiB"
-], Kt = [
+], Zt = [
   "b",
   "kbit",
   "Mbit",
@@ -460,7 +453,7 @@ const _ = (s) => s > 0 ? s + y : 0, L = (s) => s > 0 ? s - y : 0, M = (s, t) =>
   "Ebit",
   "Zbit",
   "Ybit"
-], Gt = [
+], Wt = [
   "b",
   "kibit",
   "Mibit",
@@ -470,76 +463,109 @@ const _ = (s) => s > 0 ? s + y : 0, L = (s) => s > 0 ? s - y : 0, M = (s, t) =>
   "Eibit",
   "Zibit",
   "Yibit"
-], ot = (s, t, e) => {
+], nt = (s, t, e) => {
   let r = s;
   return typeof t == "string" || Array.isArray(t) ? r = s.toLocaleString(t, e) : (t === !0 || e !== void 0) && (r = s.toLocaleString(void 0, e)), r;
+}, wt = (s) => {
+  if (typeof s == "number")
+    return Math.log10(s);
+  const t = s.toString(10);
+  return t.length + Math.log10(`0.${t.slice(0, 15)}`);
+}, vt = (s) => typeof s == "number" ? Math.log(s) : wt(s) * Math.log(10), jt = (s, t) => {
+  if (typeof s == "number")
+    return s / t;
+  const e = s / BigInt(t), r = s % BigInt(t);
+  return Number(e) + Number(r) / t;
+}, ft = (s, t) => {
+  if (t === void 0)
+    return s;
+  if (typeof t != "number" || !Number.isSafeInteger(t) || t < 0)
+    throw new TypeError(`Expected fixedWidth to be a non-negative integer, got ${typeof t}: ${t}`);
+  return t === 0 ? s : s.length < t ? s.padStart(t, " ") : s;
+}, qt = (s) => {
+  const { minimumFractionDigits: t, maximumFractionDigits: e } = s;
+  if (!(t === void 0 && e === void 0))
+    return {
+      ...t !== void 0 && { minimumFractionDigits: t },
+      ...e !== void 0 && { maximumFractionDigits: e },
+      roundingMode: "trunc"
+    };
 };
-function Xt(s, t) {
-  if (!Number.isFinite(s))
+function Jt(s, t) {
+  if (typeof s != "bigint" && !Number.isFinite(s))
     throw new TypeError(`Expected a finite number, got ${typeof s}: ${s}`);
   t = {
     bits: !1,
     binary: !1,
     space: !0,
+    nonBreakingSpace: !1,
     ...t
   };
-  const e = t.bits ? t.binary ? Gt : Kt : t.binary ? zt : Ht, r = t.space ? " " : "";
-  if (t.signed && s === 0)
-    return ` 0${r}${e[0]}`;
-  const i = s < 0, o = i ? "-" : t.signed ? "+" : "";
-  i && (s = -s);
-  let a;
-  if (t.minimumFractionDigits !== void 0 && (a = { minimumFractionDigits: t.minimumFractionDigits }), t.maximumFractionDigits !== void 0 && (a = { maximumFractionDigits: t.maximumFractionDigits, ...a }), s < 1) {
-    const p = ot(s, t.locale, a);
-    return o + p + r + e[0];
-  }
-  const n = Math.min(Math.floor(t.binary ? Math.log(s) / Math.log(1024) : Math.log10(s) / 3), e.length - 1);
-  s /= (t.binary ? 1024 : 1e3) ** n, a || (s = s.toPrecision(3));
-  const f = ot(Number(s), t.locale, a), u = e[n];
-  return o + f + r + u;
+  const e = t.bits ? t.binary ? Wt : Zt : t.binary ? Xt : Vt, r = t.space ? t.nonBreakingSpace ? " " : " " : "", i = typeof s == "number" ? s === 0 : s === 0n;
+  if (t.signed && i) {
+    const l = ` 0${r}${e[0]}`;
+    return ft(l, t.fixedWidth);
+  }
+  const o = s < 0, a = o ? "-" : t.signed ? "+" : "";
+  o && (s = -s);
+  const f = qt(t);
+  let n;
+  if (s < 1) {
+    const l = nt(s, t.locale, f);
+    n = a + l + r + e[0];
+  } else {
+    const l = Math.min(Math.floor(t.binary ? vt(s) / Math.log(1024) : wt(s) / 3), e.length - 1);
+    if (s = jt(s, (t.binary ? 1024 : 1e3) ** l), !f) {
+      const M = Math.max(3, Math.floor(s).toString().length);
+      s = s.toPrecision(M);
+    }
+    const S = nt(Number(s), t.locale, f), $ = e[l];
+    n = a + S + r + $;
+  }
+  return ft(n, t.fixedWidth);
 }
-const Wt = 8192, at = 0, X = 1, P = 2;
-class ie {
+const Qt = 8192, lt = 0, X = 1, U = 2;
+class ne {
+  buffers;
+  onGrowBufferHandlers = [];
+  isClone;
+  memory;
+  get bufferSize() {
+    return this.memory.data[lt];
+  }
   constructor(t) {
-    l(this, "buffers");
-    l(this, "onGrowBufferHandlers", []);
-    l(this, "isClone");
-    l(this, "memory");
     if (t && "buffers" in t)
-      this.buffers = t.buffers.map((e) => new G({
+      this.buffers = t.buffers.map((e) => new V({
         buf: e,
         skipInitialization: !0
-      })), this.memory = new c(this, {
+      })), this.memory = new h(this, {
         bufferPosition: 0,
         bufferByteOffset: 40
       }), this.isClone = !0;
     else {
       "SharedArrayBuffer" in globalThis || console.warn("SharedArrayBuffer is not working: falling back to ArrayBuffer");
-      const e = (t == null ? void 0 : t.bufferSize) ?? Wt;
-      if (e > q)
-        throw new Error(`Buffer size ${e} is greater than max ${q} that we can reference with pointers`);
+      const e = t?.bufferSize ?? Qt;
+      if (e > J)
+        throw new Error(`Buffer size ${e} is greater than max ${J} that we can reference with pointers`);
       let r = this.createBuffer(e);
       this.buffers = [
         r
       ];
       const i = r.callocAs("u32", 3);
       if (i)
-        this.memory = new c(this, {
+        this.memory = new h(this, {
           bufferPosition: 0,
           bufferByteOffset: i.byteOffset
         });
       else
         throw new Error("Failed to initialize first byte from buffer");
-      this.memory.data[at] = e, this.memory.data[X] = 1, this.memory.data[P] = (t == null ? void 0 : t.autoGrowSize) ?? 100, this.isClone = !1;
-      for (let o = 1; o < ((t == null ? void 0 : t.initialBuffers) ?? 1); o++)
+      this.memory.data[lt] = e, this.memory.data[X] = 1, this.memory.data[U] = t?.autoGrowSize ?? 100, this.isClone = !1;
+      for (let o = 1; o < (t?.initialBuffers ?? 1); o++)
         this.buffers.push(this.createBuffer(e));
     }
   }
-  get bufferSize() {
-    return this.memory.data[at];
-  }
   addSharedBuffer(t) {
-    this.buffers[t.bufferPosition] = new G({
+    this.buffers[t.bufferPosition] = new V({
       buf: t.buffer,
       skipInitialization: !0
     });
@@ -555,7 +581,7 @@ class ie {
   createBuffer(t) {
     const e = t ?? this.bufferSize;
     let r;
-    return "SharedArrayBuffer" in globalThis ? r = new SharedArrayBuffer(e) : r = new ArrayBuffer(e), new G({
+    return "SharedArrayBuffer" in globalThis ? r = new SharedArrayBuffer(e) : r = new ArrayBuffer(e), new V({
       buf: r,
       // We can't use this unless we can 100% guarantee that every thread will stop using memory the instant it is freed
       // ex: Allocate 16 bytes.  Thread A frees that allocation and then allocates 12 bytes and 4 bytes, but Thread B is mid-execution on the old allocation can changes the internal state of the 4-byte allocation breaking everything
@@ -575,17 +601,17 @@ class ie {
         continue;
       const a = o.callocAs("u32", t);
       if (a)
-        return i === this.buffers.length - 1 && Atomics.load(this.memory.data, X) === this.buffers.length && this.memory.data[P] < 100 && this.memory.data[P] > 0 && o.top / o.end > this.memory.data[P] / 100 && this.growBuffer(), new c(this, {
+        return i === this.buffers.length - 1 && Atomics.load(this.memory.data, X) === this.buffers.length && this.memory.data[U] < 100 && this.memory.data[U] > 0 && o.top / o.end > this.memory.data[U] / 100 && this.growBuffer(), new h(this, {
           data: a,
           buffer: o
         });
     }
-    if (this.buffers.length >= J)
-      throw new Error(`Can't initialize a new buffer since it would have a position greater than the max of ${J}`);
+    if (this.buffers.length >= Q)
+      throw new Error(`Can't initialize a new buffer since it would have a position greater than the max of ${Q}`);
     let e = this.growBuffer();
     const r = e.callocAs("u32", t);
     if (r)
-      return new c(this, {
+      return new h(this, {
         data: r,
         buffer: e
       });
@@ -593,7 +619,7 @@ class ie {
   }
   getSharedAlloc(t) {
     if (this.buffers[t.bufferPosition] !== void 0)
-      return new c(this, t);
+      return new h(this, t);
   }
   get currentUsed() {
     return this.totalAllocated - this.buffers.reduce((t, e) => t + e.stats().available, 0);
@@ -602,7 +628,7 @@ class ie {
     return this.buffers[0].buf.byteLength * this.buffers.length;
   }
   prettyMemory() {
-    return `${ft(this.currentUsed)} / ${ft(this.totalAllocated)}`;
+    return `${ht(this.currentUsed)} / ${ht(this.totalAllocated)}`;
   }
   getSharedMemory() {
     return {
@@ -610,47 +636,39 @@ class ie {
     };
   }
 }
-function ft(s) {
-  return Xt(s, {
+function ht(s) {
+  return Jt(s, {
     binary: !0,
     minimumFractionDigits: 1,
     maximumFractionDigits: 1
   });
 }
-const nt = 4, lt = 1, E = 2;
-class d {
-  constructor(t, e) {
-    l(this, "memory");
-    /* First block
-    	32 index 0
-    	uint16 0 - next buffer position
-    	uint16 1 - next buffer index
-    	32 index 1
-    	uint16 2 - last buffer position
-    	uint16 3 - last buffer index
-    	32 index 2
-    	uint32 4 - length
-    	32 index 3
-    	uint16 6 - type
-    	uint16 7 - data length (defaults to 1 number per data)
-    */
-    /* Other blocks
-    	32 index 0
-    	uint16 0 - next buffer position
-    	uint16 1 - next buffer index
-    	32 index 1 => data
-    */
-    l(this, "firstBlock");
-    l(this, "uint16Array");
-    l(this, "onDelete");
-    if (this.memory = t, e && "firstBlock" in e)
-      this.firstBlock = new c(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (E + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
-    else {
-      e && e.initWithBlock ? this.firstBlock = new c(t, e.initWithBlock) : this.firstBlock = t.allocUI32(nt), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (E + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
-      const r = (e == null ? void 0 : e.type) ?? Uint32Array;
-      r === Uint32Array ? this.type = 0 : r === Int32Array ? this.type = 1 : r === Float32Array && (this.type = 2), this.dataLength = (e == null ? void 0 : e.dataLength) ?? 1;
-    }
-  }
+const ct = 4, ut = 1, E = 2;
+class u {
+  static ALLOCATE_COUNT = ct;
+  memory;
+  /* First block
+  	32 index 0
+  	uint16 0 - next buffer position
+  	uint16 1 - next buffer index
+  	32 index 1
+  	uint16 2 - last buffer position
+  	uint16 3 - last buffer index
+  	32 index 2
+  	uint32 4 - length
+  	32 index 3
+  	uint16 6 - type
+  	uint16 7 - data length (defaults to 1 number per data)
+  */
+  /* Other blocks
+  	32 index 0
+  	uint16 0 - next buffer position
+  	uint16 1 - next buffer index
+  	32 index 1 => data
+  */
+  firstBlock;
+  uint16Array;
+  onDelete;
   get length() {
     return Atomics.load(this.firstBlock.data, E);
   }
@@ -666,20 +684,29 @@ class d {
   set dataLength(t) {
     Atomics.store(this.uint16Array, 1, t);
   }
+  constructor(t, e) {
+    if (this.memory = t, e && "firstBlock" in e)
+      this.firstBlock = new h(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (E + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
+    else {
+      e && e.initWithBlock ? this.firstBlock = new h(t, e.initWithBlock) : this.firstBlock = t.allocUI32(ct), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (E + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
+      const r = e?.type ?? Uint32Array;
+      r === Uint32Array ? this.type = 0 : r === Int32Array ? this.type = 1 : r === Float32Array && (this.type = 2), this.dataLength = e?.dataLength ?? 1;
+    }
+  }
   insert(t) {
     typeof t == "number" && (t = [t]);
     let e = this.dataLength;
     if (t.length > e)
       throw new Error(`Can't insert ${t.length} array into shared list of ${e} dataLength`);
-    let r = this.memory.allocUI32(lt + e), i = this.getDataBlock(r.data), o = r.pointer;
-    for (let f = 0; f < t.length; f++)
-      i instanceof Int32Array || i instanceof Uint32Array ? Atomics.store(i, f, t[f]) : i[f] = t[f];
-    let a, n = !1;
-    for (; !n; )
-      a = O(this.firstBlock.data, 1), n = $(this.firstBlock.data, 1, o, a);
+    let r = this.memory.allocUI32(ut + e), i = this.getDataBlock(r.data), o = r.pointer;
+    for (let n = 0; n < t.length; n++)
+      i instanceof Int32Array || i instanceof Uint32Array ? Atomics.store(i, n, t[n]) : i[n] = t[n];
+    let a, f = !1;
+    for (; !f; )
+      a = O(this.firstBlock.data, 1), f = z(this.firstBlock.data, 1, o, a);
     if (a) {
-      let { bufferPosition: f, bufferByteOffset: u } = S(a), p = new Uint32Array(this.memory.buffers[f].buf, u, 1);
-      W(p, 0, o);
+      let { bufferPosition: n, bufferByteOffset: l } = A(a), S = new Uint32Array(this.memory.buffers[n].buf, l, 1);
+      W(S, 0, o);
     } else
       W(this.firstBlock.data, 0, o);
     Atomics.add(this.firstBlock.data, E, 1);
@@ -708,37 +735,37 @@ class d {
     for (; !r; ) {
       if (t = O(this.firstBlock.data, 0), e = O(this.firstBlock.data, 1), !e)
         return;
-      r = $(this.firstBlock.data, 1, 0, e);
+      r = z(this.firstBlock.data, 1, 0, e);
     }
     if (!t)
       return;
-    $(this.firstBlock.data, 0, 0, t);
+    z(this.firstBlock.data, 0, 0, t);
     let i = 0, o = t;
     for (; o; ) {
-      let { bufferPosition: a, bufferByteOffset: n } = S(o), f = this.memory.buffers[a];
-      if (!f)
+      let { bufferPosition: a, bufferByteOffset: f } = A(o), n = this.memory.buffers[a];
+      if (!n)
         break;
-      let u = new Uint32Array(f.buf, n, 2);
-      o = O(u, 0), i++, this.onDelete && this.onDelete(this.getDataBlock(u)), f.free(u.byteOffset);
+      let l = new Uint32Array(n.buf, f, 2);
+      o = O(l, 0), i++, this.onDelete && this.onDelete(this.getDataBlock(l)), n.free(l.byteOffset);
     }
     Atomics.sub(this.firstBlock.data, E, i);
   }
   *[Symbol.iterator]() {
-    let t = 0, { bufferPosition: e, bufferByteOffset: r } = h(this.firstBlock.data, 0), i = this.firstBlock.data, o = 0, a = 0;
+    let t = 0, { bufferPosition: e, bufferByteOffset: r } = c(this.firstBlock.data, 0), i = this.firstBlock.data, o = 0, a = 0;
     for (; r; ) {
-      let n = this.memory.buffers[e];
-      if (!n)
+      let f = this.memory.buffers[e];
+      if (!f)
         return;
-      let f = new Uint32Array(n.buf, r, 2), u = this.getDataBlock(f), p = e, Mt = r;
-      ({ bufferPosition: e, bufferByteOffset: r } = h(f, 0));
-      let j = !0;
+      let n = new Uint32Array(f.buf, r, 2), l = this.getDataBlock(n), S = e, $ = r;
+      ({ bufferPosition: e, bufferByteOffset: r } = c(n, 0));
+      let M = !0;
       yield {
-        data: u,
+        data: l,
         index: t,
         deleteCurrent: () => {
-          A(i, 0, e, r), r || A(this.firstBlock.data, 1, o, a), this.onDelete && this.onDelete(this.getDataBlock(f)), n.free(f.byteOffset), Atomics.sub(this.firstBlock.data, E, 1), j = !1;
+          m(i, 0, e, r), r || m(this.firstBlock.data, 1, o, a), this.onDelete && this.onDelete(this.getDataBlock(n)), f.free(n.byteOffset), Atomics.sub(this.firstBlock.data, E, 1), M = !1;
         }
-      }, j && (i = f, o = p, a = Mt, t++);
+      }, M && (i = n, o = S, a = $, t++);
     }
   }
   forEach(t) {
@@ -751,7 +778,7 @@ class d {
     };
   }
   getDataBlock(t) {
-    const e = t.byteOffset + lt * t.BYTES_PER_ELEMENT;
+    const e = t.byteOffset + ut * t.BYTES_PER_ELEMENT;
     switch (this.type) {
       case 1:
         return new Int32Array(t.buffer, e, this.dataLength);
@@ -764,35 +791,26 @@ class d {
     }
   }
   free() {
-    let { bufferPosition: t, bufferByteOffset: e } = h(this.firstBlock.data, 0);
+    let { bufferPosition: t, bufferByteOffset: e } = c(this.firstBlock.data, 0);
     for (; e; ) {
-      let r = new c(this.memory, {
+      let r = new h(this.memory, {
         bufferPosition: t,
         bufferByteOffset: e
       });
-      ({ bufferPosition: t, bufferByteOffset: e } = h(r.data, 0)), this.onDelete && this.onDelete(this.getDataBlock(r.data)), r.free();
+      ({ bufferPosition: t, bufferByteOffset: e } = c(r.data, 0)), this.onDelete && this.onDelete(this.getDataBlock(r.data)), r.free();
     }
     this.firstBlock.free();
   }
 }
-l(d, "ALLOCATE_COUNT", nt);
-const ht = 10, F = class F {
-  constructor(t, e) {
-    l(this, "memory");
-    // Memory order: Pointer, Lock, Length, MaxHash
-    l(this, "pointerMemory");
-    l(this, "lock");
-    if (this.memory = t, e)
-      this.pointerMemory = new c(t, e.firstBlock);
-    else {
-      this.pointerMemory = t.allocUI32(F.ALLOCATE_COUNT);
-      let r = t.allocUI32(ht);
-      A(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, ht);
-    }
-    this.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + Uint32Array.BYTES_PER_ELEMENT, 1);
-  }
+const dt = 10;
+class Tt {
+  static ALLOCATE_COUNT = 4;
+  memory;
+  // Memory order: Pointer, Lock, Length, MaxHash
+  pointerMemory;
+  lock;
   get hashMemory() {
-    return new c(this.memory, h(this.pointerMemory.data, 0));
+    return new h(this.memory, c(this.pointerMemory.data, 0));
   }
   get length() {
     return Atomics.load(this.pointerMemory.data, 2);
@@ -800,31 +818,41 @@ const ht = 10, F = class F {
   get maxHash() {
     return Atomics.load(this.pointerMemory.data, 3);
   }
+  constructor(t, e) {
+    if (this.memory = t, e)
+      this.pointerMemory = new h(t, e.firstBlock);
+    else {
+      this.pointerMemory = t.allocUI32(Tt.ALLOCATE_COUNT);
+      let r = t.allocUI32(dt);
+      m(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, dt);
+    }
+    this.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + Uint32Array.BYTES_PER_ELEMENT, 1);
+  }
   set(t, e) {
     this.length >= this.maxHash * 2 && this.growHashTable();
-    let r = N(t);
+    let r = C(t);
     this.setHashKey(this.hashMemory, this.maxHash, r, e) && Atomics.add(this.pointerMemory.data, 2, 1);
   }
   setHashKey(t, e, r, i) {
-    let o = this.hash(r, e), a, n = h(t.data, o);
-    if (n.bufferByteOffset === 0) {
-      a = new d(this.memory, {
+    let o = this.hash(r, e), a, f = c(t.data, o);
+    if (f.bufferByteOffset === 0) {
+      a = new u(this.memory, {
         dataLength: 2
       });
-      let u = a.getSharedMemory();
-      A(t.data, o, u.firstBlock.bufferPosition, u.firstBlock.bufferByteOffset);
+      let l = a.getSharedMemory();
+      m(t.data, o, l.firstBlock.bufferPosition, l.firstBlock.bufferByteOffset);
     } else
-      a = new d(this.memory, {
-        firstBlock: n
+      a = new u(this.memory, {
+        firstBlock: f
       });
-    let f = !0;
-    return a.deleteValue(r) && (f = !1), a.insert([r, i]), f;
+    let n = !0;
+    return a.deleteValue(r) && (n = !1), a.insert([r, i]), n;
   }
   get(t) {
-    let e = N(t), r = this.hash(e, this.maxHash), i = h(this.hashMemory.data, r);
+    let e = C(t), r = this.hash(e, this.maxHash), i = c(this.hashMemory.data, r);
     if (i.bufferByteOffset === 0)
       return;
-    let o = new d(this.memory, {
+    let o = new u(this.memory, {
       firstBlock: i
     });
     for (let { data: a } of o)
@@ -832,10 +860,10 @@ const ht = 10, F = class F {
         return a[1];
   }
   has(t) {
-    let e = N(t), r = this.hash(e, this.maxHash), i = h(this.hashMemory.data, r);
+    let e = C(t), r = this.hash(e, this.maxHash), i = c(this.hashMemory.data, r);
     if (i.bufferByteOffset === 0)
       return !1;
-    let o = new d(this.memory, {
+    let o = new u(this.memory, {
       firstBlock: i
     });
     for (let { data: a } of o)
@@ -844,40 +872,40 @@ const ht = 10, F = class F {
     return !1;
   }
   delete(t) {
-    let e = N(t), r = this.hash(e, this.maxHash), i = h(this.hashMemory.data, r);
+    let e = C(t), r = this.hash(e, this.maxHash), i = c(this.hashMemory.data, r);
     if (i.bufferByteOffset === 0)
       return !1;
-    let o = new d(this.memory, {
+    let o = new u(this.memory, {
       firstBlock: i
     });
-    for (let { data: a, deleteCurrent: n } of o)
+    for (let { data: a, deleteCurrent: f } of o)
       if (a[0] === e)
-        return n(), Atomics.sub(this.pointerMemory.data, 2, 1), !0;
+        return f(), Atomics.sub(this.pointerMemory.data, 2, 1), !0;
     return !1;
   }
   growHashTable() {
     let t = this.maxHash, e = t * 2, r = this.memory.allocUI32(e), i = this.hashMemory;
     for (let o = 0; o < t; o++) {
-      let a = h(i.data, o);
+      let a = c(i.data, o);
       if (a.bufferByteOffset === 0)
         continue;
-      let n = new d(this.memory, {
+      let f = new u(this.memory, {
         firstBlock: a
       });
-      for (let { data: f } of n)
-        this.setHashKey(r, e, f[0], f[1]);
+      for (let { data: n } of f)
+        this.setHashKey(r, e, n[0], n[1]);
     }
-    A(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, e);
+    m(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, e);
   }
   hash(t, e) {
     return t % e;
   }
   free() {
     for (let t = 0; t < this.maxHash; t++) {
-      let e = h(this.hashMemory.data, t);
+      let e = c(this.hashMemory.data, t);
       if (e.bufferByteOffset === 0)
         continue;
-      new d(this.memory, {
+      new u(this.memory, {
         firstBlock: e
       }).free();
     }
@@ -888,13 +916,11 @@ const ht = 10, F = class F {
       firstBlock: this.pointerMemory.getSharedMemory()
     };
   }
-};
-l(F, "ALLOCATE_COUNT", 4);
-let ct = F;
-function N(s) {
-  return typeof s == "number" ? s : typeof s == "string" ? Zt(s) : s;
 }
-function Zt(s) {
+function C(s) {
+  return typeof s == "number" ? s : typeof s == "string" ? te(s) : s;
+}
+function te(s) {
   let t = s.length, e = 17 ^ t, r = 0, i;
   for (; t >= 4; )
     i = s.charCodeAt(r) & 255 | (s.charCodeAt(++r) & 255) << 8 | (s.charCodeAt(++r) & 255) << 16 | (s.charCodeAt(++r) & 255) << 14, i = (i & 65535) * 1540483477 + (((i >>> 16) * 1540483477 & 65535) << 16), i ^= i >>> 14, i = (i & 65535) * 1540483477 + (((i >>> 16) * 1540483477 & 65535) << 16), e = (e & 65535) * 1540483477 + (((e >>> 16) * 1540483477 & 65535) << 16) ^ i, t -= 4, ++r;
@@ -908,25 +934,25 @@ function Zt(s) {
   }
   return e ^= e >>> 13, e = (e & 65535) * 1540483477 + (((e >>> 16) * 1540483477 & 65535) << 16), e ^= e >>> 15, e = e >>> 0, e;
 }
-class se {
+class fe {
+  memory;
+  list;
   constructor(t, e) {
-    l(this, "memory");
-    l(this, "list");
-    this.memory = t, e ? this.list = new d(t, e) : this.list = new d(t);
+    this.memory = t, e ? this.list = new u(t, e) : this.list = new u(t);
   }
   get length() {
     return this.list.length;
   }
   insert(t) {
-    this.list.insert(w(t.memory.bufferPosition, t.memory.bufferByteOffset));
+    this.list.insert(T(t.memory.bufferPosition, t.memory.bufferByteOffset));
   }
   delete(t) {
-    return this.list.deleteValue(w(t.memory.bufferPosition, t.memory.bufferByteOffset));
+    return this.list.deleteValue(T(t.memory.bufferPosition, t.memory.bufferByteOffset));
   }
   *[Symbol.iterator]() {
     let t = this.list[Symbol.iterator]();
     for (let { data: e } of t) {
-      let { bufferPosition: r, bufferByteOffset: i } = h(e, 0), o = new c(this.memory, {
+      let { bufferPosition: r, bufferByteOffset: i } = c(e, 0), o = new h(this.memory, {
         bufferPosition: r,
         bufferByteOffset: i
       });
@@ -951,21 +977,23 @@ class se {
     this.list.free();
   }
 }
-const ut = {
+const yt = {
   1: Uint8Array,
   2: Uint16Array
-}, I = 0, dt = 1, yt = 2, mt = 3, x = class x {
+}, I = 0, Bt = 1, mt = 2, bt = 3;
+class Lt {
+  static ALLOCATE_COUNT = 4;
+  memory;
+  allocatedMemory;
+  lock;
+  cachedPointer;
+  cachedString;
   constructor(t, e) {
-    l(this, "memory");
-    l(this, "allocatedMemory");
-    l(this, "lock");
-    l(this, "cachedPointer");
-    l(this, "cachedString");
-    this.memory = t, typeof e == "string" ? (this.allocatedMemory = this.memory.allocUI32(x.ALLOCATE_COUNT), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + mt * this.allocatedMemory.data.BYTES_PER_ELEMENT), this.updateString(e)) : (this.allocatedMemory = new c(t, e), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + mt * this.allocatedMemory.data.BYTES_PER_ELEMENT), "value" in e && this.updateString(e.value));
+    this.memory = t, typeof e == "string" ? (this.allocatedMemory = this.memory.allocUI32(Lt.ALLOCATE_COUNT), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + bt * this.allocatedMemory.data.BYTES_PER_ELEMENT), this.updateString(e)) : (this.allocatedMemory = new h(t, e), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + bt * this.allocatedMemory.data.BYTES_PER_ELEMENT), "value" in e && this.updateString(e.value));
   }
   updateString(t) {
     let e = this.createString(t);
-    C(this.lock), W(this.allocatedMemory.data, I, e.pointer), Atomics.store(this.allocatedMemory.data, dt, t.length), Atomics.store(this.allocatedMemory.data, yt, e.charType), B(this.lock), this.cachedPointer = e.pointer, this.cachedString = t;
+    x(this.lock), W(this.allocatedMemory.data, I, e.pointer), Atomics.store(this.allocatedMemory.data, Bt, t.length), Atomics.store(this.allocatedMemory.data, mt, e.charType), k(this.lock), this.cachedPointer = e.pointer, this.cachedString = t;
   }
   createString(t) {
     if (t === "")
@@ -975,11 +1003,11 @@ const ut = {
         /* ASCII */
       };
     let e = [];
-    for (let f = 0; f < t.length; f++)
-      e.push(t.charCodeAt(f));
-    let i = Math.max(...e) > 255 ? 2 : 1, o = ut[i], a = this.memory.allocUI32(Math.ceil(t.length / (4 / o.BYTES_PER_ELEMENT))), n = new o(a.data.buffer, a.data.byteOffset, t.length);
-    for (let f = 0; f < t.length; f++)
-      n[f] = t.charCodeAt(f);
+    for (let n = 0; n < t.length; n++)
+      e.push(t.charCodeAt(n));
+    let i = Math.max(...e) > 255 ? 2 : 1, o = yt[i], a = this.memory.allocUI32(Math.ceil(t.length / (4 / o.BYTES_PER_ELEMENT))), f = new o(a.data.buffer, a.data.byteOffset, t.length);
+    for (let n = 0; n < t.length; n++)
+      f[n] = t.charCodeAt(n);
     return {
       pointer: a.pointer,
       charType: i
@@ -991,13 +1019,13 @@ const ut = {
       return this.cachedString;
     if (t === 0)
       return "";
-    let { bufferPosition: e, bufferByteOffset: r } = S(t);
-    C(this.lock);
-    let i = Atomics.load(this.allocatedMemory.data, yt), o = ut[i], a = Atomics.load(this.allocatedMemory.data, dt), n = new o(this.memory.buffers[e].buf, r, a), f = String.fromCharCode.apply(null, n);
-    return B(this.lock), this.cachedPointer = t, this.cachedString = f, f;
+    let { bufferPosition: e, bufferByteOffset: r } = A(t);
+    x(this.lock);
+    let i = Atomics.load(this.allocatedMemory.data, mt), o = yt[i], a = Atomics.load(this.allocatedMemory.data, Bt), f = new o(this.memory.buffers[e].buf, r, a), n = String.fromCharCode.apply(null, f);
+    return k(this.lock), this.cachedPointer = t, this.cachedString = n, n;
   }
   set value(t) {
-    let { bufferPosition: e, bufferByteOffset: r } = h(this.allocatedMemory.data, I);
+    let { bufferPosition: e, bufferByteOffset: r } = c(this.allocatedMemory.data, I);
     this.updateString(t), r && this.memory.buffers[e].free(r);
   }
   getSharedMemory() {
@@ -1007,33 +1035,19 @@ const ut = {
     return this.allocatedMemory.pointer;
   }
   free() {
-    let { bufferPosition: t, bufferByteOffset: e } = h(this.allocatedMemory.data, I);
+    let { bufferPosition: t, bufferByteOffset: e } = c(this.allocatedMemory.data, I);
     e && this.memory.buffers[t].free(e), this.allocatedMemory.free();
   }
-};
-l(x, "ALLOCATE_COUNT", 4);
-let bt = x;
-const m = 1, Bt = 2, At = 3, vt = 4, R = class R {
-  constructor(t, e) {
-    l(this, "memory");
-    // Pointer, List Length, Buffer Length, Type/DataLength
-    l(this, "firstBlock");
-    l(this, "uint16Array");
-    l(this, "cachedFullDataBlock");
-    l(this, "cachedPointer");
-    if (this.memory = t, e && "firstBlock" in e)
-      this.firstBlock = new c(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + At * Uint32Array.BYTES_PER_ELEMENT, 2);
-    else {
-      this.firstBlock = t.allocUI32(R.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + At * Uint32Array.BYTES_PER_ELEMENT, 2);
-      let r = (e == null ? void 0 : e.dataLength) ?? 1, i = (e == null ? void 0 : e.bufferLength) ?? vt, o = t.allocUI32(i * r);
-      A(this.firstBlock.data, 0, o.bufferPosition, o.bufferByteOffset), this.bufferLength = i;
-      const a = (e == null ? void 0 : e.type) ?? Uint32Array;
-      a === Uint32Array ? this.type = 0 : a === Int32Array ? this.type = 1 : a === Float32Array && (this.type = 2), this.dataLength = r;
-    }
-    this.cachedPointer = this.firstBlock.data[0], this.cachedFullDataBlock = this.getFullDataBlock(this.dataLength);
-  }
+}
+const p = 0, b = 1, kt = 2, At = 3, Z = 4;
+class y {
+  static ALLOCATE_COUNT = 4;
+  memory;
+  // Pointer, List Length, Buffer Length, Type/DataLength
+  firstBlock;
+  uint16Array;
   get length() {
-    return Atomics.load(this.firstBlock.data, m);
+    return Atomics.load(this.firstBlock.data, b);
   }
   get type() {
     return this.uint16Array[0];
@@ -1048,120 +1062,137 @@ const m = 1, Bt = 2, At = 3, vt = 4, R = class R {
     Atomics.store(this.uint16Array, 1, t);
   }
   get bufferLength() {
-    return Atomics.load(this.firstBlock.data, Bt);
+    return Atomics.load(this.firstBlock.data, kt);
   }
   set bufferLength(t) {
-    Atomics.store(this.firstBlock.data, Bt, t);
+    Atomics.store(this.firstBlock.data, kt, t);
+  }
+  get pointer() {
+    return this.firstBlock.pointer;
+  }
+  cachedFullDataBlock;
+  cachedPointer;
+  constructor(t, e) {
+    if (this.memory = t, e && "firstBlock" in e) {
+      if (this.firstBlock = new h(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + At * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in e || "dataLength" in e) {
+        let r = t.allocUI32(Z * (e.dataLength ?? 1));
+        m(this.firstBlock.data, p, r.bufferPosition, r.bufferByteOffset), this.bufferLength = Z, this.dataLength = e.dataLength ?? 1;
+      }
+      if ("type" in e) {
+        const r = e?.type ?? Uint32Array;
+        r === Uint32Array ? this.type = 0 : r === Int32Array ? this.type = 1 : r === Float32Array && (this.type = 2);
+      }
+    } else {
+      this.firstBlock = t.allocUI32(y.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + At * Uint32Array.BYTES_PER_ELEMENT, 2);
+      let r = e?.dataLength ?? 1, i = e?.bufferLength ?? Z, o = t.allocUI32(i * r);
+      m(this.firstBlock.data, p, o.bufferPosition, o.bufferByteOffset), this.bufferLength = i;
+      const a = e?.type ?? Uint32Array;
+      a === Uint32Array ? this.type = 0 : a === Int32Array ? this.type = 1 : a === Float32Array && (this.type = 2), this.dataLength = r;
+    }
+    this.cachedPointer = this.firstBlock.data[0], this.cachedFullDataBlock = this.getFullDataBlock();
   }
   at(t) {
     let e = this.length;
     if (t >= e || t < 0)
       throw new Error(`${t} is out of bounds ${e}`);
-    let r = h(this.firstBlock.data, 0), i = new c(this.memory, r);
-    return this.getDataBlock(i.data, t);
+    let r = this.getFullDataBlock();
+    return this.getDataBlock(r, t);
   }
   get(t, e = 0) {
     if (e >= this.dataLength)
       throw new Error(`${e} is out of dataLength bounds ${this.dataLength}`);
-    return this.at(t)[e];
+    if (t >= this.length || t < 0)
+      throw new Error(`${t} is out of bounds ${this.length}`);
+    return this.getFullDataBlock()[t * this.dataLength + e];
   }
   push(t) {
     typeof t == "number" && (t = [t]);
     let e = this.dataLength;
     if (t.length > e)
       throw new Error(`Can't insert ${t.length} array into shared list of ${e} dataLength`);
-    let r = this.getFullDataBlock(e), i = this.length;
-    return r.set(t, e * i), Atomics.add(this.firstBlock.data, m, m) + 1 >= this.bufferLength && this.growBuffer(), i;
+    let r = this.getFullDataBlock(), i = this.length;
+    return r.set(t, e * i), Atomics.add(this.firstBlock.data, b, 1) + 1 >= this.bufferLength && this.growBuffer(), i;
   }
   pop() {
-    let t = Atomics.sub(this.firstBlock.data, m, m), e = h(this.firstBlock.data, 0), r = new c(this.memory, e);
-    return this.getDataBlock(r.data, t - 1);
+    let t = Atomics.sub(this.firstBlock.data, b, b), e = this.getFullDataBlock();
+    return this.getDataBlock(e, t - 1);
   }
   deleteIndex(t) {
     let e = this.length;
     if (t >= e || t < 0)
       throw new Error(`${t} is out of bounds ${e}`);
-    let r = this.dataLength, i = this.getFullDataBlock(r);
+    let r = this.dataLength, i = this.getFullDataBlock();
     for (let o = t; o < e; o++)
       for (let a = 0; a < r; a++)
         i[o * r + a] = i[(o + 1) * r + a];
-    Atomics.sub(this.firstBlock.data, m, m);
+    Atomics.sub(this.firstBlock.data, b, b);
   }
   clear() {
-    this.firstBlock.data[m] = 0;
+    this.firstBlock.data[b] = 0;
   }
   *[Symbol.iterator]() {
-    let t = h(this.firstBlock.data, 0), e = new c(this.memory, t);
-    for (let r = 0; r < this.length; r++)
-      yield this.getDataBlock(e.data, r);
+    let t = this.getFullDataBlock();
+    for (let e = 0; e < this.length; e++)
+      yield this.getDataBlock(t, e);
   }
-  getFullDataBlock(t) {
-    let e = Atomics.load(this.firstBlock.data, 0);
-    if (this.cachedPointer === e && this.cachedFullDataBlock)
+  getFullDataBlock() {
+    let t = Atomics.load(this.firstBlock.data, p);
+    if (this.cachedPointer === t && this.cachedFullDataBlock)
       return this.cachedFullDataBlock;
-    let r = S(e), i = new c(this.memory, r), o;
+    let e = A(t), r = new h(this.memory, e), i;
     switch (this.type) {
       case 1:
-        o = new Int32Array(i.data.buffer, i.bufferByteOffset, t * this.bufferLength);
+        i = new Int32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
         break;
       case 0:
-        o = new Uint32Array(i.data.buffer, i.bufferByteOffset, t * this.bufferLength);
+        i = new Uint32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
         break;
       case 2:
-        o = new Float32Array(i.data.buffer, i.bufferByteOffset, t * this.bufferLength);
+        i = new Float32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
         break;
       default:
         throw new Error(`Unknown data block type ${this.type}`);
     }
-    return this.cachedPointer = e, this.cachedFullDataBlock = o, o;
+    return this.cachedPointer = t, this.cachedFullDataBlock = i, i;
   }
   getDataBlock(t, e) {
-    switch (this.type) {
-      case 1:
-        return new Int32Array(t.buffer, t.byteOffset + e * this.dataLength * 4, this.dataLength);
-      case 0:
-        return new Uint32Array(t.buffer, t.byteOffset + e * this.dataLength * 4, this.dataLength);
-      case 2:
-        return new Float32Array(t.buffer, t.byteOffset + e * this.dataLength * 4, this.dataLength);
-      default:
-        throw new Error(`Unknown data block type ${this.type}`);
-    }
+    const r = e * this.dataLength;
+    return t.subarray(r, r + this.dataLength);
   }
   growBuffer() {
-    let e = this.bufferLength * 2, r = this.dataLength, i = h(this.firstBlock.data, 0), o = new c(this.memory, i), a = this.getFullDataBlock(r), n = this.memory.allocUI32(e * r), f;
+    let e = this.bufferLength * 2, r = this.dataLength, i = c(this.firstBlock.data, p), o = new h(this.memory, i), a = this.getFullDataBlock(), f = this.memory.allocUI32(e * r), n;
     switch (this.type) {
       case 1:
-        f = new Int32Array(n.data.buffer, n.bufferByteOffset, r * this.bufferLength);
+        n = new Int32Array(f.data.buffer, f.bufferByteOffset, r * this.bufferLength);
         break;
       case 0:
-        f = new Uint32Array(n.data.buffer, n.bufferByteOffset, r * this.bufferLength);
+        n = new Uint32Array(f.data.buffer, f.bufferByteOffset, r * this.bufferLength);
         break;
       case 2:
-        f = new Float32Array(n.data.buffer, n.bufferByteOffset, r * this.bufferLength);
+        n = new Float32Array(f.data.buffer, f.bufferByteOffset, r * this.bufferLength);
         break;
       default:
         throw new Error(`Unknown data block type ${this.type}`);
     }
-    f.set(a), A(this.firstBlock.data, 0, n.bufferPosition, n.bufferByteOffset), this.bufferLength = e, o.free();
+    n.set(a), m(this.firstBlock.data, p, f.bufferPosition, f.bufferByteOffset), this.bufferLength = e, o.free();
   }
   free() {
-    let t = h(this.firstBlock.data, 0);
-    new c(this.memory, t).free(), this.firstBlock.free();
+    let t = c(this.firstBlock.data, p);
+    new h(this.memory, t).free(), this.firstBlock.free();
   }
   getSharedMemory() {
     return {
       firstBlock: this.firstBlock.getSharedMemory()
     };
   }
-};
-l(R, "ALLOCATE_COUNT", 4);
-let kt = R;
-class jt {
+}
+class le {
+  static ALLOCATE_COUNT = u.ALLOCATE_COUNT;
+  heap;
+  list;
+  cache = /* @__PURE__ */ new Map();
   constructor(t, e) {
-    l(this, "heap");
-    l(this, "list");
-    l(this, "cache", /* @__PURE__ */ new Map());
-    e ? this.list = new d(t, e) : this.list = new d(t), this.heap = t, this.list.onDelete = (r) => {
+    e ? this.list = new u(t, e) : this.list = new u(t), this.heap = t, this.list.onDelete = (r) => {
       let i = Atomics.load(r, 0);
       if (i) {
         let o = this.cache.get(i);
@@ -1226,100 +1257,246 @@ class jt {
     this.list.free(), this.cache.clear();
   }
 }
-l(jt, "ALLOCATE_COUNT", d.ALLOCATE_COUNT);
-const Et = new ArrayBuffer(4), gt = new Uint32Array(Et), D = new Uint16Array(Et);
-function oe(s, t) {
-  return qt(Atomics.load(s, t));
+const D = 0, gt = 1, Et = 2, j = 3, pt = j + y.ALLOCATE_COUNT;
+class St {
+  static ALLOCATE_COUNT = 3 + y.ALLOCATE_COUNT * 2;
+  memory;
+  // Current Length, Type/DataLength, MaxChunkLength, Pointer vector, Recycle vector
+  firstBlock;
+  uint16Array;
+  pointerVector;
+  recycleVector;
+  cachedFullDataBlock = {};
+  get length() {
+    return Atomics.load(this.firstBlock.data, D) - this.recycleVector.length;
+  }
+  get maxChunkSize() {
+    return this.firstBlock.data[Et];
+  }
+  set maxChunkSize(t) {
+    Atomics.store(this.firstBlock.data, Et, t);
+  }
+  get type() {
+    return this.uint16Array[0];
+  }
+  set type(t) {
+    Atomics.store(this.uint16Array, 0, t);
+  }
+  get dataLength() {
+    return Math.max(1, this.uint16Array[1]);
+  }
+  set dataLength(t) {
+    Atomics.store(this.uint16Array, 1, t);
+  }
+  get bufferLength() {
+    return this.maxChunkSize * this.pointerVector.length;
+  }
+  constructor(t, e) {
+    if (this.memory = t, e && "firstBlock" in e)
+      this.firstBlock = new h(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + gt * Uint32Array.BYTES_PER_ELEMENT, 2), this.pointerVector = new y(t, {
+        firstBlock: {
+          bufferPosition: this.firstBlock.bufferPosition,
+          bufferByteOffset: this.firstBlock.bufferByteOffset + j * Uint32Array.BYTES_PER_ELEMENT
+        }
+      }), this.recycleVector = new y(t, {
+        firstBlock: {
+          bufferPosition: this.firstBlock.bufferPosition,
+          bufferByteOffset: this.firstBlock.bufferByteOffset + pt * Uint32Array.BYTES_PER_ELEMENT
+        }
+      });
+    else {
+      this.firstBlock = t.allocUI32(St.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + gt * Uint32Array.BYTES_PER_ELEMENT, 2);
+      let r = e?.dataLength ?? 1, i = e?.maxChunkSize ?? 100;
+      this.pointerVector = new y(t, {
+        type: Uint32Array,
+        firstBlock: {
+          bufferPosition: this.firstBlock.bufferPosition,
+          bufferByteOffset: this.firstBlock.bufferByteOffset + j * Uint32Array.BYTES_PER_ELEMENT
+        }
+      }), this.recycleVector = new y(t, {
+        type: Uint32Array,
+        firstBlock: {
+          bufferPosition: this.firstBlock.bufferPosition,
+          bufferByteOffset: this.firstBlock.bufferByteOffset + pt * Uint32Array.BYTES_PER_ELEMENT
+        }
+      });
+      let o = t.allocUI32(i * r);
+      this.pointerVector.push(o.pointer);
+      const a = e?.type ?? Uint32Array;
+      a === Uint32Array ? this.type = 0 : a === Int32Array ? this.type = 1 : a === Float32Array && (this.type = 2), this.dataLength = r, this.maxChunkSize = i;
+    }
+  }
+  at(t) {
+    let e = this.getFullDataBlock(t);
+    return this.getDataBlock(e, t % this.maxChunkSize);
+  }
+  get(t, e = 0) {
+    const r = this.dataLength;
+    if (e >= r)
+      throw new Error(`${e} is out of dataLength bounds ${r}`);
+    return this.getFullDataBlock(t)[t % this.maxChunkSize * r + e];
+  }
+  push(t) {
+    typeof t == "number" && (t = [t]);
+    let e = this.dataLength;
+    if (t.length > e)
+      throw new Error(`Can't insert ${t.length} array into shared list of ${e} dataLength`);
+    let r;
+    this.recycleVector.length ? r = this.recycleVector.pop()[0] : r = Atomics.add(this.firstBlock.data, D, 1);
+    let i = this.getFullDataBlock(r), o = r % this.maxChunkSize;
+    return i.set(t, e * o), r;
+  }
+  deleteIndex(t) {
+    this.recycleVector.push(t);
+  }
+  clear() {
+    this.firstBlock.data[D] = 0;
+  }
+  *[Symbol.iterator]() {
+    let t = [...this.recycleVector].reduce((i, o) => (i.push(...o), i), []), e = this.getFullDataBlock(0), r = 0;
+    for (let i = 0; i < Atomics.load(this.firstBlock.data, D); i++)
+      if (!t.includes(i)) {
+        let o = Math.floor(i / this.maxChunkSize);
+        o !== r && (e = this.getFullDataBlock(i), r = o), yield this.getDataBlock(e, i % this.maxChunkSize);
+      }
+  }
+  getFullDataBlock(t) {
+    let e = Math.floor(t / this.maxChunkSize), r = this.cachedFullDataBlock[e];
+    if (r)
+      return r;
+    if (e >= this.pointerVector.length) {
+      let a = this.memory.allocUI32(this.maxChunkSize * this.dataLength);
+      this.pointerVector.push(a.pointer);
+    }
+    let i = new h(this.memory, A(this.pointerVector.get(e))), o;
+    switch (this.type) {
+      case 1:
+        o = new Int32Array(i.data.buffer, i.bufferByteOffset, this.dataLength * this.maxChunkSize);
+        break;
+      case 0:
+        o = new Uint32Array(i.data.buffer, i.bufferByteOffset, this.dataLength * this.maxChunkSize);
+        break;
+      case 2:
+        o = new Float32Array(i.data.buffer, i.bufferByteOffset, this.dataLength * this.maxChunkSize);
+        break;
+      default:
+        throw new Error(`Unknown data block type ${this.type}`);
+    }
+    return this.cachedFullDataBlock[e] = o, o;
+  }
+  getDataBlock(t, e) {
+    const r = e * this.dataLength;
+    return t.subarray(r, r + this.dataLength);
+  }
+  free() {
+    this.recycleVector.free();
+    for (let t of this.pointerVector) {
+      let e = t[0];
+      new h(this.memory, A(e)).free();
+    }
+    this.pointerVector.free(), this.firstBlock.free();
+  }
+  getSharedMemory() {
+    return {
+      firstBlock: this.firstBlock.getSharedMemory()
+    };
+  }
 }
-function ae(s, t, e, r) {
-  Atomics.store(s, t, Jt(e, r));
+const _t = new ArrayBuffer(4), Ot = new Uint32Array(_t), R = new Uint16Array(_t);
+function he(s, t) {
+  return ee(Atomics.load(s, t));
 }
-function qt(s) {
-  return gt[0] = s, [D[0], D[1]];
+function ce(s, t, e, r) {
+  Atomics.store(s, t, re(e, r));
 }
-function Jt(s, t) {
-  return D[0] = s, D[1] = t, gt[0];
+function ee(s) {
+  return Ot[0] = s, [R[0], R[1]];
+}
+function re(s, t) {
+  return R[0] = s, R[1] = t, Ot[0];
 }
-const wt = new ArrayBuffer(8), Tt = new BigUint64Array(wt), b = new Uint16Array(wt);
-function fe(s, t) {
-  return Tt[0] = Atomics.load(s, t), [b[0], b[1], b[2], b[3]];
+const Mt = new ArrayBuffer(8), Pt = new BigUint64Array(Mt), B = new Uint16Array(Mt);
+function ue(s, t) {
+  return Pt[0] = Atomics.load(s, t), [B[0], B[1], B[2], B[3]];
 }
-function ne(s, t, e, r, i, o = 0) {
-  b[0] = e, b[1] = r, b[2] = i, b[3] = o, Atomics.store(s, t, Tt[0]);
+function de(s, t, e, r, i, o = 0) {
+  B[0] = e, B[1] = r, B[2] = i, B[3] = o, Atomics.store(s, t, Pt[0]);
 }
-const pt = new ArrayBuffer(4), _t = new Float32Array(pt), Ot = new Int32Array(pt);
-function le(s, t) {
-  return St(Atomics.load(s, t));
+const Nt = new ArrayBuffer(4), Ut = new Float32Array(Nt), Ct = new Int32Array(Nt);
+function ye(s, t) {
+  return It(Atomics.load(s, t));
 }
-function he(s, t, e) {
-  Atomics.store(s, t, Lt(e));
+function Be(s, t, e) {
+  Atomics.store(s, t, Dt(e));
 }
-function St(s) {
-  return Ot[0] = s, _t[0];
+function It(s) {
+  return Ct[0] = s, Ut[0];
 }
-function Lt(s) {
-  return _t[0] = s, Ot[0];
+function Dt(s) {
+  return Ut[0] = s, Ct[0];
 }
-function ce(s, t, e) {
-  return St(Atomics.exchange(s, t, Lt(e)));
+function me(s, t, e) {
+  return It(Atomics.exchange(s, t, Dt(e)));
 }
-const g = 0, v = 1, T = 2;
-function ue(s, t = 0) {
-  for (; Atomics.compareExchange(s, t, g, v) === T; )
-    Atomics.wait(s, t, T);
+const w = 0, q = 1, L = 2;
+function be(s, t = 0) {
+  for (; Atomics.compareExchange(s, t, w, q) === L; )
+    Atomics.wait(s, t, L);
   Atomics.add(s, t + 1, 1);
 }
-function de(s, t = 0) {
-  let e = Atomics.compareExchange(s, t, g, T);
-  for (; e !== g; )
-    Atomics.wait(s, t, e), e = Atomics.compareExchange(s, t, g, T);
+function ke(s, t = 0) {
+  let e = Atomics.compareExchange(s, t, w, L);
+  for (; e !== w; )
+    Atomics.wait(s, t, e), e = Atomics.compareExchange(s, t, w, L);
 }
-function ye(s, t = 0) {
-  Atomics.sub(s, t + 1, 1) - 1 <= 0 && (Atomics.compareExchange(s, t, v, g) !== v && console.warn("We are unlocking when it was not read locked!"), Atomics.notify(s, t));
+function Ae(s, t = 0) {
+  Atomics.sub(s, t + 1, 1) - 1 <= 0 && (Atomics.compareExchange(s, t, q, w) !== q && console.warn("We are unlocking when it was not read locked!"), Atomics.notify(s, t));
 }
-function me(s, t = 0) {
-  Atomics.compareExchange(s, t, T, g) !== T && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(s, t);
+function ge(s, t = 0) {
+  Atomics.compareExchange(s, t, L, w) !== L && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(s, t);
 }
-const be = 2;
+const Ee = 2;
 export {
-  c as AllocatedMemory,
-  Vt as BYTE_OFFSET_BIT_COUNT,
-  jt as CachedItemList,
-  q as MAX_BYTE_OFFSET_LENGTH,
-  J as MAX_POSITION_LENGTH,
-  G as MemoryBuffer,
-  ie as MemoryHeap,
-  te as POSITION_BIT_COUNT,
-  be as READ_WRITE_LOCK_ALLOCATE_COUNT,
-  re as SIMPLE_LOCK_ALLOCATE_COUNT,
-  d as SharedList,
-  ct as SharedMap,
-  se as SharedPointerList,
-  bt as SharedString,
-  kt as SharedVector,
-  Jt as convert16To32,
-  qt as convert32To16,
-  Lt as convertFloat32ToInt32,
-  St as convertInt32ToFloat32,
-  w as createPointer,
-  ce as exchangeFloat32,
-  S as getPointer,
-  oe as load16From32,
-  fe as load16From64,
-  le as loadFloat32,
-  h as loadPointer,
+  h as AllocatedMemory,
+  ie as BYTE_OFFSET_BIT_COUNT,
+  le as CachedItemList,
+  J as MAX_BYTE_OFFSET_LENGTH,
+  Q as MAX_POSITION_LENGTH,
+  V as MemoryBuffer,
+  ne as MemoryHeap,
+  se as POSITION_BIT_COUNT,
+  Ee as READ_WRITE_LOCK_ALLOCATE_COUNT,
+  ae as SIMPLE_LOCK_ALLOCATE_COUNT,
+  u as SharedList,
+  Tt as SharedMap,
+  fe as SharedPointerList,
+  St as SharedPool,
+  Lt as SharedString,
+  y as SharedVector,
+  re as convert16To32,
+  ee as convert32To16,
+  Dt as convertFloat32ToInt32,
+  It as convertInt32ToFloat32,
+  T as createPointer,
+  me as exchangeFloat32,
+  A as getPointer,
+  he as load16From32,
+  ue as load16From64,
+  ye as loadFloat32,
+  c as loadPointer,
   O as loadRawPointer,
-  C as lock,
-  ue as readLock,
-  ye as readUnlock,
-  ee as replacePointer,
-  $ as replaceRawPointer,
-  ae as store16In32,
-  ne as store16In64,
-  he as storeFloat32,
-  A as storePointer,
+  x as lock,
+  be as readLock,
+  Ae as readUnlock,
+  oe as replacePointer,
+  z as replaceRawPointer,
+  ce as store16In32,
+  de as store16In64,
+  Be as storeFloat32,
+  m as storePointer,
   W as storeRawPointer,
-  B as unlock,
-  de as writeLock,
-  me as writeUnlock
+  k as unlock,
+  ke as writeLock,
+  ge as writeUnlock
 };
+//# sourceMappingURL=shared-memory-objects.js.map