@daneren2005/shared-memory-objects 0.0.18 → 0.0.20

package/dist/shared-memory-objects.js

@@ -1,30 +1,30 @@
 const he = 20, ce = 12, et = Math.pow(2, 20), rt = Math.pow(2, 12);
 function c(i, t = 0) {
-  return g(Atomics.load(i, t));
+  return B(Atomics.load(i, t));
 }
 function O(i, t = 0) {
   return Atomics.load(i, t);
 }
-function m(i, t = 0, e, r) {
-  Atomics.store(i, t, T(e, r));
+function k(i, t = 0, e, r) {
+  Atomics.store(i, t, L(e, r));
 }
-function v(i, t = 0, e) {
+function x(i, t = 0, e) {
   Atomics.store(i, t, e);
 }
 function ue(i, t, e, r, s, o) {
-  let n = T(s, o);
-  return Atomics.compareExchange(i, t, n, T(e, r)) === n;
+  let a = L(s, o);
+  return Atomics.compareExchange(i, t, a, L(e, r)) === a;
 }
-function H(i, t, e, r) {
+function V(i, t, e, r) {
   return Atomics.compareExchange(i, t, r, e) === r;
 }
-function g(i) {
+function B(i) {
   return {
     bufferPosition: i & 4095,
     bufferByteOffset: i >>> 12
   };
 }
-function T(i, t) {
+function L(i, t) {
   return i + (t << 12);
 }
 class h {
@@ -34,7 +34,7 @@ class h {
     return this.data.byteOffset;
   }
   get pointer() {
-    return T(this.bufferPosition, this.bufferByteOffset);
+    return L(this.bufferPosition, this.bufferByteOffset);
   }
   buffer;
   data;
@@ -60,15 +60,15 @@ class h {
     };
   }
 }
-const j = 0, D = 1;
-function x(i, t = 0) {
-  for (; Atomics.compareExchange(i, t, j, D) !== j; )
-    "WorkerGlobalScope" in self && Atomics.wait(i, t, D);
+const j = 0, F = 1;
+function z(i, t = 0) {
+  for (; Atomics.compareExchange(i, t, j, F) !== j; )
+    "WorkerGlobalScope" in self && Atomics.wait(i, t, F);
 }
-function A(i, t = 0) {
-  Atomics.compareExchange(i, t, D, j) !== D && console.warn("We are unlocking when it was not locked!"), Atomics.notify(i, t);
+function g(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 ye = 1, Vt = {
+const de = 1, Vt = {
   5120: "i8",
   5121: "u8",
   5122: "i16",
@@ -103,8 +103,8 @@ function jt(i, ...t) {
   const e = Zt[i];
   return new (e || Wt[vt(i)])(...t);
 }
-const it = 0, st = 1, ot = 2, nt = 3, at = 4, k = 5, ft = 6, V = 1, K = 2, lt = 32, G = 0, X = 1, y = 8;
-class Z {
+const it = 0, st = 1, ot = 2, at = 3, nt = 4, A = 5, lt = 6, K = 1, G = 2, ft = 32, X = 0, Z = 1, y = 8;
+class W {
   buf;
   start;
   u8;
@@ -112,7 +112,7 @@ class Z {
   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, lt / 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 ? I(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`);
@@ -159,48 +159,48 @@ class Z {
   malloc(t) {
     if (t <= 0)
       return 0;
-    x(this.lock);
-    const e = P(t + y, this.align), r = this.end;
-    let s = this.top, o = this._free, n = 0;
+    z(this.lock);
+    const e = I(t + y, this.align), r = this.end;
+    let s = this.top, o = this._free, a = 0;
     for (; o; ) {
-      const f = this.blockSize(o), a = o + f >= s;
-      if (a || f >= e) {
-        let l = this.mallocTop(
+      const l = this.blockSize(o), n = o + l >= s;
+      if (n || l >= e) {
+        let f = this.mallocTop(
           o,
-          n,
-          f,
+          a,
+          l,
           e,
-          a
+          n
         );
-        return A(this.lock), l;
+        return g(this.lock), f;
       }
-      n = o, o = this.blockNext(o);
+      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 A(this.lock), f;
+      let l = _(o);
+      return g(this.lock), l;
     }
-    return A(this.lock), 0;
+    return g(this.lock), 0;
   }
   mallocTop(t, e, r, s, o) {
     if (o && t + s > 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, s);
     else if (this.doSplit) {
-      const n = r - s;
-      n >= this.minSplit && this.splitBlock(t, s, n);
+      const a = r - s;
+      a >= this.minSplit && this.splitBlock(t, s, a);
     }
     return _(t);
   }
   realloc(t, e) {
     if (e <= 0)
       return 0;
-    const r = I(t);
-    let s = 0, o = this._used, n = 0;
+    const r = C(t);
+    let s = 0, o = this._used, a = 0;
     for (; o; ) {
       if (o === r) {
-        [s, n] = this.reallocBlock(o, e);
+        [s, a] = this.reallocBlock(o, e);
         break;
       }
       o = this.blockNext(o);
@@ -208,19 +208,19 @@ class Z {
     return s && s !== r && this.u8.copyWithin(
       _(s),
       _(r),
-      n
+      a
     ), _(s);
   }
   reallocBlock(t, e) {
-    const r = this.blockSize(t), s = t + r, o = s >= this.top, n = P(e + y, this.align);
-    if (n <= r) {
+    const r = this.blockSize(t), s = t + r, o = s >= this.top, a = I(e + y, this.align);
+    if (a <= r) {
       if (this.doSplit) {
-        const f = r - n;
-        f >= this.minSplit ? this.splitBlock(t, n, f) : o && (this.top = t + n);
-      } else o && (this.top = t + n);
+        const l = r - a;
+        l >= this.minSplit ? this.splitBlock(t, a, l) : o && (this.top = t + a);
+      } else o && (this.top = t + a);
       return [t, s];
     }
-    return o && t + n < this.end ? (this.top = t + this.setBlockSize(t, n), [t, s]) : (this.free(t), [I(this.malloc(e)), s]);
+    return o && t + a < this.end ? (this.top = t + this.setBlockSize(t, a), [t, s]) : (this.free(t), [C(this.malloc(e)), s]);
   }
   reallocArray(t, e) {
     if (t.buffer !== this.buf)
@@ -239,7 +239,7 @@ class Z {
       e = t.byteOffset;
     } else
       e = t;
-    e = I(e);
+    e = C(e);
     let r = this._used;
     for (; r; ) {
       if (r === e)
@@ -260,14 +260,14 @@ class Z {
       e = t.byteOffset;
     } else
       e = t;
-    x(this.lock), e = I(e);
+    z(this.lock), e = C(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(), A(this.lock), !0;
+        return s ? this.unlinkBlock(s, r) : this._used = this.blockNext(r), this.insert(r), this.doCompact && this.compact(), g(this.lock), !0;
       s = r, r = this.blockNext(r);
     }
-    return A(this.lock), !1;
+    return g(this.lock), !1;
   }
   freeAll() {
     this._free = 0, this._used = 0, this.top = this.initialTop();
@@ -276,16 +276,16 @@ class Z {
     return delete this.u8, delete this.u32, delete this.state, delete this.buf, !0;
   }
   get align() {
-    return this.state[at];
+    return this.state[nt];
   }
   set align(t) {
-    this.state[at] = t;
+    this.state[nt] = t;
   }
   get end() {
-    return this.state[nt];
+    return this.state[at];
   }
   set end(t) {
-    this.state[nt] = t;
+    this.state[at] = t;
   }
   get top() {
     return Atomics.load(this.state, ot);
@@ -306,27 +306,27 @@ class Z {
     Atomics.store(this.state, st, t);
   }
   get doCompact() {
-    return !!(this.state[k] & V);
+    return !!(this.state[A] & K);
   }
   set doCompact(t) {
-    t ? this.state[k] |= 1 << V - 1 : this.state[k] &= ~V;
+    t ? this.state[A] |= 1 << K - 1 : this.state[A] &= ~K;
   }
   get doSplit() {
-    return !!(this.state[k] & K);
+    return !!(this.state[A] & G);
   }
   set doSplit(t) {
-    t ? this.state[k] |= 1 << K - 1 : this.state[k] &= ~K;
+    t ? this.state[A] |= 1 << G - 1 : this.state[A] &= ~G;
   }
   get minSplit() {
-    return this.state[ft];
+    return this.state[lt];
   }
   set minSplit(t) {
     if (t <= y)
       throw new Error(`illegal min split threshold: ${t}, require at least ${y + 1}`);
-    this.state[ft] = t;
+    this.state[lt] = t;
   }
   blockSize(t) {
-    return Atomics.load(this.u32, (t >> 2) + G);
+    return Atomics.load(this.u32, (t >> 2) + X);
   }
   /**
    * Sets & returns given block size.
@@ -335,10 +335,10 @@ class Z {
    * @param size -
    */
   setBlockSize(t, e) {
-    return Atomics.store(this.u32, (t >> 2) + G, e), e;
+    return Atomics.store(this.u32, (t >> 2) + X, e), e;
   }
   blockNext(t) {
-    return Atomics.load(this.u32, (t >> 2) + X);
+    return Atomics.load(this.u32, (t >> 2) + Z);
   }
   /**
    * Sets block next pointer to `next`. Use zero to indicate list end.
@@ -346,7 +346,7 @@ class Z {
    * @param block -
    */
   setBlockNext(t, e) {
-    Atomics.store(this.u32, (t >> 2) + X, e);
+    Atomics.store(this.u32, (t >> 2) + Z, e);
   }
   /**
    * Initializes block header with given `size` and `next` pointer. Returns `block`.
@@ -357,7 +357,7 @@ class Z {
    */
   initBlock(t, e, r) {
     const s = t >>> 2;
-    return Atomics.store(this.u32, s + G, e), Atomics.store(this.u32, s + X, r), t;
+    return Atomics.store(this.u32, s + X, e), Atomics.store(this.u32, s + Z, r), t;
   }
   unlinkBlock(t, e) {
     this.setBlockNext(t, this.blockNext(e));
@@ -372,7 +372,7 @@ class Z {
     ), this.doCompact && this.compact();
   }
   initialTop(t = this.align) {
-    return P(this.start + lt + y, t) - y;
+    return I(this.start + ft + y, t) - y;
   }
   /**
    * Traverses free list and attempts to recursively merge blocks
@@ -385,15 +385,15 @@ class Z {
       for (s = t, r = this.blockNext(t); r && s + this.blockSize(s) === r; )
         s = r, r = this.blockNext(r);
       if (s !== t) {
-        const n = s - t + this.blockSize(s);
-        this.setBlockSize(t, n);
-        const f = this.blockNext(s);
-        let a = this.blockNext(t);
-        for (; a && a !== f; ) {
-          const l = this.blockNext(a);
-          this.setBlockNext(a, 0), a = l;
+        const a = s - t + this.blockSize(s);
+        this.setBlockSize(t, a);
+        const l = this.blockNext(s);
+        let n = this.blockNext(t);
+        for (; n && n !== l; ) {
+          const f = this.blockNext(n);
+          this.setBlockNext(n, 0), n = f;
         }
-        this.setBlockNext(t, f), o = !0;
+        this.setBlockNext(t, l), 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);
     }
@@ -411,7 +411,7 @@ class Z {
     r ? this.setBlockNext(r, t) : this._free = t, this.setBlockNext(t, e);
   }
 }
-const _ = (i) => i > 0 ? i + y : 0, I = (i) => i > 0 ? i - y : 0, P = (i, t) => (t--, i + t & ~t), qt = {
+const _ = (i) => i > 0 ? i + y : 0, C = (i) => i > 0 ? i - y : 0, I = (i, t) => (t--, i + t & ~t), qt = {
   u8: 1,
   u8c: 1,
   i8: 1,
@@ -503,29 +503,29 @@ function oe(i, t) {
   };
   const e = t.bits ? t.binary ? ee : te : t.binary ? Qt : Jt, r = t.space ? t.nonBreakingSpace ? " " : " " : "", s = typeof i == "number" ? i === 0 : i === 0n;
   if (t.signed && s) {
-    const l = ` 0${r}${e[0]}`;
-    return ct(l, t.fixedWidth);
+    const f = ` 0${r}${e[0]}`;
+    return ct(f, t.fixedWidth);
   }
-  const o = i < 0, n = o ? "-" : t.signed ? "+" : "";
+  const o = i < 0, a = o ? "-" : t.signed ? "+" : "";
   o && (i = -i);
-  const f = se(t);
-  let a;
+  const l = se(t);
+  let n;
   if (i < 1) {
-    const l = ht(i, t.locale, f);
-    a = n + l + r + e[0];
+    const f = ht(i, t.locale, l);
+    n = a + f + r + e[0];
   } else {
-    const l = Math.min(Math.floor(t.binary ? re(i) / Math.log(1024) : _t(i) / 3), e.length - 1);
-    if (i = ie(i, (t.binary ? 1024 : 1e3) ** l), !f) {
+    const f = Math.min(Math.floor(t.binary ? re(i) / Math.log(1024) : _t(i) / 3), e.length - 1);
+    if (i = ie(i, (t.binary ? 1024 : 1e3) ** f), !l) {
       const M = Math.max(3, Math.floor(i).toString().length);
       i = i.toPrecision(M);
     }
-    const S = ht(Number(i), t.locale, f), Y = e[l];
-    a = n + S + r + Y;
+    const T = ht(Number(i), t.locale, l), H = e[f];
+    n = a + T + r + H;
   }
-  return ct(a, t.fixedWidth);
+  return ct(n, t.fixedWidth);
 }
-const ne = 8192, ut = 0, W = 1, N = 2;
-class de {
+const ae = 8192, ut = 0, v = 1, N = 2;
+class ye {
   buffers;
   onGrowBufferHandlers = [];
   isClone;
@@ -535,7 +535,7 @@ class de {
   }
   constructor(t) {
     if (t && "buffers" in t)
-      this.buffers = t.buffers.map((e) => new Z({
+      this.buffers = t.buffers.map((e) => new W({
         buf: e,
         skipInitialization: !0
       })), this.memory = new h(this, {
@@ -544,7 +544,7 @@ class de {
       }), this.isClone = !0;
     else {
       "SharedArrayBuffer" in globalThis || console.warn("SharedArrayBuffer is not working: falling back to ArrayBuffer");
-      const e = t?.bufferSize ?? ne;
+      const e = t?.bufferSize ?? ae;
       if (e > et)
         throw new Error(`Buffer size ${e} is greater than max ${et} that we can reference with pointers`);
       let r = this.createBuffer(e);
@@ -559,20 +559,20 @@ class de {
         });
       else
         throw new Error("Failed to initialize first byte from buffer");
-      this.memory.data[ut] = e, this.memory.data[W] = 1, this.memory.data[N] = t?.autoGrowSize ?? 100, this.isClone = !1;
+      this.memory.data[ut] = e, this.memory.data[v] = 1, this.memory.data[N] = 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 Z({
+    this.buffers[t.bufferPosition] = new W({
       buf: t.buffer,
       skipInitialization: !0
     });
   }
   growBuffer() {
     const t = this.createBuffer();
-    let e = Atomics.add(this.memory.data, W, 1);
+    let e = Atomics.add(this.memory.data, v, 1);
     return this.buffers[e] = t, this.onGrowBufferHandlers.forEach((r) => r({
       bufferPosition: e,
       buffer: t.buf
@@ -581,7 +581,7 @@ class de {
   createBuffer(t) {
     const e = t ?? this.bufferSize;
     let r;
-    return "SharedArrayBuffer" in globalThis ? r = new SharedArrayBuffer(e) : r = new ArrayBuffer(e), new Z({
+    return "SharedArrayBuffer" in globalThis ? r = new SharedArrayBuffer(e) : r = new ArrayBuffer(e), new W({
       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
@@ -599,10 +599,10 @@ class de {
       const o = this.buffers[s];
       if (!o)
         continue;
-      const n = o.callocAs("u32", t);
-      if (n)
-        return s === this.buffers.length - 1 && Atomics.load(this.memory.data, W) === 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 h(this, {
-          data: n,
+      const a = o.callocAs("u32", t);
+      if (a)
+        return s === this.buffers.length - 1 && Atomics.load(this.memory.data, v) === 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 h(this, {
+          data: a,
           buffer: o
         });
     }
@@ -628,7 +628,7 @@ class de {
     return this.buffers[0].buf.byteLength * this.buffers.length;
   }
   prettyMemory() {
-    return `${yt(this.currentUsed)} / ${yt(this.totalAllocated)}`;
+    return `${dt(this.currentUsed)} / ${dt(this.totalAllocated)}`;
   }
   getSharedMemory() {
     return {
@@ -636,16 +636,16 @@ class de {
     };
   }
 }
-function yt(i) {
+function dt(i) {
   return oe(i, {
     binary: !0,
     minimumFractionDigits: 1,
     maximumFractionDigits: 1
   });
 }
-const dt = 4, Bt = 1, E = 2;
+const yt = 4, Bt = 1, p = 2;
 class u {
-  static ALLOCATE_COUNT = dt;
+  static ALLOCATE_COUNT = yt;
   memory;
   /* First block
   	32 index 0
@@ -670,7 +670,7 @@ class u {
   uint16Array;
   onDelete;
   get length() {
-    return Atomics.load(this.firstBlock.data, E);
+    return Atomics.load(this.firstBlock.data, p);
   }
   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 h(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (E + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
+      this.firstBlock = new h(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (p + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
     else {
-      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);
+      e && e.initWithBlock ? this.firstBlock = new h(t, e.initWithBlock) : this.firstBlock = t.allocUI32(yt), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (p + 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;
     }
@@ -699,17 +699,17 @@ class u {
     if (t.length > e)
       throw new Error(`Can't insert ${t.length} array into shared list of ${e} dataLength`);
     let r = this.memory.allocUI32(Bt + e), s = this.getDataBlock(r.data), o = r.pointer;
-    for (let a = 0; a < t.length; a++)
-      s instanceof Int32Array || s instanceof Uint32Array ? Atomics.store(s, a, t[a]) : s[a] = t[a];
-    let n, f = !1;
-    for (; !f; )
-      n = O(this.firstBlock.data, 1), f = H(this.firstBlock.data, 1, o, n);
-    if (n) {
-      let { bufferPosition: a, bufferByteOffset: l } = g(n), S = new Uint32Array(this.memory.buffers[a].buf, l, 1);
-      v(S, 0, o);
+    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, l = !1;
+    for (; !l; )
+      a = O(this.firstBlock.data, 1), l = V(this.firstBlock.data, 1, o, a);
+    if (a) {
+      let { bufferPosition: n, bufferByteOffset: f } = B(a), T = new Uint32Array(this.memory.buffers[n].buf, f, 1);
+      x(T, 0, o);
     } else
-      v(this.firstBlock.data, 0, o);
-    Atomics.add(this.firstBlock.data, E, 1);
+      x(this.firstBlock.data, 0, o);
+    Atomics.add(this.firstBlock.data, p, 1);
   }
   deleteMatch(t) {
     for (let { data: e, index: r, deleteCurrent: s } of this)
@@ -735,37 +735,37 @@ class u {
     for (; !r; ) {
       if (t = O(this.firstBlock.data, 0), e = O(this.firstBlock.data, 1), !e)
         return;
-      r = H(this.firstBlock.data, 1, 0, e);
+      r = V(this.firstBlock.data, 1, 0, e);
     }
     if (!t)
       return;
-    H(this.firstBlock.data, 0, 0, t);
+    V(this.firstBlock.data, 0, 0, t);
     let s = 0, o = t;
     for (; o; ) {
-      let { bufferPosition: n, bufferByteOffset: f } = g(o), a = this.memory.buffers[n];
-      if (!a)
+      let { bufferPosition: a, bufferByteOffset: l } = B(o), n = this.memory.buffers[a];
+      if (!n)
         break;
-      let l = new Uint32Array(a.buf, f, 2);
-      o = O(l, 0), s++, this.onDelete && this.onDelete(this.getDataBlock(l)), a.free(l.byteOffset);
+      let f = new Uint32Array(n.buf, l, 2);
+      o = O(f, 0), s++, this.onDelete && this.onDelete(this.getDataBlock(f)), n.free(f.byteOffset);
     }
-    Atomics.sub(this.firstBlock.data, E, s);
+    Atomics.sub(this.firstBlock.data, p, s);
   }
   *[Symbol.iterator]() {
-    let t = 0, { bufferPosition: e, bufferByteOffset: r } = c(this.firstBlock.data, 0), s = this.firstBlock.data, o = 0, n = 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)
+      let l = this.memory.buffers[e];
+      if (!l)
         return;
-      let a = new Uint32Array(f.buf, r, 2), l = this.getDataBlock(a), S = e, Y = r;
-      ({ bufferPosition: e, bufferByteOffset: r } = c(a, 0));
+      let n = new Uint32Array(l.buf, r, 2), f = this.getDataBlock(n), T = e, H = r;
+      ({ bufferPosition: e, bufferByteOffset: r } = c(n, 0));
       let M = !0;
       yield {
-        data: l,
+        data: f,
         index: t,
         deleteCurrent: () => {
-          m(s, 0, e, r), r || m(this.firstBlock.data, 1, o, n), this.onDelete && this.onDelete(this.getDataBlock(a)), f.free(a.byteOffset), Atomics.sub(this.firstBlock.data, E, 1), M = !1;
+          k(s, 0, e, r), r || k(this.firstBlock.data, 1, o, a), this.onDelete && this.onDelete(this.getDataBlock(n)), l.free(n.byteOffset), Atomics.sub(this.firstBlock.data, p, 1), M = !1;
         }
-      }, M && (s = a, o = S, n = Y, t++);
+      }, M && (s = n, o = T, a = H, t++);
     }
   }
   forEach(t) {
@@ -824,78 +824,78 @@ class Ot {
     else {
       this.pointerMemory = t.allocUI32(Ot.ALLOCATE_COUNT);
       let r = t.allocUI32(mt);
-      m(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, mt);
+      k(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, mt);
     }
     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 = C(t);
+    let r = P(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), n, f = c(t.data, o);
-    if (f.bufferByteOffset === 0) {
-      n = new u(this.memory, {
+    let o = this.hash(r, e), a, l = c(t.data, o);
+    if (l.bufferByteOffset === 0) {
+      a = new u(this.memory, {
         dataLength: 2
       });
-      let l = n.getSharedMemory();
-      m(t.data, o, l.firstBlock.bufferPosition, l.firstBlock.bufferByteOffset);
+      let f = a.getSharedMemory();
+      k(t.data, o, f.firstBlock.bufferPosition, f.firstBlock.bufferByteOffset);
     } else
-      n = new u(this.memory, {
-        firstBlock: f
+      a = new u(this.memory, {
+        firstBlock: l
       });
-    let a = !0;
-    return n.deleteValue(r) && (a = !1), n.insert([r, s]), a;
+    let n = !0;
+    return a.deleteValue(r) && (n = !1), a.insert([r, s]), n;
   }
   get(t) {
-    let e = C(t), r = this.hash(e, this.maxHash), s = c(this.hashMemory.data, r);
+    let e = P(t), r = this.hash(e, this.maxHash), s = c(this.hashMemory.data, r);
     if (s.bufferByteOffset === 0)
       return;
     let o = new u(this.memory, {
       firstBlock: s
     });
-    for (let { data: n } of o)
-      if (n[0] === e)
-        return n[1];
+    for (let { data: a } of o)
+      if (a[0] === e)
+        return a[1];
   }
   has(t) {
-    let e = C(t), r = this.hash(e, this.maxHash), s = c(this.hashMemory.data, r);
+    let e = P(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, {
       firstBlock: s
     });
-    for (let { data: n } of o)
-      if (n[0] === e)
+    for (let { data: a } of o)
+      if (a[0] === e)
         return !0;
     return !1;
   }
   delete(t) {
-    let e = C(t), r = this.hash(e, this.maxHash), s = c(this.hashMemory.data, r);
+    let e = P(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, {
       firstBlock: s
     });
-    for (let { data: n, deleteCurrent: f } of o)
-      if (n[0] === e)
-        return f(), Atomics.sub(this.pointerMemory.data, 2, 1), !0;
+    for (let { data: a, deleteCurrent: l } of o)
+      if (a[0] === e)
+        return l(), Atomics.sub(this.pointerMemory.data, 2, 1), !0;
     return !1;
   }
   growHashTable() {
     let t = this.maxHash, e = t * 2, r = this.memory.allocUI32(e), s = this.hashMemory;
     for (let o = 0; o < t; o++) {
-      let n = c(s.data, o);
-      if (n.bufferByteOffset === 0)
+      let a = c(s.data, o);
+      if (a.bufferByteOffset === 0)
         continue;
-      let f = new u(this.memory, {
-        firstBlock: n
+      let l = new u(this.memory, {
+        firstBlock: a
       });
-      for (let { data: a } of f)
-        this.setHashKey(r, e, a[0], a[1]);
+      for (let { data: n } of l)
+        this.setHashKey(r, e, n[0], n[1]);
     }
-    m(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, e);
+    k(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, e);
   }
   hash(t, e) {
     return t % e;
@@ -917,10 +917,10 @@ class Ot {
     };
   }
 }
-function C(i) {
-  return typeof i == "number" ? i : typeof i == "string" ? ae(i) : i;
+function P(i) {
+  return typeof i == "number" ? i : typeof i == "string" ? ne(i) : i;
 }
-function ae(i) {
+function ne(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;
@@ -944,10 +944,10 @@ class Be {
     return this.list.length;
   }
   insert(t) {
-    this.list.insert(T(t.memory.bufferPosition, t.memory.bufferByteOffset));
+    this.list.insert(L(t.memory.bufferPosition, t.memory.bufferByteOffset));
   }
   delete(t) {
-    return this.list.deleteValue(T(t.memory.bufferPosition, t.memory.bufferByteOffset));
+    return this.list.deleteValue(L(t.memory.bufferPosition, t.memory.bufferByteOffset));
   }
   *[Symbol.iterator]() {
     let t = this.list[Symbol.iterator]();
@@ -980,7 +980,7 @@ class Be {
 const bt = {
   1: Uint8Array,
   2: Uint16Array
-}, U = 0, At = 1, gt = 2, kt = 3;
+}, U = 0, gt = 1, kt = 2, At = 3;
 class Mt {
   static ALLOCATE_COUNT = 4;
   memory;
@@ -989,11 +989,11 @@ class Mt {
   cachedPointer;
   cachedString;
   constructor(t, e) {
-    this.memory = t, typeof e == "string" ? (this.allocatedMemory = this.memory.allocUI32(Mt.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));
+    this.memory = t, typeof e == "string" ? (this.allocatedMemory = this.memory.allocUI32(Mt.ALLOCATE_COUNT), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + At * 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 + At * this.allocatedMemory.data.BYTES_PER_ELEMENT), "value" in e && this.updateString(e.value));
   }
   updateString(t) {
     let e = this.createString(t);
-    x(this.lock), v(this.allocatedMemory.data, U, e.pointer), Atomics.store(this.allocatedMemory.data, At, t.length), Atomics.store(this.allocatedMemory.data, gt, e.charType), A(this.lock), this.cachedPointer = e.pointer, this.cachedString = t;
+    z(this.lock), x(this.allocatedMemory.data, U, e.pointer), Atomics.store(this.allocatedMemory.data, gt, t.length), Atomics.store(this.allocatedMemory.data, kt, e.charType), g(this.lock), this.cachedPointer = e.pointer, this.cachedString = t;
   }
   createString(t) {
     if (t === "")
@@ -1003,13 +1003,13 @@ class Mt {
         /* ASCII */
       };
     let e = [];
-    for (let a = 0; a < t.length; a++)
-      e.push(t.charCodeAt(a));
-    let s = Math.max(...e) > 255 ? 2 : 1, o = bt[s], n = this.memory.allocUI32(Math.ceil(t.length / (4 / o.BYTES_PER_ELEMENT))), f = new o(n.data.buffer, n.data.byteOffset, t.length);
-    for (let a = 0; a < t.length; a++)
-      f[a] = t.charCodeAt(a);
+    for (let n = 0; n < t.length; n++)
+      e.push(t.charCodeAt(n));
+    let s = Math.max(...e) > 255 ? 2 : 1, o = bt[s], a = this.memory.allocUI32(Math.ceil(t.length / (4 / o.BYTES_PER_ELEMENT))), l = new o(a.data.buffer, a.data.byteOffset, t.length);
+    for (let n = 0; n < t.length; n++)
+      l[n] = t.charCodeAt(n);
     return {
-      pointer: n.pointer,
+      pointer: a.pointer,
       charType: s
     };
   }
@@ -1019,10 +1019,10 @@ class Mt {
       return this.cachedString;
     if (t === 0)
       return "";
-    let { bufferPosition: e, bufferByteOffset: r } = g(t);
-    x(this.lock);
-    let s = Atomics.load(this.allocatedMemory.data, gt), o = bt[s], n = Atomics.load(this.allocatedMemory.data, At), f = new o(this.memory.buffers[e].buf, r, n), a = String.fromCharCode.apply(null, f);
-    return A(this.lock), this.cachedPointer = t, this.cachedString = a, a;
+    let { bufferPosition: e, bufferByteOffset: r } = B(t);
+    z(this.lock);
+    let s = Atomics.load(this.allocatedMemory.data, kt), o = bt[s], a = Atomics.load(this.allocatedMemory.data, gt), l = new o(this.memory.buffers[e].buf, r, a), n = String.fromCharCode.apply(null, l);
+    return g(this.lock), this.cachedPointer = t, this.cachedString = n, n;
   }
   set value(t) {
     let { bufferPosition: e, bufferByteOffset: r } = c(this.allocatedMemory.data, U);
@@ -1039,15 +1039,15 @@ class Mt {
     e && this.memory.buffers[t].free(e), this.allocatedMemory.free();
   }
 }
-const w = 0, b = 1, Et = 2, wt = 3, pt = 4;
-class d {
+const E = 0, d = 1, pt = 2, Et = 3, wt = 4;
+class m {
   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, d);
   }
   get type() {
     return this.uint16Array[0];
@@ -1056,16 +1056,16 @@ class d {
     Atomics.store(this.uint16Array, 0, t);
   }
   get dataLength() {
-    return Math.max(1, this.uint16Array[1]);
+    return this.uint16Array[1] || 1;
   }
   set dataLength(t) {
     Atomics.store(this.uint16Array, 1, t);
   }
   get bufferLength() {
-    return Atomics.load(this.firstBlock.data, Et);
+    return Atomics.load(this.firstBlock.data, pt);
   }
   set bufferLength(t) {
-    Atomics.store(this.firstBlock.data, Et, t);
+    Atomics.store(this.firstBlock.data, pt, t);
   }
   get pointer() {
     return this.firstBlock.pointer;
@@ -1074,21 +1074,21 @@ class d {
   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 + wt * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in e || "dataLength" in e) {
-        const r = e.bufferLength ?? pt;
+      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) {
+        const r = e.bufferLength ?? wt;
         let s = t.allocUI32(r * (e.dataLength ?? 1));
-        m(this.firstBlock.data, w, s.bufferPosition, s.bufferByteOffset), this.bufferLength = r, this.dataLength = e.dataLength ?? 1;
+        k(this.firstBlock.data, E, s.bufferPosition, s.bufferByteOffset), this.bufferLength = r, 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(d.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?.bufferLength ?? pt, o = t.allocUI32(s * r);
-      m(this.firstBlock.data, w, o.bufferPosition, o.bufferByteOffset), this.bufferLength = s;
-      const n = e?.type ?? Uint32Array;
-      n === Uint32Array ? this.type = 0 : n === Int32Array ? this.type = 1 : n === Float32Array && (this.type = 2), this.dataLength = r;
+      this.firstBlock = t.allocUI32(m.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 ?? wt, o = t.allocUI32(s * r);
+      k(this.firstBlock.data, E, 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;
     }
     this.cachedPointer = this.firstBlock.data[0], this.cachedFullDataBlock = this.getFullDataBlock();
   }
@@ -1107,40 +1107,49 @@ class d {
     return this.getFullDataBlock()[t * this.dataLength + e];
   }
   push(t) {
-    typeof t == "number" && (t = [t]);
     let e = this.dataLength;
-    if (t.length > e)
+    const r = typeof t == "number";
+    if (!r && 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;
+    let s = this.getFullDataBlock(), o = this.length, a = e * o;
+    return r ? s[a] = t : s.set(t, a), Atomics.add(this.firstBlock.data, d, 1) + 1 >= this.bufferLength && this.growBuffer(), o;
   }
   pop() {
-    let t = Atomics.sub(this.firstBlock.data, b, b), e = this.getFullDataBlock();
+    let t = Atomics.sub(this.firstBlock.data, d, d), e = this.getFullDataBlock();
     return this.getDataBlock(e, t - 1);
   }
+  // Returns the first number irregardless of dataLength - faster way to pop if you don't care about the rest of the data block
+  popNumber() {
+    const t = Atomics.sub(this.firstBlock.data, d, d);
+    return this.getFullDataBlock()[(t - 1) * this.dataLength];
+  }
   deleteIndex(t) {
     let e = this.length;
     if (t >= e || t < 0)
       throw new Error(`${t} is out of bounds ${e}`);
     let r = this.dataLength, s = this.getFullDataBlock();
     for (let o = t; o < e; o++)
-      for (let n = 0; n < r; n++)
-        s[o * r + n] = s[(o + 1) * r + n];
-    Atomics.sub(this.firstBlock.data, b, b);
+      for (let a = 0; a < r; a++)
+        s[o * r + a] = s[(o + 1) * r + a];
+    Atomics.sub(this.firstBlock.data, d, d);
   }
   clear() {
-    this.firstBlock.data[b] = 0;
+    this.firstBlock.data[d] = 0;
   }
   *[Symbol.iterator]() {
-    let t = this.getFullDataBlock();
-    for (let e = 0; e < this.length; e++)
-      yield this.getDataBlock(t, e);
+    let t = this.getFullDataBlock(), e = this.dataLength;
+    for (let r = 0; r < this.length; r += e)
+      yield t.subarray(r, r + e);
+  }
+  // Significantly faster but won't be thread safe if anything is removing/adding to it during iteration
+  getCurrentArray() {
+    return this.getFullDataBlock().subarray(0, this.length * this.dataLength);
   }
   getFullDataBlock() {
-    let t = Atomics.load(this.firstBlock.data, w);
+    let t = Atomics.load(this.firstBlock.data, E);
     if (this.cachedPointer === t && this.cachedFullDataBlock)
       return this.cachedFullDataBlock;
-    let e = g(t), r = new h(this.memory, e), s;
+    let e = B(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);
@@ -1161,24 +1170,26 @@ class d {
     return t.subarray(r, r + this.dataLength);
   }
   growBuffer() {
-    let e = this.bufferLength * 2, r = this.dataLength, s = c(this.firstBlock.data, w), o = new h(this.memory, s), n = this.getFullDataBlock(), f = this.memory.allocUI32(e * r), a;
+    let e = this.bufferLength * 2, r = this.dataLength, s = c(this.firstBlock.data, E), o = new h(this.memory, s), a = this.getFullDataBlock(), l = this.memory.allocUI32(e * r), n;
     switch (this.type) {
       case 1:
-        a = new Int32Array(f.data.buffer, f.bufferByteOffset, r * this.bufferLength);
+        n = new Int32Array(l.data.buffer, l.bufferByteOffset, r * e);
         break;
       case 0:
-        a = new Uint32Array(f.data.buffer, f.bufferByteOffset, r * this.bufferLength);
+        n = new Uint32Array(l.data.buffer, l.bufferByteOffset, r * e);
         break;
       case 2:
-        a = new Float32Array(f.data.buffer, f.bufferByteOffset, r * this.bufferLength);
+        n = new Float32Array(l.data.buffer, l.bufferByteOffset, r * e);
         break;
       default:
         throw new Error(`Unknown data block type ${this.type}`);
     }
-    a.set(n), m(this.firstBlock.data, w, f.bufferPosition, f.bufferByteOffset), this.bufferLength = e, o.free();
+    n.set(a);
+    const f = l.pointer;
+    x(this.firstBlock.data, E, f), this.bufferLength = e, o.free(), this.cachedPointer = f, this.cachedFullDataBlock = n;
   }
   free() {
-    let t = c(this.firstBlock.data, w);
+    let t = c(this.firstBlock.data, E);
     new h(this.memory, t).free(), this.firstBlock.free();
   }
   getSharedMemory() {
@@ -1258,9 +1269,9 @@ class me {
     this.list.free(), this.cache.clear();
   }
 }
-const F = 0, Tt = 1, Lt = 2, q = 3, St = q + d.ALLOCATE_COUNT;
-class It {
-  static ALLOCATE_COUNT = 3 + d.ALLOCATE_COUNT * 2;
+const D = 0, Lt = 1, St = 2, q = 3, Tt = q + m.ALLOCATE_COUNT;
+class Ct {
+  static ALLOCATE_COUNT = 3 + m.ALLOCATE_COUNT * 2;
   memory;
   // Current Length, Type/DataLength, MaxChunkLength, Pointer vector, Recycle vector
   firstBlock;
@@ -1269,13 +1280,13 @@ class It {
   recycleVector;
   cachedFullDataBlock = {};
   get length() {
-    return Atomics.load(this.firstBlock.data, F) - this.recycleVector.length;
+    return Atomics.load(this.firstBlock.data, D) - this.recycleVector.length;
   }
   get maxChunkSize() {
-    return this.firstBlock.data[Lt];
+    return this.firstBlock.data[St];
   }
   set maxChunkSize(t) {
-    Atomics.store(this.firstBlock.data, Lt, t);
+    Atomics.store(this.firstBlock.data, St, t);
   }
   get type() {
     return this.uint16Array[0];
@@ -1300,38 +1311,38 @@ class It {
   }
   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 + Tt * Uint32Array.BYTES_PER_ELEMENT, 2), this.pointerVector = new d(t, {
+      this.firstBlock = new h(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + Lt * Uint32Array.BYTES_PER_ELEMENT, 2), this.pointerVector = new m(t, {
         firstBlock: {
           bufferPosition: this.firstBlock.bufferPosition,
           bufferByteOffset: this.firstBlock.bufferByteOffset + q * Uint32Array.BYTES_PER_ELEMENT
         }
-      }), this.recycleVector = new d(t, {
+      }), this.recycleVector = new m(t, {
         firstBlock: {
           bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + St * Uint32Array.BYTES_PER_ELEMENT
+          bufferByteOffset: this.firstBlock.bufferByteOffset + Tt * Uint32Array.BYTES_PER_ELEMENT
         }
       });
     else {
-      this.firstBlock = t.allocUI32(It.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + Tt * Uint32Array.BYTES_PER_ELEMENT, 2);
+      this.firstBlock = t.allocUI32(Ct.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + Lt * Uint32Array.BYTES_PER_ELEMENT, 2);
       let r = e?.dataLength ?? 1, s = e?.maxChunkSize ?? 100;
-      this.pointerVector = new d(t, {
+      this.pointerVector = new m(t, {
         type: Uint32Array,
         firstBlock: {
           bufferPosition: this.firstBlock.bufferPosition,
           bufferByteOffset: this.firstBlock.bufferByteOffset + q * Uint32Array.BYTES_PER_ELEMENT
         }
-      }), this.recycleVector = new d(t, {
+      }), this.recycleVector = new m(t, {
         type: Uint32Array,
         firstBlock: {
           bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + St * Uint32Array.BYTES_PER_ELEMENT
+          bufferByteOffset: this.firstBlock.bufferByteOffset + Tt * Uint32Array.BYTES_PER_ELEMENT
         },
         bufferLength: e?.recycleBufferLength
       });
       const o = e?.type ?? Uint32Array;
       o === Uint32Array ? this.type = 0 : o === Int32Array ? this.type = 1 : o === Float32Array ? this.type = 2 : o === Float64Array && (this.type = 3), this.dataLength = r, this.maxChunkSize = s;
-      let n = t.allocUI32(s * r * this.byteMultipler);
-      this.pointerVector.push(n.pointer);
+      let a = t.allocUI32(s * r * this.byteMultipler);
+      this.pointerVector.push(a.pointer);
     }
   }
   at(t) {
@@ -1350,7 +1361,7 @@ class It {
     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, F, 1);
+    this.recycleVector.length ? r = this.recycleVector.popNumber() : r = Atomics.add(this.firstBlock.data, D, 1);
     let s = this.getFullDataBlock(r), o = r % this.maxChunkSize;
     return s.set(t, e * o), r;
   }
@@ -1358,14 +1369,14 @@ class It {
     this.recycleVector.push(t);
   }
   clear() {
-    this.firstBlock.data[F] = 0, this.recycleVector.clear();
+    this.firstBlock.data[D] = 0, this.recycleVector.clear();
   }
   *[Symbol.iterator]() {
     const t = {};
     for (let s of this.recycleVector)
       t[s[0]] = !0;
     let e = this.getFullDataBlock(0), r = 0;
-    for (let s = 0; s < Atomics.load(this.firstBlock.data, F); s++)
+    for (let s = 0; s < Atomics.load(this.firstBlock.data, D); s++)
       if (!t[s]) {
         let o = Math.floor(s / this.maxChunkSize);
         o !== r && (e = this.getFullDataBlock(s), r = o), yield this.getDataBlock(e, s % this.maxChunkSize);
@@ -1376,10 +1387,10 @@ class It {
     if (r)
       return r;
     if (e >= this.pointerVector.length) {
-      let n = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
-      this.pointerVector.push(n.pointer);
+      let a = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
+      this.pointerVector.push(a.pointer);
     }
-    let s = new h(this.memory, g(this.pointerVector.get(e))), o;
+    let s = new h(this.memory, B(this.pointerVector.get(e))), o;
     switch (this.type) {
       case 1:
         o = new Int32Array(s.data.buffer, s.bufferByteOffset, this.dataLength * this.maxChunkSize);
@@ -1406,7 +1417,7 @@ class It {
     this.recycleVector.free();
     for (let t of this.pointerVector) {
       let e = t[0];
-      new h(this.memory, g(e)).free();
+      new h(this.memory, B(e)).free();
     }
     this.pointerVector.free(), this.firstBlock.free();
   }
@@ -1416,158 +1427,248 @@ class It {
     };
   }
 }
-const Pt = new ArrayBuffer(4), Nt = new Uint32Array(Pt), R = new Uint16Array(Pt);
-function be(i, t) {
-  return fe(Atomics.load(i, t));
+class be {
+  memory;
+  pointers = [];
+  recycledIndexes = [];
+  totalLength = 0;
+  maxChunkSize = 100;
+  dataLength = 1;
+  byteMultipler = 1;
+  typeConstructor;
+  fullDataBlocks = {};
+  get length() {
+    return this.totalLength - this.recycledIndexes.length;
+  }
+  get bufferLength() {
+    return this.maxChunkSize * this.pointers.length;
+  }
+  constructor(t, e) {
+    this.memory = t;
+    const r = e?.dataLength ?? 1, s = e?.maxChunkSize ?? 100;
+    this.dataLength = r, this.maxChunkSize = s, this.typeConstructor = e.type, this.typeConstructor === Float64Array && (this.byteMultipler = 2);
+    let o = t.allocUI32(s * r * this.byteMultipler);
+    this.pointers.push(o.pointer);
+    let a = new this.typeConstructor(o.data.buffer, o.bufferByteOffset, this.dataLength * this.maxChunkSize);
+    this.fullDataBlocks[0] = a;
+  }
+  at(t) {
+    let e = this.fullDataBlocks[Math.floor(t / this.maxChunkSize)];
+    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.fullDataBlocks[Math.floor(t / this.maxChunkSize)][t % this.maxChunkSize * r + e];
+  }
+  push(t) {
+    const e = typeof t == "number";
+    if (!e && t.length > this.dataLength)
+      throw new Error(`Can't insert ${t.length} array into shared list of ${this.dataLength} dataLength`);
+    let r = this.recycledIndexes.pop();
+    r === void 0 && (r = this.totalLength++);
+    let s = Math.floor(r / this.maxChunkSize);
+    if (s >= this.pointers.length) {
+      let n = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
+      this.pointers.push(n.pointer);
+      let f = new this.typeConstructor(n.data.buffer, n.bufferByteOffset, this.dataLength * this.maxChunkSize);
+      this.fullDataBlocks[s] = f;
+    }
+    let o = this.fullDataBlocks[s], a = r % this.maxChunkSize, l = this.dataLength * a;
+    return e ? o[l] = t : o.set(t, l), r;
+  }
+  deleteIndex(t) {
+    this.recycledIndexes.push(t);
+  }
+  clear() {
+    this.totalLength = 0, this.recycledIndexes = [];
+  }
+  *[Symbol.iterator]() {
+    const t = {};
+    for (let s of this.recycledIndexes)
+      t[s] = !0;
+    let e = this.getFullDataBlock(0), r = 0;
+    for (let s = 0; s < this.totalLength; s++)
+      if (!t[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.fullDataBlocks[e];
+    if (r)
+      return r;
+    if (e >= this.pointers.length) {
+      let a = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
+      this.pointers.push(a.pointer);
+    }
+    let s = new h(this.memory, B(this.pointers[e])), o = new this.typeConstructor(s.data.buffer, s.bufferByteOffset, this.dataLength * this.maxChunkSize);
+    return this.fullDataBlocks[e] = o, o;
+  }
+  getDataBlock(t, e) {
+    const r = e * this.dataLength;
+    return t.subarray(r, r + this.dataLength);
+  }
+  free() {
+    for (let t of this.pointers)
+      new h(this.memory, B(t)).free();
+    this.pointers = [], this.recycledIndexes = [], this.totalLength = 0, this.fullDataBlocks = {};
+  }
+}
+const It = new ArrayBuffer(4), Nt = new Uint32Array(It), R = new Uint16Array(It);
+function ge(i, t) {
+  return le(Atomics.load(i, t));
 }
-function Ae(i, t, e, r) {
-  Atomics.store(i, t, le(e, r));
+function ke(i, t, e, r) {
+  Atomics.store(i, t, fe(e, r));
 }
-function fe(i) {
+function le(i) {
   return Nt[0] = i, [R[0], R[1]];
 }
-function le(i, t) {
+function fe(i, t) {
   return R[0] = i, R[1] = t, Nt[0];
 }
-const Ct = new ArrayBuffer(8), Ut = new BigUint64Array(Ct), B = new Uint16Array(Ct);
-function ge(i, t) {
-  return Ut[0] = Atomics.load(i, t), [B[0], B[1], B[2], B[3]];
+const Pt = new ArrayBuffer(8), Ut = new BigUint64Array(Pt), b = new Uint16Array(Pt);
+function Ae(i, t) {
+  return Ut[0] = Atomics.load(i, t), [b[0], b[1], b[2], b[3]];
 }
-function ke(i, t, e, r, s, o = 0) {
-  B[0] = e, B[1] = r, B[2] = s, B[3] = o, Atomics.store(i, t, Ut[0]);
+function pe(i, t, e, r, s, o = 0) {
+  b[0] = e, b[1] = r, b[2] = s, b[3] = o, Atomics.store(i, t, Ut[0]);
 }
-const Ft = new ArrayBuffer(4), Dt = new Float32Array(Ft), xt = new Int32Array(Ft);
-function Rt(i, t) {
+const Dt = new ArrayBuffer(4), xt = new Float32Array(Dt), Ft = new Int32Array(Dt);
+function zt(i, t) {
   return i instanceof Float32Array && (i = new Int32Array(i.buffer, i.byteOffset, i.length)), Q(Atomics.load(i, t));
 }
 function Ee(i, t, e) {
   i instanceof Float32Array && (i = new Int32Array(i.buffer, i.byteOffset, i.length)), Atomics.store(i, t, $(e));
 }
 function Q(i) {
-  return xt[0] = i, Dt[0];
+  return Ft[0] = i, xt[0];
 }
 function $(i) {
-  return Dt[0] = i, xt[0];
+  return xt[0] = i, Ft[0];
 }
 function we(i, t, e) {
   return i instanceof Float32Array && (i = new Int32Array(i.buffer, i.byteOffset, i.length)), Q(Atomics.exchange(i, t, $(e)));
 }
-function $t(i, t, e, r) {
+function Rt(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 pe(i, t, e, r) {
+function Le(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 Te(i, t, e, r) {
+function Se(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 Le(i, t, e, r) {
+function Te(i, t, e, r) {
   let s, o;
   do
-    s = Rt(i, t), o = Math.min(s + e, r);
-  while ($t(i, t, s, o) !== s);
+    s = zt(i, t), o = Math.min(s + e, r);
+  while (Rt(i, t, s, o) !== s);
 }
-function Se(i, t, e, r) {
+function _e(i, t, e, r) {
   let s, o;
   do
-    s = Rt(i, t), o = Math.max(s - e, r);
-  while ($t(i, t, s, o) !== s);
+    s = zt(i, t), o = Math.max(s - e, r);
+  while (Rt(i, t, s, o) !== s);
 }
-const zt = new ArrayBuffer(8), Yt = new Float64Array(zt), Ht = new BigInt64Array(zt);
-function _e(i, t) {
+const $t = new ArrayBuffer(8), Yt = new Float64Array($t), Ht = new BigInt64Array($t);
+function Oe(i, t) {
   return i instanceof Float64Array && (i = new BigInt64Array(i.buffer, i.byteOffset, i.length)), tt(Atomics.load(i, t));
 }
-function Oe(i, t, e) {
-  i instanceof Float64Array && (i = new BigInt64Array(i.buffer, i.byteOffset, i.length)), Atomics.store(i, t, z(e));
+function Me(i, t, e) {
+  i instanceof Float64Array && (i = new BigInt64Array(i.buffer, i.byteOffset, i.length)), Atomics.store(i, t, Y(e));
 }
 function tt(i) {
   return Ht[0] = i, Yt[0];
 }
-function z(i) {
+function Y(i) {
   return Yt[0] = i, Ht[0];
 }
-function Me(i, t, e) {
-  return i instanceof Float64Array && (i = new BigInt64Array(i.buffer, i.byteOffset, i.length)), tt(Atomics.exchange(i, t, z(e)));
+function Ce(i, t, e) {
+  return i instanceof Float64Array && (i = new BigInt64Array(i.buffer, i.byteOffset, i.length)), tt(Atomics.exchange(i, t, Y(e)));
 }
 function Ie(i, t, e, r) {
-  return i instanceof Float64Array && (i = new BigInt64Array(i.buffer, i.byteOffset, i.length)), tt(Atomics.compareExchange(i, t, z(e), z(r)));
-}
-const p = 0, J = 1, L = 2;
-function Pe(i, t = 0) {
-  for (; Atomics.compareExchange(i, t, p, J) === L; )
-    Atomics.wait(i, t, L);
-  Atomics.add(i, t + 1, 1);
+  return i instanceof Float64Array && (i = new BigInt64Array(i.buffer, i.byteOffset, i.length)), tt(Atomics.compareExchange(i, t, Y(e), Y(r)));
 }
+const w = 0, J = 1, S = 2;
 function Ne(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);
+  for (; Atomics.compareExchange(i, t, w, J) === S; )
+    Atomics.wait(i, t, S);
+  Atomics.add(i, t + 1, 1);
 }
-function Ce(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 Pe(i, t = 0) {
+  let e = Atomics.compareExchange(i, t, w, S);
+  for (; e !== w; )
+    Atomics.wait(i, t, e), e = Atomics.compareExchange(i, t, w, S);
 }
 function Ue(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);
+  Atomics.sub(i, t + 1, 1) - 1 <= 0 && (Atomics.compareExchange(i, t, J, w) !== J && console.warn("We are unlocking when it was not read locked!"), Atomics.notify(i, t));
+}
+function De(i, t = 0) {
+  Atomics.compareExchange(i, t, S, w) !== S && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(i, t);
 }
-const Fe = 2;
+const xe = 2;
 export {
   h as AllocatedMemory,
   he as BYTE_OFFSET_BIT_COUNT,
   me as CachedItemList,
+  be as LocalPool,
   et as MAX_BYTE_OFFSET_LENGTH,
   rt as MAX_POSITION_LENGTH,
-  Z as MemoryBuffer,
-  de as MemoryHeap,
+  W as MemoryBuffer,
+  ye as MemoryHeap,
   ce as POSITION_BIT_COUNT,
-  Fe as READ_WRITE_LOCK_ALLOCATE_COUNT,
-  ye as SIMPLE_LOCK_ALLOCATE_COUNT,
+  xe as READ_WRITE_LOCK_ALLOCATE_COUNT,
+  de as SIMPLE_LOCK_ALLOCATE_COUNT,
   u as SharedList,
   Ot as SharedMap,
   Be as SharedPointerList,
-  It as SharedPool,
+  Ct as SharedPool,
   Mt as SharedString,
-  d as SharedVector,
-  Le as addAtomicFloat32,
-  pe as addAtomicInt,
-  $t as compareExchangeFloat32,
+  m as SharedVector,
+  Te as addAtomicFloat32,
+  Le as addAtomicInt,
+  Rt as compareExchangeFloat32,
   Ie as compareExchangeFloat64,
-  le as convert16To32,
-  fe as convert32To16,
+  fe as convert16To32,
+  le as convert32To16,
   $ as convertFloat32ToInt32,
-  z as convertFloat64ToInt64,
+  Y as convertFloat64ToInt64,
   Q as convertInt32ToFloat32,
   tt as convertInt64ToFloat64,
-  T as createPointer,
+  L as createPointer,
   we as exchangeFloat32,
-  Me as exchangeFloat64,
-  g as getPointer,
-  be as load16From32,
-  ge as load16From64,
-  Rt as loadFloat32,
-  _e as loadFloat64,
+  Ce as exchangeFloat64,
+  B as getPointer,
+  ge as load16From32,
+  Ae as load16From64,
+  zt as loadFloat32,
+  Oe as loadFloat64,
   c as loadPointer,
   O as loadRawPointer,
-  x as lock,
-  Pe as readLock,
-  Ce as readUnlock,
+  z as lock,
+  Ne as readLock,
+  Ue as readUnlock,
   ue as replacePointer,
-  H as replaceRawPointer,
-  Ae as store16In32,
-  ke as store16In64,
+  V as replaceRawPointer,
+  ke as store16In32,
+  pe as store16In64,
   Ee as storeFloat32,
-  Oe as storeFloat64,
-  m as storePointer,
-  v as storeRawPointer,
-  Se as subtractAtomicFloat,
-  Te as subtractAtomicInt,
-  A as unlock,
-  Ne as writeLock,
-  Ue as writeUnlock
+  Me as storeFloat64,
+  k as storePointer,
+  x as storeRawPointer,
+  _e as subtractAtomicFloat,
+  Se as subtractAtomicInt,
+  g as unlock,
+  Pe as writeLock,
+  De as writeUnlock
 };
 //# sourceMappingURL=shared-memory-objects.js.map