@daneren2005/shared-memory-objects 0.0.12 → 0.0.14

package/dist/shared-memory-objects.js

@@ -1,40 +1,40 @@
-const qt = 20, Jt = 12, V = Math.pow(2, 20), j = Math.pow(2, 12);
-function h(i, t = 0) {
-  return L(Atomics.load(i, t));
+const oe = 20, ae = 12, tt = Math.pow(2, 20), et = Math.pow(2, 12);
+function c(i, t = 0) {
+  return k(Atomics.load(i, t));
 }
-function S(i, t = 0) {
+function O(i, t = 0) {
   return Atomics.load(i, t);
 }
 function m(i, t = 0, e, r) {
-  Atomics.store(i, t, w(e, r));
+  Atomics.store(i, t, T(e, r));
 }
-function Z(i, t = 0, e) {
+function v(i, t = 0, e) {
   Atomics.store(i, t, e);
 }
-function Qt(i, t, e, r, s, o) {
-  let a = w(s, o);
-  return Atomics.compareExchange(i, t, a, w(e, r)) === a;
+function ne(i, t, e, r, s, o) {
+  let a = T(s, o);
+  return Atomics.compareExchange(i, t, a, T(e, r)) === a;
 }
-function R(i, t, e, r) {
+function Y(i, t, e, r) {
   return Atomics.compareExchange(i, t, r, e) === r;
 }
-function L(i) {
+function k(i) {
   return {
     bufferPosition: i & 4095,
     bufferByteOffset: i >>> 12
   };
 }
-function w(i, t) {
+function T(i, t) {
   return i + (t << 12);
 }
-class c {
+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;
@@ -60,15 +60,15 @@ class c {
     };
   }
 }
-const W = 0, C = 1;
-function D(i, t = 0) {
-  for (; Atomics.compareExchange(i, t, W, C) !== W; )
-    "WorkerGlobalScope" in self && Atomics.wait(i, t, C);
+const j = 0, F = 1;
+function x(i, t = 0) {
+  for (; Atomics.compareExchange(i, t, j, F) !== j; )
+    "WorkerGlobalScope" in self && Atomics.wait(i, t, F);
 }
-function b(i, t = 0) {
-  Atomics.compareExchange(i, t, C, W) !== C && console.warn("We are unlocking when it was not locked!"), Atomics.notify(i, t);
+function A(i, t = 0) {
+  Atomics.compareExchange(i, t, F, j) !== F && console.warn("We are unlocking when it was not locked!"), Atomics.notify(i, t);
 }
-const te = 1, Pt = {
+const fe = 1, Rt = {
   5120: "i8",
   5121: "u8",
   5122: "i16",
@@ -76,35 +76,35 @@ const te = 1, Pt = {
   5124: "i32",
   5125: "u32",
   5126: "f32"
-}, Nt = {
+}, $t = {
   f32: Float32Array,
   f64: Float64Array
-}, It = {
+}, zt = {
   i8: Int8Array,
   i16: Int16Array,
   i32: Int32Array
-}, Ut = {
+}, Yt = {
   u8: Uint8Array,
   u8c: Uint8ClampedArray,
   u16: Uint16Array,
   u32: Uint32Array
-}, Ct = {
+}, Ht = {
   i64: BigInt64Array,
   u64: BigUint64Array
-}, Dt = {
-  ...Nt,
-  ...It,
-  ...Ut
-}, Ft = (i) => {
-  const t = Pt[i];
+}, Vt = {
+  ...$t,
+  ...zt,
+  ...Yt
+}, Kt = (i) => {
+  const t = Rt[i];
   return t !== void 0 ? t : i;
 };
-function xt(i, ...t) {
-  const e = Ct[i];
-  return new (e || Dt[Ft(i)])(...t);
+function Gt(i, ...t) {
+  const e = Ht[i];
+  return new (e || Vt[Kt(i)])(...t);
 }
-const q = 0, J = 1, Q = 2, tt = 3, et = 4, A = 5, rt = 6, $ = 1, Y = 2, it = 32, H = 0, z = 1, d = 8;
-class K {
+const rt = 0, it = 1, st = 2, ot = 3, at = 4, g = 5, nt = 6, H = 1, V = 2, ft = 32, K = 0, G = 1, d = 8;
+class X {
   buf;
   start;
   u8;
@@ -112,7 +112,7 @@ class K {
   state;
   lock;
   constructor(t = {}) {
-    if (this.buf = t.buf ? t.buf : new ArrayBuffer(t.size || 4096), this.start = t.start != null ? P(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, it / 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, ft / 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`);
@@ -149,8 +149,8 @@ class K {
     return s && s.fill(r), s;
   }
   mallocAs(t, e) {
-    const r = this.malloc(e * Rt[t]);
-    return r ? xt(t, this.buf, r, e) : void 0;
+    const r = this.malloc(e * Xt[t]);
+    return r ? Gt(t, this.buf, r, e) : void 0;
   }
   calloc(t, e = 0) {
     const r = this.malloc(t);
@@ -159,8 +159,8 @@ class K {
   malloc(t) {
     if (t <= 0)
       return 0;
-    D(this.lock);
-    const e = P(t + d, this.align), r = this.end;
+    x(this.lock);
+    const e = N(t + d, this.align), r = this.end;
     let s = this.top, o = this._free, a = 0;
     for (; o; ) {
       const f = this.blockSize(o), n = o + f >= s;
@@ -172,16 +172,16 @@ class K {
           e,
           n
         );
-        return b(this.lock), l;
+        return A(this.lock), l;
       }
       a = o, o = this.blockNext(o);
     }
     if (o = s, s = o + e, s <= r) {
       this.initBlock(o, e, this._used), this._used = o, this.top = s;
       let f = _(o);
-      return b(this.lock), f;
+      return A(this.lock), f;
     }
-    return b(this.lock), 0;
+    return A(this.lock), 0;
   }
   mallocTop(t, e, r, s, o) {
     if (o && t + s > this.end) return 0;
@@ -196,7 +196,7 @@ class K {
   realloc(t, e) {
     if (e <= 0)
       return 0;
-    const r = M(t);
+    const r = P(t);
     let s = 0, o = this._used, a = 0;
     for (; o; ) {
       if (o === r) {
@@ -212,7 +212,7 @@ class K {
     ), _(s);
   }
   reallocBlock(t, e) {
-    const r = this.blockSize(t), s = t + r, o = s >= this.top, a = P(e + d, this.align);
+    const r = this.blockSize(t), s = t + r, o = s >= this.top, a = N(e + d, this.align);
     if (a <= r) {
       if (this.doSplit) {
         const f = r - a;
@@ -220,7 +220,7 @@ class K {
       } else o && (this.top = t + a);
       return [t, s];
     }
-    return o && t + a < this.end ? (this.top = t + this.setBlockSize(t, a), [t, s]) : (this.free(t), [M(this.malloc(e)), s]);
+    return o && t + a < this.end ? (this.top = t + this.setBlockSize(t, a), [t, s]) : (this.free(t), [P(this.malloc(e)), s]);
   }
   reallocArray(t, e) {
     if (t.buffer !== this.buf)
@@ -239,7 +239,7 @@ class K {
       e = t.byteOffset;
     } else
       e = t;
-    e = M(e);
+    e = P(e);
     let r = this._used;
     for (; r; ) {
       if (r === e)
@@ -260,14 +260,14 @@ class K {
       e = t.byteOffset;
     } else
       e = t;
-    D(this.lock), e = M(e);
+    x(this.lock), e = P(e);
     let r = this._used, s = 0;
     for (; r; ) {
       if (r === e)
-        return s ? this.unlinkBlock(s, r) : this._used = this.blockNext(r), this.insert(r), this.doCompact && this.compact(), b(this.lock), !0;
+        return s ? this.unlinkBlock(s, r) : this._used = this.blockNext(r), this.insert(r), this.doCompact && this.compact(), A(this.lock), !0;
       s = r, r = this.blockNext(r);
     }
-    return b(this.lock), !1;
+    return A(this.lock), !1;
   }
   freeAll() {
     this._free = 0, this._used = 0, this.top = this.initialTop();
@@ -276,57 +276,57 @@ class K {
     return delete this.u8, delete this.u32, delete this.state, delete this.buf, !0;
   }
   get align() {
-    return this.state[et];
+    return this.state[at];
   }
   set align(t) {
-    this.state[et] = t;
+    this.state[at] = t;
   }
   get end() {
-    return this.state[tt];
+    return this.state[ot];
   }
   set end(t) {
-    this.state[tt] = t;
+    this.state[ot] = t;
   }
   get top() {
-    return Atomics.load(this.state, Q);
+    return Atomics.load(this.state, st);
   }
   set top(t) {
-    Atomics.store(this.state, Q, t);
+    Atomics.store(this.state, st, t);
   }
   get _free() {
-    return Atomics.load(this.state, q);
+    return Atomics.load(this.state, rt);
   }
   set _free(t) {
-    Atomics.store(this.state, q, t);
+    Atomics.store(this.state, rt, t);
   }
   get _used() {
-    return Atomics.load(this.state, J);
+    return Atomics.load(this.state, it);
   }
   set _used(t) {
-    Atomics.store(this.state, J, t);
+    Atomics.store(this.state, it, t);
   }
   get doCompact() {
-    return !!(this.state[A] & $);
+    return !!(this.state[g] & H);
   }
   set doCompact(t) {
-    t ? this.state[A] |= 1 << $ - 1 : this.state[A] &= ~$;
+    t ? this.state[g] |= 1 << H - 1 : this.state[g] &= ~H;
   }
   get doSplit() {
-    return !!(this.state[A] & Y);
+    return !!(this.state[g] & V);
   }
   set doSplit(t) {
-    t ? this.state[A] |= 1 << Y - 1 : this.state[A] &= ~Y;
+    t ? this.state[g] |= 1 << V - 1 : this.state[g] &= ~V;
   }
   get minSplit() {
-    return this.state[rt];
+    return this.state[nt];
   }
   set minSplit(t) {
     if (t <= d)
       throw new Error(`illegal min split threshold: ${t}, require at least ${d + 1}`);
-    this.state[rt] = t;
+    this.state[nt] = t;
   }
   blockSize(t) {
-    return Atomics.load(this.u32, (t >> 2) + H);
+    return Atomics.load(this.u32, (t >> 2) + K);
   }
   /**
    * Sets & returns given block size.
@@ -335,10 +335,10 @@ class K {
    * @param size -
    */
   setBlockSize(t, e) {
-    return Atomics.store(this.u32, (t >> 2) + H, e), e;
+    return Atomics.store(this.u32, (t >> 2) + K, e), e;
   }
   blockNext(t) {
-    return Atomics.load(this.u32, (t >> 2) + z);
+    return Atomics.load(this.u32, (t >> 2) + G);
   }
   /**
    * Sets block next pointer to `next`. Use zero to indicate list end.
@@ -346,7 +346,7 @@ class K {
    * @param block -
    */
   setBlockNext(t, e) {
-    Atomics.store(this.u32, (t >> 2) + z, e);
+    Atomics.store(this.u32, (t >> 2) + G, e);
   }
   /**
    * Initializes block header with given `size` and `next` pointer. Returns `block`.
@@ -357,7 +357,7 @@ class K {
    */
   initBlock(t, e, r) {
     const s = t >>> 2;
-    return Atomics.store(this.u32, s + H, e), Atomics.store(this.u32, s + z, r), t;
+    return Atomics.store(this.u32, s + K, e), Atomics.store(this.u32, s + G, r), t;
   }
   unlinkBlock(t, e) {
     this.setBlockNext(t, this.blockNext(e));
@@ -372,7 +372,7 @@ class K {
     ), this.doCompact && this.compact();
   }
   initialTop(t = this.align) {
-    return P(this.start + it + d, t) - d;
+    return N(this.start + ft + d, t) - d;
   }
   /**
    * Traverses free list and attempts to recursively merge blocks
@@ -411,7 +411,7 @@ class K {
     r ? this.setBlockNext(r, t) : this._free = t, this.setBlockNext(t, e);
   }
 }
-const _ = (i) => i > 0 ? i + d : 0, M = (i) => i > 0 ? i - d : 0, P = (i, t) => (t--, i + t & ~t), Rt = {
+const _ = (i) => i > 0 ? i + d : 0, P = (i) => i > 0 ? i - d : 0, N = (i, t) => (t--, i + t & ~t), Xt = {
   u8: 1,
   u8c: 1,
   i8: 1,
@@ -423,7 +423,7 @@ const _ = (i) => i > 0 ? i + d : 0, M = (i) => i > 0 ? i - d : 0, P = (i, t) =>
   u64: 8,
   f32: 4,
   f64: 8
-}, $t = [
+}, Zt = [
   "B",
   "kB",
   "MB",
@@ -433,7 +433,7 @@ const _ = (i) => i > 0 ? i + d : 0, M = (i) => i > 0 ? i - d : 0, P = (i, t) =>
   "EB",
   "ZB",
   "YB"
-], Yt = [
+], Wt = [
   "B",
   "KiB",
   "MiB",
@@ -443,7 +443,7 @@ const _ = (i) => i > 0 ? i + d : 0, M = (i) => i > 0 ? i - d : 0, P = (i, t) =>
   "EiB",
   "ZiB",
   "YiB"
-], Ht = [
+], vt = [
   "b",
   "kbit",
   "Mbit",
@@ -453,7 +453,7 @@ const _ = (i) => i > 0 ? i + d : 0, M = (i) => i > 0 ? i - d : 0, P = (i, t) =>
   "Ebit",
   "Zbit",
   "Ybit"
-], zt = [
+], jt = [
   "b",
   "kibit",
   "Mibit",
@@ -463,26 +463,26 @@ const _ = (i) => i > 0 ? i + d : 0, M = (i) => i > 0 ? i - d : 0, P = (i, t) =>
   "Eibit",
   "Zibit",
   "Yibit"
-], st = (i, t, e) => {
+], lt = (i, t, e) => {
   let r = i;
   return typeof t == "string" || Array.isArray(t) ? r = i.toLocaleString(t, e) : (t === !0 || e !== void 0) && (r = i.toLocaleString(void 0, e)), r;
-}, bt = (i) => {
+}, Lt = (i) => {
   if (typeof i == "number")
     return Math.log10(i);
   const t = i.toString(10);
   return t.length + Math.log10(`0.${t.slice(0, 15)}`);
-}, Kt = (i) => typeof i == "number" ? Math.log(i) : bt(i) * Math.log(10), Gt = (i, t) => {
+}, qt = (i) => typeof i == "number" ? Math.log(i) : Lt(i) * Math.log(10), Jt = (i, t) => {
   if (typeof i == "number")
     return i / t;
   const e = i / BigInt(t), r = i % BigInt(t);
   return Number(e) + Number(r) / t;
-}, ot = (i, t) => {
+}, ht = (i, t) => {
   if (t === void 0)
     return i;
   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 ? i : i.length < t ? i.padStart(t, " ") : i;
-}, Xt = (i) => {
+}, Qt = (i) => {
   const { minimumFractionDigits: t, maximumFractionDigits: e } = i;
   if (!(t === void 0 && e === void 0))
     return {
@@ -491,7 +491,7 @@ const _ = (i) => i > 0 ? i + d : 0, M = (i) => i > 0 ? i - d : 0, P = (i, t) =>
       roundingMode: "trunc"
     };
 };
-function Zt(i, t) {
+function te(i, t) {
   if (typeof i != "bigint" && !Number.isFinite(i))
     throw new TypeError(`Expected a finite number, got ${typeof i}: ${i}`);
   t = {
@@ -501,78 +501,78 @@ function Zt(i, t) {
     nonBreakingSpace: !1,
     ...t
   };
-  const e = t.bits ? t.binary ? zt : Ht : t.binary ? Yt : $t, r = t.space ? t.nonBreakingSpace ? " " : " " : "", s = typeof i == "number" ? i === 0 : i === 0n;
+  const e = t.bits ? t.binary ? jt : vt : t.binary ? Wt : Zt, r = t.space ? t.nonBreakingSpace ? " " : " " : "", s = typeof i == "number" ? i === 0 : i === 0n;
   if (t.signed && s) {
     const l = ` 0${r}${e[0]}`;
-    return ot(l, t.fixedWidth);
+    return ht(l, t.fixedWidth);
   }
   const o = i < 0, a = o ? "-" : t.signed ? "+" : "";
   o && (i = -i);
-  const f = Xt(t);
+  const f = Qt(t);
   let n;
   if (i < 1) {
-    const l = st(i, t.locale, f);
+    const l = lt(i, t.locale, f);
     n = a + l + r + e[0];
   } else {
-    const l = Math.min(Math.floor(t.binary ? Kt(i) / Math.log(1024) : bt(i) / 3), e.length - 1);
-    if (i = Gt(i, (t.binary ? 1024 : 1e3) ** l), !f) {
-      const O = Math.max(3, Math.floor(i).toString().length);
-      i = i.toPrecision(O);
+    const l = Math.min(Math.floor(t.binary ? qt(i) / Math.log(1024) : Lt(i) / 3), e.length - 1);
+    if (i = Jt(i, (t.binary ? 1024 : 1e3) ** l), !f) {
+      const M = Math.max(3, Math.floor(i).toString().length);
+      i = i.toPrecision(M);
     }
-    const T = st(Number(i), t.locale, f), x = e[l];
-    n = a + T + r + x;
+    const S = lt(Number(i), t.locale, f), z = e[l];
+    n = a + S + r + z;
   }
-  return ot(n, t.fixedWidth);
+  return ht(n, t.fixedWidth);
 }
-const Wt = 8192, at = 0, G = 1, N = 2;
-class ee {
+const ee = 8192, ct = 0, Z = 1, I = 2;
+class le {
   buffers;
   onGrowBufferHandlers = [];
   isClone;
   memory;
   get bufferSize() {
-    return this.memory.data[at];
+    return this.memory.data[ct];
   }
   constructor(t) {
     if (t && "buffers" in t)
-      this.buffers = t.buffers.map((e) => new K({
+      this.buffers = t.buffers.map((e) => new X({
         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?.bufferSize ?? Wt;
-      if (e > V)
-        throw new Error(`Buffer size ${e} is greater than max ${V} that we can reference with pointers`);
+      const e = t?.bufferSize ?? ee;
+      if (e > tt)
+        throw new Error(`Buffer size ${e} is greater than max ${tt} that we can reference with pointers`);
       let r = this.createBuffer(e);
       this.buffers = [
         r
       ];
       const s = r.callocAs("u32", 3);
       if (s)
-        this.memory = new c(this, {
+        this.memory = new h(this, {
           bufferPosition: 0,
           bufferByteOffset: s.byteOffset
         });
       else
         throw new Error("Failed to initialize first byte from buffer");
-      this.memory.data[at] = e, this.memory.data[G] = 1, this.memory.data[N] = t?.autoGrowSize ?? 100, this.isClone = !1;
+      this.memory.data[ct] = e, this.memory.data[Z] = 1, this.memory.data[I] = t?.autoGrowSize ?? 100, this.isClone = !1;
       for (let o = 1; o < (t?.initialBuffers ?? 1); o++)
         this.buffers.push(this.createBuffer(e));
     }
   }
   addSharedBuffer(t) {
-    this.buffers[t.bufferPosition] = new K({
+    this.buffers[t.bufferPosition] = new X({
       buf: t.buffer,
       skipInitialization: !0
     });
   }
   growBuffer() {
     const t = this.createBuffer();
-    let e = Atomics.add(this.memory.data, G, 1);
+    let e = Atomics.add(this.memory.data, Z, 1);
     return this.buffers[e] = t, this.onGrowBufferHandlers.forEach((r) => r({
       bufferPosition: e,
       buffer: t.buf
@@ -581,7 +581,7 @@ class ee {
   createBuffer(t) {
     const e = t ?? this.bufferSize;
     let r;
-    return "SharedArrayBuffer" in globalThis ? r = new SharedArrayBuffer(e) : r = new ArrayBuffer(e), new K({
+    return "SharedArrayBuffer" in globalThis ? r = new SharedArrayBuffer(e) : r = new ArrayBuffer(e), new X({
       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
@@ -601,17 +601,17 @@ class ee {
         continue;
       const a = o.callocAs("u32", t);
       if (a)
-        return s === this.buffers.length - 1 && Atomics.load(this.memory.data, G) === this.buffers.length && this.memory.data[N] < 100 && this.memory.data[N] > 0 && o.top / o.end > this.memory.data[N] / 100 && this.growBuffer(), new c(this, {
+        return s === this.buffers.length - 1 && Atomics.load(this.memory.data, Z) === this.buffers.length && this.memory.data[I] < 100 && this.memory.data[I] > 0 && o.top / o.end > this.memory.data[I] / 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 >= et)
+      throw new Error(`Can't initialize a new buffer since it would have a position greater than the max of ${et}`);
     let e = this.growBuffer();
     const r = e.callocAs("u32", t);
     if (r)
-      return new c(this, {
+      return new h(this, {
         data: r,
         buffer: e
       });
@@ -619,7 +619,7 @@ class ee {
   }
   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);
@@ -628,7 +628,7 @@ class ee {
     return this.buffers[0].buf.byteLength * this.buffers.length;
   }
   prettyMemory() {
-    return `${nt(this.currentUsed)} / ${nt(this.totalAllocated)}`;
+    return `${ut(this.currentUsed)} / ${ut(this.totalAllocated)}`;
   }
   getSharedMemory() {
     return {
@@ -636,16 +636,16 @@ class ee {
     };
   }
 }
-function nt(i) {
-  return Zt(i, {
+function ut(i) {
+  return te(i, {
     binary: !0,
     minimumFractionDigits: 1,
     maximumFractionDigits: 1
   });
 }
-const ft = 4, lt = 1, g = 2;
+const dt = 4, yt = 1, E = 2;
 class u {
-  static ALLOCATE_COUNT = ft;
+  static ALLOCATE_COUNT = dt;
   memory;
   /* First block
   	32 index 0
@@ -670,7 +670,7 @@ class u {
   uint16Array;
   onDelete;
   get length() {
-    return Atomics.load(this.firstBlock.data, g);
+    return Atomics.load(this.firstBlock.data, E);
   }
   get type() {
     return Atomics.load(this.uint16Array, 0);
@@ -686,9 +686,9 @@ class u {
   }
   constructor(t, e) {
     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 + (g + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
+      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 c(t, e.initWithBlock) : this.firstBlock = t.allocUI32(ft), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (g + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
+      e && e.initWithBlock ? this.firstBlock = new h(t, e.initWithBlock) : this.firstBlock = t.allocUI32(dt), 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;
     }
@@ -698,18 +698,18 @@ class u {
     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), s = this.getDataBlock(r.data), o = r.pointer;
+    let r = this.memory.allocUI32(yt + e), s = this.getDataBlock(r.data), o = r.pointer;
     for (let n = 0; n < t.length; n++)
       s instanceof Int32Array || s instanceof Uint32Array ? Atomics.store(s, n, t[n]) : s[n] = t[n];
     let a, f = !1;
     for (; !f; )
-      a = S(this.firstBlock.data, 1), f = R(this.firstBlock.data, 1, o, a);
+      a = O(this.firstBlock.data, 1), f = Y(this.firstBlock.data, 1, o, a);
     if (a) {
-      let { bufferPosition: n, bufferByteOffset: l } = L(a), T = new Uint32Array(this.memory.buffers[n].buf, l, 1);
-      Z(T, 0, o);
+      let { bufferPosition: n, bufferByteOffset: l } = k(a), S = new Uint32Array(this.memory.buffers[n].buf, l, 1);
+      v(S, 0, o);
     } else
-      Z(this.firstBlock.data, 0, o);
-    Atomics.add(this.firstBlock.data, g, 1);
+      v(this.firstBlock.data, 0, o);
+    Atomics.add(this.firstBlock.data, E, 1);
   }
   deleteMatch(t) {
     for (let { data: e, index: r, deleteCurrent: s } of this)
@@ -733,39 +733,39 @@ class u {
   clear() {
     let t, e, r = !1;
     for (; !r; ) {
-      if (t = S(this.firstBlock.data, 0), e = S(this.firstBlock.data, 1), !e)
+      if (t = O(this.firstBlock.data, 0), e = O(this.firstBlock.data, 1), !e)
         return;
-      r = R(this.firstBlock.data, 1, 0, e);
+      r = Y(this.firstBlock.data, 1, 0, e);
     }
     if (!t)
       return;
-    R(this.firstBlock.data, 0, 0, t);
+    Y(this.firstBlock.data, 0, 0, t);
     let s = 0, o = t;
     for (; o; ) {
-      let { bufferPosition: a, bufferByteOffset: f } = L(o), n = this.memory.buffers[a];
+      let { bufferPosition: a, bufferByteOffset: f } = k(o), n = this.memory.buffers[a];
       if (!n)
         break;
       let l = new Uint32Array(n.buf, f, 2);
-      o = S(l, 0), s++, this.onDelete && this.onDelete(this.getDataBlock(l)), n.free(l.byteOffset);
+      o = O(l, 0), s++, this.onDelete && this.onDelete(this.getDataBlock(l)), n.free(l.byteOffset);
     }
-    Atomics.sub(this.firstBlock.data, g, s);
+    Atomics.sub(this.firstBlock.data, E, s);
   }
   *[Symbol.iterator]() {
-    let t = 0, { bufferPosition: e, bufferByteOffset: r } = h(this.firstBlock.data, 0), s = this.firstBlock.data, o = 0, a = 0;
+    let t = 0, { bufferPosition: e, bufferByteOffset: r } = c(this.firstBlock.data, 0), s = this.firstBlock.data, o = 0, a = 0;
     for (; r; ) {
       let f = this.memory.buffers[e];
       if (!f)
         return;
-      let n = new Uint32Array(f.buf, r, 2), l = this.getDataBlock(n), T = e, x = r;
-      ({ bufferPosition: e, bufferByteOffset: r } = h(n, 0));
-      let O = !0;
+      let n = new Uint32Array(f.buf, r, 2), l = this.getDataBlock(n), S = e, z = r;
+      ({ bufferPosition: e, bufferByteOffset: r } = c(n, 0));
+      let M = !0;
       yield {
         data: l,
         index: t,
         deleteCurrent: () => {
-          m(s, 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, g, 1), O = !1;
+          m(s, 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;
         }
-      }, O && (s = n, o = T, a = x, t++);
+      }, M && (s = n, o = S, a = z, t++);
     }
   }
   forEach(t) {
@@ -778,7 +778,7 @@ class u {
     };
   }
   getDataBlock(t) {
-    const e = t.byteOffset + lt * t.BYTES_PER_ELEMENT;
+    const e = t.byteOffset + yt * t.BYTES_PER_ELEMENT;
     switch (this.type) {
       case 1:
         return new Int32Array(t.buffer, e, this.dataLength);
@@ -791,26 +791,26 @@ class u {
     }
   }
   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();
   }
 }
-const ht = 10;
-class At {
+const Bt = 10;
+class St {
   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);
@@ -820,21 +820,21 @@ class At {
   }
   constructor(t, e) {
     if (this.memory = t, e)
-      this.pointerMemory = new c(t, e.firstBlock);
+      this.pointerMemory = new h(t, e.firstBlock);
     else {
-      this.pointerMemory = t.allocUI32(At.ALLOCATE_COUNT);
-      let r = t.allocUI32(ht);
-      m(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, ht);
+      this.pointerMemory = t.allocUI32(St.ALLOCATE_COUNT);
+      let r = t.allocUI32(Bt);
+      m(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, Bt);
     }
     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 = I(t);
+    let r = U(t);
     this.setHashKey(this.hashMemory, this.maxHash, r, e) && Atomics.add(this.pointerMemory.data, 2, 1);
   }
   setHashKey(t, e, r, s) {
-    let o = this.hash(r, e), a, f = h(t.data, o);
+    let o = this.hash(r, e), a, f = c(t.data, o);
     if (f.bufferByteOffset === 0) {
       a = new u(this.memory, {
         dataLength: 2
@@ -849,7 +849,7 @@ class At {
     return a.deleteValue(r) && (n = !1), a.insert([r, s]), n;
   }
   get(t) {
-    let e = I(t), r = this.hash(e, this.maxHash), s = h(this.hashMemory.data, r);
+    let e = U(t), r = this.hash(e, this.maxHash), s = c(this.hashMemory.data, r);
     if (s.bufferByteOffset === 0)
       return;
     let o = new u(this.memory, {
@@ -860,7 +860,7 @@ class At {
         return a[1];
   }
   has(t) {
-    let e = I(t), r = this.hash(e, this.maxHash), s = h(this.hashMemory.data, r);
+    let e = U(t), r = this.hash(e, this.maxHash), s = c(this.hashMemory.data, r);
     if (s.bufferByteOffset === 0)
       return !1;
     let o = new u(this.memory, {
@@ -872,7 +872,7 @@ class At {
     return !1;
   }
   delete(t) {
-    let e = I(t), r = this.hash(e, this.maxHash), s = h(this.hashMemory.data, r);
+    let e = U(t), r = this.hash(e, this.maxHash), s = c(this.hashMemory.data, r);
     if (s.bufferByteOffset === 0)
       return !1;
     let o = new u(this.memory, {
@@ -886,7 +886,7 @@ class At {
   growHashTable() {
     let t = this.maxHash, e = t * 2, r = this.memory.allocUI32(e), s = this.hashMemory;
     for (let o = 0; o < t; o++) {
-      let a = h(s.data, o);
+      let a = c(s.data, o);
       if (a.bufferByteOffset === 0)
         continue;
       let f = new u(this.memory, {
@@ -902,7 +902,7 @@ class At {
   }
   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 u(this.memory, {
@@ -917,10 +917,10 @@ class At {
     };
   }
 }
-function I(i) {
-  return typeof i == "number" ? i : typeof i == "string" ? vt(i) : i;
+function U(i) {
+  return typeof i == "number" ? i : typeof i == "string" ? re(i) : i;
 }
-function vt(i) {
+function re(i) {
   let t = i.length, e = 17 ^ t, r = 0, s;
   for (; t >= 4; )
     s = i.charCodeAt(r) & 255 | (i.charCodeAt(++r) & 255) << 8 | (i.charCodeAt(++r) & 255) << 16 | (i.charCodeAt(++r) & 255) << 14, s = (s & 65535) * 1540483477 + (((s >>> 16) * 1540483477 & 65535) << 16), s ^= s >>> 14, s = (s & 65535) * 1540483477 + (((s >>> 16) * 1540483477 & 65535) << 16), e = (e & 65535) * 1540483477 + (((e >>> 16) * 1540483477 & 65535) << 16) ^ s, t -= 4, ++r;
@@ -934,7 +934,7 @@ function vt(i) {
   }
   return e ^= e >>> 13, e = (e & 65535) * 1540483477 + (((e >>> 16) * 1540483477 & 65535) << 16), e ^= e >>> 15, e = e >>> 0, e;
 }
-class re {
+class he {
   memory;
   list;
   constructor(t, e) {
@@ -944,15 +944,15 @@ class re {
     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: s } = h(e, 0), o = new c(this.memory, {
+      let { bufferPosition: r, bufferByteOffset: s } = c(e, 0), o = new h(this.memory, {
         bufferPosition: r,
         bufferByteOffset: s
       });
@@ -977,11 +977,11 @@ class re {
     this.list.free();
   }
 }
-const ct = {
+const mt = {
   1: Uint8Array,
   2: Uint16Array
-}, U = 0, ut = 1, dt = 2, yt = 3;
-class gt {
+}, C = 0, bt = 1, At = 2, kt = 3;
+class _t {
   static ALLOCATE_COUNT = 4;
   memory;
   allocatedMemory;
@@ -989,11 +989,11 @@ class gt {
   cachedPointer;
   cachedString;
   constructor(t, e) {
-    this.memory = t, typeof e == "string" ? (this.allocatedMemory = this.memory.allocUI32(gt.ALLOCATE_COUNT), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + yt * 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 + yt * this.allocatedMemory.data.BYTES_PER_ELEMENT), "value" in e && this.updateString(e.value));
+    this.memory = t, typeof e == "string" ? (this.allocatedMemory = this.memory.allocUI32(_t.ALLOCATE_COUNT), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + kt * 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 + kt * this.allocatedMemory.data.BYTES_PER_ELEMENT), "value" in e && this.updateString(e.value));
   }
   updateString(t) {
     let e = this.createString(t);
-    D(this.lock), Z(this.allocatedMemory.data, U, e.pointer), Atomics.store(this.allocatedMemory.data, ut, t.length), Atomics.store(this.allocatedMemory.data, dt, e.charType), b(this.lock), this.cachedPointer = e.pointer, this.cachedString = t;
+    x(this.lock), v(this.allocatedMemory.data, C, e.pointer), Atomics.store(this.allocatedMemory.data, bt, t.length), Atomics.store(this.allocatedMemory.data, At, e.charType), A(this.lock), this.cachedPointer = e.pointer, this.cachedString = t;
   }
   createString(t) {
     if (t === "")
@@ -1005,7 +1005,7 @@ class gt {
     let e = [];
     for (let n = 0; n < t.length; n++)
       e.push(t.charCodeAt(n));
-    let s = Math.max(...e) > 255 ? 2 : 1, o = ct[s], a = this.memory.allocUI32(Math.ceil(t.length / (4 / o.BYTES_PER_ELEMENT))), f = new o(a.data.buffer, a.data.byteOffset, t.length);
+    let s = Math.max(...e) > 255 ? 2 : 1, o = mt[s], 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 {
@@ -1014,18 +1014,18 @@ class gt {
     };
   }
   get value() {
-    let t = S(this.allocatedMemory.data, U);
+    let t = O(this.allocatedMemory.data, C);
     if (this.cachedPointer === t && this.cachedString !== void 0)
       return this.cachedString;
     if (t === 0)
       return "";
-    let { bufferPosition: e, bufferByteOffset: r } = L(t);
-    D(this.lock);
-    let s = Atomics.load(this.allocatedMemory.data, dt), o = ct[s], a = Atomics.load(this.allocatedMemory.data, ut), f = new o(this.memory.buffers[e].buf, r, a), n = String.fromCharCode.apply(null, f);
-    return b(this.lock), this.cachedPointer = t, this.cachedString = n, n;
+    let { bufferPosition: e, bufferByteOffset: r } = k(t);
+    x(this.lock);
+    let s = Atomics.load(this.allocatedMemory.data, At), o = mt[s], a = Atomics.load(this.allocatedMemory.data, bt), f = new o(this.memory.buffers[e].buf, r, a), n = String.fromCharCode.apply(null, f);
+    return A(this.lock), this.cachedPointer = t, this.cachedString = n, n;
   }
   set value(t) {
-    let { bufferPosition: e, bufferByteOffset: r } = h(this.allocatedMemory.data, U);
+    let { bufferPosition: e, bufferByteOffset: r } = c(this.allocatedMemory.data, C);
     this.updateString(t), r && this.memory.buffers[e].free(r);
   }
   getSharedMemory() {
@@ -1035,19 +1035,19 @@ class gt {
     return this.allocatedMemory.pointer;
   }
   free() {
-    let { bufferPosition: t, bufferByteOffset: e } = h(this.allocatedMemory.data, U);
+    let { bufferPosition: t, bufferByteOffset: e } = c(this.allocatedMemory.data, C);
     e && this.memory.buffers[t].free(e), this.allocatedMemory.free();
   }
 }
-const k = 0, B = 1, mt = 2, Bt = 3, X = 4;
-class kt {
+const w = 0, b = 1, gt = 2, Et = 3, W = 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, B);
+    return Atomics.load(this.firstBlock.data, b);
   }
   get type() {
     return this.uint16Array[0];
@@ -1062,10 +1062,10 @@ class kt {
     Atomics.store(this.uint16Array, 1, t);
   }
   get bufferLength() {
-    return Atomics.load(this.firstBlock.data, mt);
+    return Atomics.load(this.firstBlock.data, gt);
   }
   set bufferLength(t) {
-    Atomics.store(this.firstBlock.data, mt, t);
+    Atomics.store(this.firstBlock.data, gt, t);
   }
   get pointer() {
     return this.firstBlock.pointer;
@@ -1074,18 +1074,18 @@ class kt {
   cachedPointer;
   constructor(t, e) {
     if (this.memory = t, e && "firstBlock" in e) {
-      if (this.firstBlock = new c(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + Bt * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in e || "dataLength" in e) {
-        let r = t.allocUI32(X * (e.dataLength ?? 1));
-        m(this.firstBlock.data, k, r.bufferPosition, r.bufferByteOffset), this.bufferLength = X, this.dataLength = e.dataLength ?? 1;
+      if (this.firstBlock = new h(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + Et * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in e || "dataLength" in e) {
+        let r = t.allocUI32(W * (e.dataLength ?? 1));
+        m(this.firstBlock.data, w, r.bufferPosition, r.bufferByteOffset), this.bufferLength = W, 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(kt.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + Bt * Uint32Array.BYTES_PER_ELEMENT, 2);
-      let r = e?.dataLength ?? 1, s = e?.bufferLength ?? X, o = t.allocUI32(s * r);
-      m(this.firstBlock.data, k, o.bufferPosition, o.bufferByteOffset), this.bufferLength = s;
+      this.firstBlock = t.allocUI32(y.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + Et * Uint32Array.BYTES_PER_ELEMENT, 2);
+      let r = e?.dataLength ?? 1, s = e?.bufferLength ?? W, o = t.allocUI32(s * r);
+      m(this.firstBlock.data, w, o.bufferPosition, o.bufferByteOffset), this.bufferLength = s;
       const a = e?.type ?? Uint32Array;
       a === Uint32Array ? this.type = 0 : a === Int32Array ? this.type = 1 : a === Float32Array && (this.type = 2), this.dataLength = r;
     }
@@ -1111,10 +1111,10 @@ class kt {
     if (t.length > e)
       throw new Error(`Can't insert ${t.length} array into shared list of ${e} dataLength`);
     let r = this.getFullDataBlock(), s = this.length;
-    return r.set(t, e * s), Atomics.add(this.firstBlock.data, B, 1) + 1 >= this.bufferLength && this.growBuffer(), s;
+    return r.set(t, e * s), Atomics.add(this.firstBlock.data, b, 1) + 1 >= this.bufferLength && this.growBuffer(), s;
   }
   pop() {
-    let t = Atomics.sub(this.firstBlock.data, B, B), e = this.getFullDataBlock();
+    let t = Atomics.sub(this.firstBlock.data, b, b), e = this.getFullDataBlock();
     return this.getDataBlock(e, t - 1);
   }
   deleteIndex(t) {
@@ -1125,10 +1125,10 @@ class kt {
     for (let o = t; o < e; o++)
       for (let a = 0; a < r; a++)
         s[o * r + a] = s[(o + 1) * r + a];
-    Atomics.sub(this.firstBlock.data, B, B);
+    Atomics.sub(this.firstBlock.data, b, b);
   }
   clear() {
-    this.firstBlock.data[B] = 0;
+    this.firstBlock.data[b] = 0;
   }
   *[Symbol.iterator]() {
     let t = this.getFullDataBlock();
@@ -1136,10 +1136,10 @@ class kt {
       yield this.getDataBlock(t, e);
   }
   getFullDataBlock() {
-    let t = Atomics.load(this.firstBlock.data, k);
+    let t = Atomics.load(this.firstBlock.data, w);
     if (this.cachedPointer === t && this.cachedFullDataBlock)
       return this.cachedFullDataBlock;
-    let e = L(t), r = new c(this.memory, e), s;
+    let e = k(t), r = new h(this.memory, e), s;
     switch (this.type) {
       case 1:
         s = new Int32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
@@ -1160,7 +1160,7 @@ class kt {
     return t.subarray(r, r + this.dataLength);
   }
   growBuffer() {
-    let e = this.bufferLength * 2, r = this.dataLength, s = h(this.firstBlock.data, k), o = new c(this.memory, s), a = this.getFullDataBlock(), f = this.memory.allocUI32(e * r), n;
+    let e = this.bufferLength * 2, r = this.dataLength, s = c(this.firstBlock.data, w), o = new h(this.memory, s), a = this.getFullDataBlock(), f = this.memory.allocUI32(e * r), n;
     switch (this.type) {
       case 1:
         n = new Int32Array(f.data.buffer, f.bufferByteOffset, r * this.bufferLength);
@@ -1174,11 +1174,11 @@ class kt {
       default:
         throw new Error(`Unknown data block type ${this.type}`);
     }
-    n.set(a), m(this.firstBlock.data, k, f.bufferPosition, f.bufferByteOffset), this.bufferLength = e, o.free();
+    n.set(a), m(this.firstBlock.data, w, f.bufferPosition, f.bufferByteOffset), this.bufferLength = e, o.free();
   }
   free() {
-    let t = h(this.firstBlock.data, k);
-    new c(this.memory, t).free(), this.firstBlock.free();
+    let t = c(this.firstBlock.data, w);
+    new h(this.memory, t).free(), this.firstBlock.free();
   }
   getSharedMemory() {
     return {
@@ -1186,7 +1186,7 @@ class kt {
     };
   }
 }
-class ie {
+class ce {
   static ALLOCATE_COUNT = u.ALLOCATE_COUNT;
   heap;
   list;
@@ -1257,100 +1257,278 @@ class ie {
     this.list.free(), this.cache.clear();
   }
 }
-const Et = new ArrayBuffer(4), wt = new Uint32Array(Et), F = new Uint16Array(Et);
+const D = 0, wt = 1, pt = 2, q = 3, Tt = q + y.ALLOCATE_COUNT;
+class Ot {
+  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[pt];
+  }
+  set maxChunkSize(t) {
+    Atomics.store(this.firstBlock.data, pt, 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 + wt * Uint32Array.BYTES_PER_ELEMENT, 2), this.pointerVector = new y(t, {
+        firstBlock: {
+          bufferPosition: this.firstBlock.bufferPosition,
+          bufferByteOffset: this.firstBlock.bufferByteOffset + q * Uint32Array.BYTES_PER_ELEMENT
+        }
+      }), this.recycleVector = new y(t, {
+        firstBlock: {
+          bufferPosition: this.firstBlock.bufferPosition,
+          bufferByteOffset: this.firstBlock.bufferByteOffset + Tt * Uint32Array.BYTES_PER_ELEMENT
+        }
+      });
+    else {
+      this.firstBlock = t.allocUI32(Ot.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + wt * Uint32Array.BYTES_PER_ELEMENT, 2);
+      let r = e?.dataLength ?? 1, s = e?.maxChunkSize ?? 100;
+      this.pointerVector = new y(t, {
+        type: Uint32Array,
+        firstBlock: {
+          bufferPosition: this.firstBlock.bufferPosition,
+          bufferByteOffset: this.firstBlock.bufferByteOffset + q * Uint32Array.BYTES_PER_ELEMENT
+        }
+      }), this.recycleVector = new y(t, {
+        type: Uint32Array,
+        firstBlock: {
+          bufferPosition: this.firstBlock.bufferPosition,
+          bufferByteOffset: this.firstBlock.bufferByteOffset + Tt * Uint32Array.BYTES_PER_ELEMENT
+        }
+      });
+      let o = t.allocUI32(s * 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 = s;
+    }
+  }
+  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 s = this.getFullDataBlock(r), o = r % this.maxChunkSize;
+    return s.set(t, e * o), r;
+  }
+  deleteIndex(t) {
+    this.recycleVector.push(t);
+  }
+  clear() {
+    this.firstBlock.data[D] = 0;
+  }
+  *[Symbol.iterator]() {
+    let t = [...this.recycleVector].reduce((s, o) => (s.push(...o), s), []), e = this.getFullDataBlock(0), r = 0;
+    for (let s = 0; s < Atomics.load(this.firstBlock.data, D); s++)
+      if (!t.includes(s)) {
+        let o = Math.floor(s / this.maxChunkSize);
+        o !== r && (e = this.getFullDataBlock(s), r = o), yield this.getDataBlock(e, s % 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 s = new h(this.memory, k(this.pointerVector.get(e))), o;
+    switch (this.type) {
+      case 1:
+        o = new Int32Array(s.data.buffer, s.bufferByteOffset, this.dataLength * this.maxChunkSize);
+        break;
+      case 0:
+        o = new Uint32Array(s.data.buffer, s.bufferByteOffset, this.dataLength * this.maxChunkSize);
+        break;
+      case 2:
+        o = new Float32Array(s.data.buffer, s.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, k(e)).free();
+    }
+    this.pointerVector.free(), this.firstBlock.free();
+  }
+  getSharedMemory() {
+    return {
+      firstBlock: this.firstBlock.getSharedMemory()
+    };
+  }
+}
+const Mt = new ArrayBuffer(4), Pt = new Uint32Array(Mt), R = new Uint16Array(Mt);
+function ue(i, t) {
+  return ie(Atomics.load(i, t));
+}
+function de(i, t, e, r) {
+  Atomics.store(i, t, se(e, r));
+}
+function ie(i) {
+  return Pt[0] = i, [R[0], R[1]];
+}
 function se(i, t) {
-  return Vt(Atomics.load(i, t));
+  return R[0] = i, R[1] = t, Pt[0];
+}
+const Nt = new ArrayBuffer(8), It = new BigUint64Array(Nt), B = new Uint16Array(Nt);
+function ye(i, t) {
+  return It[0] = Atomics.load(i, t), [B[0], B[1], B[2], B[3]];
+}
+function Be(i, t, e, r, s, o = 0) {
+  B[0] = e, B[1] = r, B[2] = s, B[3] = o, Atomics.store(i, t, It[0]);
 }
-function oe(i, t, e, r) {
-  Atomics.store(i, t, jt(e, r));
+const Ut = new ArrayBuffer(4), Ct = new Float32Array(Ut), Dt = new Int32Array(Ut);
+function Ft(i, t) {
+  return i instanceof Float32Array && (i = new Int32Array(i.buffer, i.byteOffset, i.length)), Q(Atomics.load(i, t));
 }
-function Vt(i) {
-  return wt[0] = i, [F[0], F[1]];
+function me(i, t, e) {
+  i instanceof Float32Array && (i = new Int32Array(i.buffer, i.byteOffset, i.length)), Atomics.store(i, t, $(e));
 }
-function jt(i, t) {
-  return F[0] = i, F[1] = t, wt[0];
+function Q(i) {
+  return Dt[0] = i, Ct[0];
 }
-const pt = new ArrayBuffer(8), Tt = new BigUint64Array(pt), y = new Uint16Array(pt);
-function ae(i, t) {
-  return Tt[0] = Atomics.load(i, t), [y[0], y[1], y[2], y[3]];
+function $(i) {
+  return Ct[0] = i, Dt[0];
 }
-function ne(i, t, e, r, s, o = 0) {
-  y[0] = e, y[1] = r, y[2] = s, y[3] = o, Atomics.store(i, t, Tt[0]);
+function be(i, t, e) {
+  return i instanceof Float32Array && (i = new Int32Array(i.buffer, i.byteOffset, i.length)), Q(Atomics.exchange(i, t, $(e)));
 }
-const _t = new ArrayBuffer(4), St = new Float32Array(_t), Lt = new Int32Array(_t);
-function fe(i, t) {
-  return Ot(Atomics.load(i, t));
+function xt(i, t, e, r) {
+  return i instanceof Float32Array && (i = new Int32Array(i.buffer, i.byteOffset, i.length)), Q(Atomics.compareExchange(i, t, $(e), $(r)));
 }
-function le(i, t, e) {
-  Atomics.store(i, t, Mt(e));
+function Ae(i, t, e, r) {
+  let s, o;
+  do
+    s = Atomics.load(i, t), o = Math.min(s + e, r);
+  while (Atomics.compareExchange(i, t, s, o) !== s);
 }
-function Ot(i) {
-  return Lt[0] = i, St[0];
+function ke(i, t, e, r) {
+  let s, o;
+  do
+    s = Atomics.load(i, t), o = Math.max(s - e, r);
+  while (Atomics.compareExchange(i, t, s, o) !== s);
 }
-function Mt(i) {
-  return St[0] = i, Lt[0];
+function ge(i, t, e, r) {
+  let s, o;
+  do
+    s = Ft(i, t), o = Math.min(s + e, r);
+  while (xt(i, t, s, o) !== s);
 }
-function he(i, t, e) {
-  return Ot(Atomics.exchange(i, t, Mt(e)));
+function Ee(i, t, e, r) {
+  let s, o;
+  do
+    s = Ft(i, t), o = Math.max(s - e, r);
+  while (xt(i, t, s, o) !== s);
 }
-const E = 0, v = 1, p = 2;
-function ce(i, t = 0) {
-  for (; Atomics.compareExchange(i, t, E, v) === p; )
-    Atomics.wait(i, t, p);
+const p = 0, J = 1, L = 2;
+function we(i, t = 0) {
+  for (; Atomics.compareExchange(i, t, p, J) === L; )
+    Atomics.wait(i, t, L);
   Atomics.add(i, t + 1, 1);
 }
-function ue(i, t = 0) {
-  let e = Atomics.compareExchange(i, t, E, p);
-  for (; e !== E; )
-    Atomics.wait(i, t, e), e = Atomics.compareExchange(i, t, E, p);
+function pe(i, t = 0) {
+  let e = Atomics.compareExchange(i, t, p, L);
+  for (; e !== p; )
+    Atomics.wait(i, t, e), e = Atomics.compareExchange(i, t, p, L);
 }
-function de(i, t = 0) {
-  Atomics.sub(i, t + 1, 1) - 1 <= 0 && (Atomics.compareExchange(i, t, v, E) !== v && console.warn("We are unlocking when it was not read locked!"), Atomics.notify(i, t));
+function Te(i, t = 0) {
+  Atomics.sub(i, t + 1, 1) - 1 <= 0 && (Atomics.compareExchange(i, t, J, p) !== J && console.warn("We are unlocking when it was not read locked!"), Atomics.notify(i, t));
 }
-function ye(i, t = 0) {
-  Atomics.compareExchange(i, t, p, E) !== p && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(i, t);
+function Le(i, t = 0) {
+  Atomics.compareExchange(i, t, L, p) !== L && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(i, t);
 }
-const me = 2;
+const Se = 2;
 export {
-  c as AllocatedMemory,
-  qt as BYTE_OFFSET_BIT_COUNT,
-  ie as CachedItemList,
-  V as MAX_BYTE_OFFSET_LENGTH,
-  j as MAX_POSITION_LENGTH,
-  K as MemoryBuffer,
-  ee as MemoryHeap,
-  Jt as POSITION_BIT_COUNT,
-  me as READ_WRITE_LOCK_ALLOCATE_COUNT,
-  te as SIMPLE_LOCK_ALLOCATE_COUNT,
+  h as AllocatedMemory,
+  oe as BYTE_OFFSET_BIT_COUNT,
+  ce as CachedItemList,
+  tt as MAX_BYTE_OFFSET_LENGTH,
+  et as MAX_POSITION_LENGTH,
+  X as MemoryBuffer,
+  le as MemoryHeap,
+  ae as POSITION_BIT_COUNT,
+  Se as READ_WRITE_LOCK_ALLOCATE_COUNT,
+  fe as SIMPLE_LOCK_ALLOCATE_COUNT,
   u as SharedList,
-  At as SharedMap,
-  re as SharedPointerList,
-  gt as SharedString,
-  kt as SharedVector,
-  jt as convert16To32,
-  Vt as convert32To16,
-  Mt as convertFloat32ToInt32,
-  Ot as convertInt32ToFloat32,
-  w as createPointer,
-  he as exchangeFloat32,
-  L as getPointer,
-  se as load16From32,
-  ae as load16From64,
-  fe as loadFloat32,
-  h as loadPointer,
-  S as loadRawPointer,
-  D as lock,
-  ce as readLock,
-  de as readUnlock,
-  Qt as replacePointer,
-  R as replaceRawPointer,
-  oe as store16In32,
-  ne as store16In64,
-  le as storeFloat32,
+  St as SharedMap,
+  he as SharedPointerList,
+  Ot as SharedPool,
+  _t as SharedString,
+  y as SharedVector,
+  ge as addAtomicFloat32,
+  Ae as addAtomicInt,
+  xt as compareExchangeFloat32,
+  se as convert16To32,
+  ie as convert32To16,
+  $ as convertFloat32ToInt32,
+  Q as convertInt32ToFloat32,
+  T as createPointer,
+  be as exchangeFloat32,
+  k as getPointer,
+  ue as load16From32,
+  ye as load16From64,
+  Ft as loadFloat32,
+  c as loadPointer,
+  O as loadRawPointer,
+  x as lock,
+  we as readLock,
+  Te as readUnlock,
+  ne as replacePointer,
+  Y as replaceRawPointer,
+  de as store16In32,
+  Be as store16In64,
+  me as storeFloat32,
   m as storePointer,
-  Z as storeRawPointer,
-  b as unlock,
-  ue as writeLock,
-  ye as writeUnlock
+  v as storeRawPointer,
+  Ee as subtractAtomicFloat,
+  ke as subtractAtomicInt,
+  A as unlock,
+  pe as writeLock,
+  Le as writeUnlock
 };
 //# sourceMappingURL=shared-memory-objects.js.map