@daneren2005/shared-memory-objects 1.0.0 → 1.2.0

package/dist/shared-memory-objects.js

@@ -1,1578 +0,0 @@
-const Qt = 20, te = 12, tt = Math.pow(2, 20), et = Math.pow(2, 12);
-function c(s, t = 0) {
-  return y(Atomics.load(s, t));
-}
-function O(s, t = 0) {
-  return Atomics.load(s, t);
-}
-function k(s, t = 0, e, r) {
-  Atomics.store(s, t, L(e, r));
-}
-function U(s, t = 0, e) {
-  Atomics.store(s, t, e);
-}
-function ee(s, t, e, r, i, o) {
-  let a = L(i, o);
-  return Atomics.compareExchange(s, t, a, L(e, r)) === a;
-}
-function H(s, t, e, r) {
-  return Atomics.compareExchange(s, t, r, e) === r;
-}
-function y(s) {
-  return {
-    bufferPosition: s & 4095,
-    bufferByteOffset: s >>> 12
-  };
-}
-function L(s, t) {
-  return s + (t << 12);
-}
-class f {
-  memory;
-  bufferPosition;
-  get bufferByteOffset() {
-    return this.data.byteOffset;
-  }
-  get pointer() {
-    return L(this.bufferPosition, this.bufferByteOffset);
-  }
-  buffer;
-  data;
-  constructor(t, e) {
-    this.memory = t, "buffer" in e ? (this.data = e.data, this.buffer = e.buffer, this.bufferPosition = this.memory.buffers.indexOf(e.buffer)) : (this.bufferPosition = e.bufferPosition, this.buffer = t.buffers[e.bufferPosition], this.data = new Uint32Array(this.buffer.buf, e.bufferByteOffset));
-  }
-  getArray(t, e, r) {
-    return new t(this.data.buffer, this.data.byteOffset + e * t.BYTES_PER_ELEMENT, r);
-  }
-  getArrayMemory(t, e) {
-    return {
-      bufferPosition: this.bufferPosition,
-      bufferByteOffset: this.bufferByteOffset + t * this.data.BYTES_PER_ELEMENT
-    };
-  }
-  free() {
-    this.buffer.free(this.data.byteOffset);
-  }
-  getSharedMemory() {
-    return {
-      bufferPosition: this.bufferPosition,
-      bufferByteOffset: this.bufferByteOffset
-    };
-  }
-}
-const W = 0, D = 1;
-function x(s, t = 0) {
-  for (; Atomics.compareExchange(s, t, W, D) !== W; )
-    "WorkerGlobalScope" in self && Atomics.wait(s, t, D);
-}
-function b(s, t = 0) {
-  Atomics.compareExchange(s, t, D, W) !== D && console.warn("We are unlocking when it was not locked!"), Atomics.notify(s, t);
-}
-const re = 1, Rt = {
-  5120: "i8",
-  5121: "u8",
-  5122: "i16",
-  5123: "u16",
-  5124: "i32",
-  5125: "u32",
-  5126: "f32"
-}, $t = {
-  f32: Float32Array,
-  f64: Float64Array
-}, Ht = {
-  i8: Int8Array,
-  i16: Int16Array,
-  i32: Int32Array
-}, Yt = {
-  u8: Uint8Array,
-  u8c: Uint8ClampedArray,
-  u16: Uint16Array,
-  u32: Uint32Array
-}, Vt = {
-  i64: BigInt64Array,
-  u64: BigUint64Array
-}, Kt = {
-  ...$t,
-  ...Ht,
-  ...Yt
-}, Xt = (s) => {
-  const t = Rt[s];
-  return t !== void 0 ? t : s;
-};
-function Gt(s, ...t) {
-  const e = Vt[s];
-  return new (e || Kt[Xt(s)])(...t);
-}
-const rt = 0, it = 1, st = 2, ot = 3, at = 4, g = 5, nt = 6, Y = 1, V = 2, lt = 32, K = 0, X = 1, d = 8;
-class G {
-  buf;
-  start;
-  u8;
-  u32;
-  state;
-  lock;
-  constructor(t = {}) {
-    if (this.buf = t.buf ? t.buf : new ArrayBuffer(t.size || 4096), this.start = t.start != null ? C(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) {
-      const e = t.align || 8;
-      if (e < 8)
-        throw new Error(`invalid alignment: ${e}, must be a pow2 and >= 8`);
-      const r = this.initialTop(e), i = t.end != null ? Math.min(t.end, this.buf.byteLength) : this.buf.byteLength;
-      if (r >= i)
-        throw new Error(
-          `insufficient address range (0x${this.start.toString(
-            16
-          )} - 0x${i.toString(16)})`
-        );
-      this.align = e, this.doCompact = t.compact !== !1, this.doSplit = t.split !== !1, this.minSplit = t.minSplit || 16, this.end = i, this.top = r, this._free = 0, this._used = 0;
-    }
-  }
-  stats() {
-    const t = (r) => {
-      let i = 0, o = 0;
-      for (; r; )
-        if (i++, o += this.blockSize(r), r = this.blockNext(r), r > this.end) {
-          console.error(`Trying to get stats for block past end of buffer: ${r} > ${this.end}`);
-          break;
-        }
-      return { count: i, size: o };
-    }, e = t(this._free);
-    return {
-      free: e,
-      used: t(this._used),
-      top: this.top,
-      available: this.end - this.top + e.size,
-      total: this.buf.byteLength
-    };
-  }
-  callocAs(t, e, r = 0) {
-    const i = this.mallocAs(t, e);
-    return i && i.fill(r), i;
-  }
-  mallocAs(t, e) {
-    const r = this.malloc(e * Zt[t]);
-    return r ? Gt(t, this.buf, r, e) : void 0;
-  }
-  calloc(t, e = 0) {
-    const r = this.malloc(t);
-    return r && this.u8.fill(e, r, r + t), r;
-  }
-  malloc(t) {
-    if (t <= 0)
-      return 0;
-    x(this.lock);
-    const e = C(t + d, this.align), r = this.end;
-    let i = this.top, o = this._free, a = 0;
-    for (; o; ) {
-      const n = this.blockSize(o), l = o + n >= i;
-      if (l || n >= e) {
-        let h = this.mallocTop(
-          o,
-          a,
-          n,
-          e,
-          l
-        );
-        return b(this.lock), h;
-      }
-      a = o, o = this.blockNext(o);
-    }
-    if (o = i, i = o + e, i <= r) {
-      this.initBlock(o, e, this._used), this._used = o, this.top = i;
-      let n = T(o);
-      return b(this.lock), n;
-    }
-    return b(this.lock), 0;
-  }
-  mallocTop(t, e, r, i, o) {
-    if (o && t + i > this.end) return 0;
-    if (e ? this.unlinkBlock(e, t) : this._free = this.blockNext(t), this.setBlockNext(t, this._used), this._used = t, o)
-      this.top = t + this.setBlockSize(t, i);
-    else if (this.doSplit) {
-      const a = r - i;
-      a >= this.minSplit && this.splitBlock(t, i, a);
-    }
-    return T(t);
-  }
-  realloc(t, e) {
-    if (e <= 0)
-      return 0;
-    const r = _(t);
-    let i = 0, o = this._used, a = 0;
-    for (; o; ) {
-      if (o === r) {
-        [i, a] = this.reallocBlock(o, e);
-        break;
-      }
-      o = this.blockNext(o);
-    }
-    return i && i !== r && this.u8.copyWithin(
-      T(i),
-      T(r),
-      a
-    ), T(i);
-  }
-  reallocBlock(t, e) {
-    const r = this.blockSize(t), i = t + r, o = i >= this.top, a = C(e + d, this.align);
-    if (a <= r) {
-      if (this.doSplit) {
-        const n = r - a;
-        n >= this.minSplit ? this.splitBlock(t, a, n) : o && (this.top = t + a);
-      } else o && (this.top = t + a);
-      return [t, i];
-    }
-    return o && t + a < this.end ? (this.top = t + this.setBlockSize(t, a), [t, i]) : (this.free(t), [_(this.malloc(e)), i]);
-  }
-  reallocArray(t, e) {
-    if (t.buffer !== this.buf)
-      return;
-    const r = this.realloc(
-      t.byteOffset,
-      e * t.BYTES_PER_ELEMENT
-    );
-    return r ? new t.constructor(this.buf, r, e) : void 0;
-  }
-  bytesFor(t) {
-    let e;
-    if (typeof t != "number") {
-      if (t.buffer !== this.buf)
-        return;
-      e = t.byteOffset;
-    } else
-      e = t;
-    e = _(e);
-    let r = this._used;
-    for (; r; ) {
-      if (r === e)
-        return this.blockSize(e) - d;
-      r = this.blockNext(r);
-    }
-  }
-  lengthOf(t) {
-    let e = this.bytesFor(t);
-    if (e)
-      return e / this.u32.BYTES_PER_ELEMENT;
-  }
-  free(t) {
-    let e;
-    if (typeof t != "number") {
-      if (t.buffer !== this.buf)
-        return !1;
-      e = t.byteOffset;
-    } else
-      e = t;
-    x(this.lock), e = _(e);
-    let r = this._used, i = 0;
-    for (; r; ) {
-      if (r === e)
-        return i ? this.unlinkBlock(i, r) : this._used = this.blockNext(r), this.insert(r), this.doCompact && this.compact(), b(this.lock), !0;
-      i = r, r = this.blockNext(r);
-    }
-    return b(this.lock), !1;
-  }
-  freeAll() {
-    this._free = 0, this._used = 0, this.top = this.initialTop();
-  }
-  release() {
-    return delete this.u8, delete this.u32, delete this.state, delete this.buf, !0;
-  }
-  get align() {
-    return this.state[at];
-  }
-  set align(t) {
-    this.state[at] = t;
-  }
-  get end() {
-    return this.state[ot];
-  }
-  set end(t) {
-    this.state[ot] = t;
-  }
-  get top() {
-    return Atomics.load(this.state, st);
-  }
-  set top(t) {
-    Atomics.store(this.state, st, t);
-  }
-  get _free() {
-    return Atomics.load(this.state, rt);
-  }
-  set _free(t) {
-    Atomics.store(this.state, rt, t);
-  }
-  get _used() {
-    return Atomics.load(this.state, it);
-  }
-  set _used(t) {
-    Atomics.store(this.state, it, t);
-  }
-  get doCompact() {
-    return !!(this.state[g] & Y);
-  }
-  set doCompact(t) {
-    t ? this.state[g] |= 1 << Y - 1 : this.state[g] &= ~Y;
-  }
-  get doSplit() {
-    return !!(this.state[g] & V);
-  }
-  set doSplit(t) {
-    t ? this.state[g] |= 1 << V - 1 : this.state[g] &= ~V;
-  }
-  get minSplit() {
-    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[nt] = t;
-  }
-  blockSize(t) {
-    return Atomics.load(this.u32, (t >> 2) + K);
-  }
-  /**
-   * Sets & returns given block size.
-   *
-   * @param block -
-   * @param size -
-   */
-  setBlockSize(t, e) {
-    return Atomics.store(this.u32, (t >> 2) + K, e), e;
-  }
-  blockNext(t) {
-    return Atomics.load(this.u32, (t >> 2) + X);
-  }
-  /**
-   * Sets block next pointer to `next`. Use zero to indicate list end.
-   *
-   * @param block -
-   */
-  setBlockNext(t, e) {
-    Atomics.store(this.u32, (t >> 2) + X, e);
-  }
-  /**
-   * Initializes block header with given `size` and `next` pointer. Returns `block`.
-   *
-   * @param block -
-   * @param size -
-   * @param next -
-   */
-  initBlock(t, e, r) {
-    const i = t >>> 2;
-    return Atomics.store(this.u32, i + K, e), Atomics.store(this.u32, i + X, r), t;
-  }
-  unlinkBlock(t, e) {
-    this.setBlockNext(t, this.blockNext(e));
-  }
-  splitBlock(t, e, r) {
-    this.insert(
-      this.initBlock(
-        t + this.setBlockSize(t, e),
-        r,
-        0
-      )
-    ), this.doCompact && this.compact();
-  }
-  initialTop(t = this.align) {
-    return C(this.start + lt + d, t) - d;
-  }
-  /**
-   * Traverses free list and attempts to recursively merge blocks
-   * occupying consecutive memory regions. Returns true if any blocks
-   * have been merged. Only called if `compact` option is enabled.
-   */
-  compact() {
-    let t = this._free, e = 0, r = 0, i, o = !1;
-    for (; t; ) {
-      for (i = t, r = this.blockNext(t); r && i + this.blockSize(i) === r; )
-        i = r, r = this.blockNext(r);
-      if (i !== t) {
-        const a = i - t + this.blockSize(i);
-        this.setBlockSize(t, a);
-        const n = this.blockNext(i);
-        let l = this.blockNext(t);
-        for (; l && l !== n; ) {
-          const h = this.blockNext(l);
-          this.setBlockNext(l, 0), l = h;
-        }
-        this.setBlockNext(t, n), 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);
-    }
-    return o;
-  }
-  /**
-   * Inserts given block into list of free blocks, sorted by address.
-   *
-   * @param block -
-   */
-  insert(t) {
-    let e = this._free, r = 0;
-    for (; e && !(t <= e); )
-      r = e, e = this.blockNext(e);
-    r ? this.setBlockNext(r, t) : this._free = t, this.setBlockNext(t, e);
-  }
-}
-const T = (s) => s > 0 ? s + d : 0, _ = (s) => s > 0 ? s - d : 0, C = (s, t) => (t--, s + t & ~t), Zt = {
-  u8: 1,
-  u8c: 1,
-  i8: 1,
-  u16: 2,
-  i16: 2,
-  u32: 4,
-  i32: 4,
-  i64: 8,
-  u64: 8,
-  f32: 4,
-  f64: 8
-}, Wt = 8192, ft = 0, Z = 1, I = 2;
-class ie {
-  buffers;
-  onGrowBufferHandlers = [];
-  isClone;
-  memory;
-  get bufferSize() {
-    return this.memory.data[ft];
-  }
-  constructor(t) {
-    if (t && "buffers" in t)
-      this.buffers = t.buffers.map((e) => new G({
-        buf: e,
-        skipInitialization: !0
-      })), this.memory = new f(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 > 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 i = r.callocAs("u32", 3);
-      if (i)
-        this.memory = new f(this, {
-          bufferPosition: 0,
-          bufferByteOffset: i.byteOffset
-        });
-      else
-        throw new Error("Failed to initialize first byte from buffer");
-      this.memory.data[ft] = 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 G({
-      buf: t.buffer,
-      skipInitialization: !0
-    });
-  }
-  growBuffer() {
-    const t = this.createBuffer();
-    let e = Atomics.add(this.memory.data, Z, 1);
-    return this.buffers[e] = t, this.onGrowBufferHandlers.forEach((r) => r({
-      bufferPosition: e,
-      buffer: t.buf
-    })), t;
-  }
-  createBuffer(t) {
-    const e = t ?? this.bufferSize;
-    let r;
-    return "SharedArrayBuffer" in globalThis ? r = new SharedArrayBuffer(e) : r = new ArrayBuffer(e), new G({
-      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
-      // After the internal state is wrong MemoryBuffer will loose track of which blocks are where and how big they are
-      compact: !1,
-      split: !1
-    });
-  }
-  addOnGrowBufferHandlers(t) {
-    this.onGrowBufferHandlers.push(t);
-  }
-  allocUI32(t) {
-    t = Math.ceil(t);
-    for (let i = 0; i < this.buffers.length; i++) {
-      const o = this.buffers[i];
-      if (!o)
-        continue;
-      const a = o.callocAs("u32", t);
-      if (a)
-        return i === 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 f(this, {
-          data: a,
-          buffer: o
-        });
-    }
-    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 f(this, {
-        data: r,
-        buffer: e
-      });
-    throw new Error(`Unable to allocate ${t} numbers even after adding a new buffer`);
-  }
-  getSharedAlloc(t) {
-    if (this.buffers[t.bufferPosition] !== void 0)
-      return new f(this, t);
-  }
-  get currentUsed() {
-    return this.totalAllocated - this.buffers.reduce((t, e) => t + e.stats().available, 0);
-  }
-  get totalAllocated() {
-    return this.buffers[0].buf.byteLength * this.buffers.length;
-  }
-  getSharedMemory() {
-    return {
-      buffers: this.buffers.map((t) => t.buf)
-    };
-  }
-}
-const ht = 4, ct = 1, A = 2;
-class u {
-  static ALLOCATE_COUNT = ht;
-  memory;
-  /* First block
-  	32 index 0
-  	uint16 0 - next buffer position
-  	uint16 1 - next buffer index
-  	32 index 1
-  	uint16 2 - last buffer position
-  	uint16 3 - last buffer index
-  	32 index 2
-  	uint32 4 - length
-  	32 index 3
-  	uint16 6 - type
-  	uint16 7 - data length (defaults to 1 number per data)
-  */
-  /* Other blocks
-  	32 index 0
-  	uint16 0 - next buffer position
-  	uint16 1 - next buffer index
-  	32 index 1 => data
-  */
-  firstBlock;
-  uint16Array;
-  onDelete;
-  get length() {
-    return Atomics.load(this.firstBlock.data, A);
-  }
-  get type() {
-    return Atomics.load(this.uint16Array, 0);
-  }
-  set type(t) {
-    Atomics.store(this.uint16Array, 0, t);
-  }
-  get dataLength() {
-    return Math.max(1, Atomics.load(this.uint16Array, 1));
-  }
-  set dataLength(t) {
-    Atomics.store(this.uint16Array, 1, t);
-  }
-  constructor(t, e) {
-    if (this.memory = t, e && "firstBlock" in e)
-      this.firstBlock = new f(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (A + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
-    else {
-      e && e.initWithBlock ? this.firstBlock = new f(t, e.initWithBlock) : this.firstBlock = t.allocUI32(ht), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (A + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
-      const r = e?.type ?? Uint32Array;
-      r === Uint32Array ? this.type = 0 : r === Int32Array ? this.type = 1 : r === Float32Array && (this.type = 2), this.dataLength = e?.dataLength ?? 1;
-    }
-  }
-  insert(t) {
-    typeof t == "number" && (t = [t]);
-    let e = this.dataLength;
-    if (t.length > e)
-      throw new Error(`Can't insert ${t.length} array into shared list of ${e} dataLength`);
-    let r = this.memory.allocUI32(ct + e), i = this.getDataBlock(r.data), o = r.pointer;
-    for (let l = 0; l < t.length; l++)
-      i instanceof Int32Array || i instanceof Uint32Array ? Atomics.store(i, l, t[l]) : i[l] = t[l];
-    let a, n = !1;
-    for (; !n; )
-      a = O(this.firstBlock.data, 1), n = H(this.firstBlock.data, 1, o, a);
-    if (a) {
-      let { bufferPosition: l, bufferByteOffset: h } = y(a), $ = new Uint32Array(this.memory.buffers[l].buf, h, 1);
-      U($, 0, o);
-    } else
-      U(this.firstBlock.data, 0, o);
-    Atomics.add(this.firstBlock.data, A, 1);
-  }
-  deleteMatch(t) {
-    for (let { data: e, index: r, deleteCurrent: i } of this)
-      if (t(e, r))
-        return i(), !0;
-    return !1;
-  }
-  deleteIndex(t) {
-    return t >= this.length || t < 0 ? !1 : this.deleteMatch((e, r) => r === t);
-  }
-  deleteValue(t) {
-    return typeof t == "number" ? this.deleteMatch((e) => e[0] === t) : this.deleteMatch((e) => {
-      if (e.length !== t.length)
-        return !1;
-      for (let r = 0; r < e.length; r++)
-        if (e[r] !== t[r])
-          return !1;
-      return !0;
-    });
-  }
-  clear() {
-    let t, e, r = !1;
-    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);
-    }
-    if (!t)
-      return;
-    H(this.firstBlock.data, 0, 0, t);
-    let i = 0, o = t;
-    for (; o; ) {
-      let { bufferPosition: a, bufferByteOffset: n } = y(o), l = this.memory.buffers[a];
-      if (!l)
-        break;
-      let h = new Uint32Array(l.buf, n, 2);
-      o = O(h, 0), i++, this.onDelete && this.onDelete(this.getDataBlock(h)), l.free(h.byteOffset);
-    }
-    Atomics.sub(this.firstBlock.data, A, i);
-  }
-  *[Symbol.iterator]() {
-    let t = 0, { bufferPosition: e, bufferByteOffset: r } = c(this.firstBlock.data, 0), i = this.firstBlock.data, o = 0, a = 0;
-    for (; r; ) {
-      let n = this.memory.buffers[e];
-      if (!n)
-        return;
-      let l = new Uint32Array(n.buf, r, 2), h = this.getDataBlock(l), $ = e, zt = r;
-      ({ bufferPosition: e, bufferByteOffset: r } = c(l, 0));
-      let Q = !0;
-      yield {
-        data: h,
-        index: t,
-        deleteCurrent: () => {
-          k(i, 0, e, r), r || k(this.firstBlock.data, 1, o, a), this.onDelete && this.onDelete(this.getDataBlock(l)), n.free(l.byteOffset), Atomics.sub(this.firstBlock.data, A, 1), Q = !1;
-        }
-      }, Q && (i = l, o = $, a = zt, t++);
-    }
-  }
-  forEach(t) {
-    for (let e of this)
-      t(e.data);
-  }
-  getSharedMemory() {
-    return {
-      firstBlock: this.firstBlock.getSharedMemory()
-    };
-  }
-  getDataBlock(t) {
-    const e = t.byteOffset + ct * t.BYTES_PER_ELEMENT;
-    switch (this.type) {
-      case 1:
-        return new Int32Array(t.buffer, e, this.dataLength);
-      case 0:
-        return new Uint32Array(t.buffer, e, this.dataLength);
-      case 2:
-        return new Float32Array(t.buffer, e, this.dataLength);
-      default:
-        throw new Error(`Unknown data block type ${this.type}`);
-    }
-  }
-  free() {
-    let { bufferPosition: t, bufferByteOffset: e } = c(this.firstBlock.data, 0);
-    for (; e; ) {
-      let r = new f(this.memory, {
-        bufferPosition: t,
-        bufferByteOffset: e
-      });
-      ({ bufferPosition: t, bufferByteOffset: e } = c(r.data, 0)), this.onDelete && this.onDelete(this.getDataBlock(r.data)), r.free();
-    }
-    this.firstBlock.free();
-  }
-}
-const ut = 10;
-class wt {
-  static ALLOCATE_COUNT = 4;
-  memory;
-  // Memory order: Pointer, Lock, Length, MaxHash
-  pointerMemory;
-  lock;
-  get hashMemory() {
-    return new f(this.memory, c(this.pointerMemory.data, 0));
-  }
-  get length() {
-    return Atomics.load(this.pointerMemory.data, 2);
-  }
-  get maxHash() {
-    return Atomics.load(this.pointerMemory.data, 3);
-  }
-  constructor(t, e) {
-    if (this.memory = t, e)
-      this.pointerMemory = new f(t, e.firstBlock);
-    else {
-      this.pointerMemory = t.allocUI32(wt.ALLOCATE_COUNT);
-      let r = t.allocUI32(ut);
-      k(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, ut);
-    }
-    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 = M(t);
-    this.setHashKey(this.hashMemory, this.maxHash, r, e) && Atomics.add(this.pointerMemory.data, 2, 1);
-  }
-  setHashKey(t, e, r, i) {
-    let o = this.hash(r, e), a, n = c(t.data, o);
-    if (n.bufferByteOffset === 0) {
-      a = new u(this.memory, {
-        dataLength: 2
-      });
-      let h = a.getSharedMemory();
-      k(t.data, o, h.firstBlock.bufferPosition, h.firstBlock.bufferByteOffset);
-    } else
-      a = new u(this.memory, {
-        firstBlock: n
-      });
-    let l = !0;
-    return a.deleteValue(r) && (l = !1), a.insert([r, i]), l;
-  }
-  get(t) {
-    let e = M(t), r = this.hash(e, this.maxHash), i = c(this.hashMemory.data, r);
-    if (i.bufferByteOffset === 0)
-      return;
-    let o = new u(this.memory, {
-      firstBlock: i
-    });
-    for (let { data: a } of o)
-      if (a[0] === e)
-        return a[1];
-  }
-  has(t) {
-    let e = M(t), r = this.hash(e, this.maxHash), i = c(this.hashMemory.data, r);
-    if (i.bufferByteOffset === 0)
-      return !1;
-    let o = new u(this.memory, {
-      firstBlock: i
-    });
-    for (let { data: a } of o)
-      if (a[0] === e)
-        return !0;
-    return !1;
-  }
-  delete(t) {
-    let e = M(t), r = this.hash(e, this.maxHash), i = c(this.hashMemory.data, r);
-    if (i.bufferByteOffset === 0)
-      return !1;
-    let o = new u(this.memory, {
-      firstBlock: i
-    });
-    for (let { data: a, deleteCurrent: n } of o)
-      if (a[0] === e)
-        return n(), Atomics.sub(this.pointerMemory.data, 2, 1), !0;
-    return !1;
-  }
-  growHashTable() {
-    let t = this.maxHash, e = t * 2, r = this.memory.allocUI32(e), i = this.hashMemory;
-    for (let o = 0; o < t; o++) {
-      let a = c(i.data, o);
-      if (a.bufferByteOffset === 0)
-        continue;
-      let n = new u(this.memory, {
-        firstBlock: a
-      });
-      for (let { data: l } of n)
-        this.setHashKey(r, e, l[0], l[1]);
-      n.free();
-    }
-    k(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, e), i.free();
-  }
-  hash(t, e) {
-    return t % e;
-  }
-  free() {
-    for (let t = 0; t < this.maxHash; t++) {
-      let e = c(this.hashMemory.data, t);
-      if (e.bufferByteOffset === 0)
-        continue;
-      new u(this.memory, {
-        firstBlock: e
-      }).free();
-    }
-    this.hashMemory.free(), this.pointerMemory.free();
-  }
-  getSharedMemory() {
-    return {
-      firstBlock: this.pointerMemory.getSharedMemory()
-    };
-  }
-}
-function M(s) {
-  return typeof s == "number" ? s : typeof s == "string" ? vt(s) : s;
-}
-function vt(s) {
-  let t = s.length, e = 17 ^ t, r = 0, i;
-  for (; t >= 4; )
-    i = s.charCodeAt(r) & 255 | (s.charCodeAt(++r) & 255) << 8 | (s.charCodeAt(++r) & 255) << 16 | (s.charCodeAt(++r) & 255) << 14, i = (i & 65535) * 1540483477 + (((i >>> 16) * 1540483477 & 65535) << 16), i ^= i >>> 14, i = (i & 65535) * 1540483477 + (((i >>> 16) * 1540483477 & 65535) << 16), e = (e & 65535) * 1540483477 + (((e >>> 16) * 1540483477 & 65535) << 16) ^ i, t -= 4, ++r;
-  switch (t) {
-    case 3:
-      e ^= (s.charCodeAt(r + 2) & 255) << 16;
-    case 2:
-      e ^= (s.charCodeAt(r + 1) & 255) << 8;
-    case 1:
-      e ^= s.charCodeAt(r) & 255, e = (e & 65535) * 1540483477 + (((e >>> 16) * 1540483477 & 65535) << 16);
-  }
-  return e ^= e >>> 13, e = (e & 65535) * 1540483477 + (((e >>> 16) * 1540483477 & 65535) << 16), e ^= e >>> 15, e = e >>> 0, e;
-}
-class se {
-  memory;
-  list;
-  constructor(t, e) {
-    this.memory = t, e ? this.list = new u(t, e) : this.list = new u(t);
-  }
-  get length() {
-    return this.list.length;
-  }
-  insert(t) {
-    this.list.insert(L(t.memory.bufferPosition, t.memory.bufferByteOffset));
-  }
-  delete(t) {
-    return this.list.deleteValue(L(t.memory.bufferPosition, t.memory.bufferByteOffset));
-  }
-  *[Symbol.iterator]() {
-    let t = this.list[Symbol.iterator]();
-    for (let { data: e } of t) {
-      let { bufferPosition: r, bufferByteOffset: i } = c(e, 0), o = new f(this.memory, {
-        bufferPosition: r,
-        bufferByteOffset: i
-      });
-      yield this.createItem(o);
-    }
-  }
-  forEach(t) {
-    for (let e of this)
-      t(e);
-  }
-  find(t) {
-    for (let e of this)
-      if (t(e))
-        return e;
-  }
-  getSharedMemory() {
-    return this.list.getSharedMemory();
-  }
-  free() {
-    for (let t of this)
-      "free" in t && typeof t.free == "function" ? t.free() : t.memory.free();
-    this.list.free();
-  }
-}
-const dt = {
-  1: Uint8Array,
-  2: Uint16Array
-}, N = 0, yt = 1, mt = 2, Bt = 3;
-class Lt {
-  static ALLOCATE_COUNT = 4;
-  memory;
-  allocatedMemory;
-  lock;
-  cachedPointer;
-  cachedString;
-  constructor(t, e) {
-    this.memory = t, typeof e == "string" ? (this.allocatedMemory = this.memory.allocUI32(Lt.ALLOCATE_COUNT), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + Bt * this.allocatedMemory.data.BYTES_PER_ELEMENT), this.updateString(e)) : (this.allocatedMemory = new f(t, e), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + Bt * this.allocatedMemory.data.BYTES_PER_ELEMENT), "value" in e && this.updateString(e.value));
-  }
-  updateString(t) {
-    let e = this.createString(t);
-    x(this.lock), U(this.allocatedMemory.data, N, e.pointer), Atomics.store(this.allocatedMemory.data, yt, t.length), Atomics.store(this.allocatedMemory.data, mt, e.charType), b(this.lock), this.cachedPointer = e.pointer, this.cachedString = t;
-  }
-  createString(t) {
-    if (t === "")
-      return {
-        pointer: 0,
-        charType: 1
-        /* ASCII */
-      };
-    let e = 0;
-    for (let n = 0; n < t.length; n++) {
-      let l = t.charCodeAt(n);
-      l > e && (e = l);
-    }
-    let r = e > 255 ? 2 : 1, i = dt[r], o = this.memory.allocUI32(Math.ceil(t.length / (4 / i.BYTES_PER_ELEMENT))), a = new i(o.data.buffer, o.data.byteOffset, t.length);
-    for (let n = 0; n < t.length; n++)
-      a[n] = t.charCodeAt(n);
-    return {
-      pointer: o.pointer,
-      charType: r
-    };
-  }
-  get value() {
-    let t = O(this.allocatedMemory.data, N);
-    if (this.cachedPointer === t && this.cachedString !== void 0)
-      return this.cachedString;
-    if (t === 0)
-      return "";
-    let { bufferPosition: e, bufferByteOffset: r } = y(t);
-    x(this.lock);
-    let i = Atomics.load(this.allocatedMemory.data, mt), o = dt[i], a = Atomics.load(this.allocatedMemory.data, yt), n = new o(this.memory.buffers[e].buf, r, a), l = jt(n);
-    return b(this.lock), this.cachedPointer = t, this.cachedString = l, l;
-  }
-  set value(t) {
-    let { bufferPosition: e, bufferByteOffset: r } = c(this.allocatedMemory.data, N);
-    this.updateString(t), r && this.memory.buffers[e].free(r);
-  }
-  getSharedMemory() {
-    return this.allocatedMemory.getSharedMemory();
-  }
-  get pointer() {
-    return this.allocatedMemory.pointer;
-  }
-  free() {
-    let { bufferPosition: t, bufferByteOffset: e } = c(this.allocatedMemory.data, N);
-    e && this.memory.buffers[t].free(e), this.allocatedMemory.free();
-  }
-}
-function jt(s) {
-  if (s.length <= 8192)
-    return String.fromCharCode.apply(null, s);
-  let e = "";
-  for (let r = 0; r < s.length; r += 8192)
-    e += String.fromCharCode.apply(null, s.subarray(r, r + 8192));
-  return e;
-}
-const p = 0, E = 1, bt = 2, kt = 3, gt = 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, E);
-  }
-  get type() {
-    return this.uint16Array[0];
-  }
-  set type(t) {
-    Atomics.store(this.uint16Array, 0, t);
-  }
-  get dataLength() {
-    return this.uint16Array[1] || 1;
-  }
-  set dataLength(t) {
-    Atomics.store(this.uint16Array, 1, t);
-  }
-  get bufferLength() {
-    return Atomics.load(this.firstBlock.data, bt);
-  }
-  set bufferLength(t) {
-    Atomics.store(this.firstBlock.data, bt, t);
-  }
-  get pointer() {
-    return this.firstBlock.pointer;
-  }
-  cachedFullDataBlock;
-  cachedPointer;
-  constructor(t, e) {
-    if (this.memory = t, e && "firstBlock" in e) {
-      if (this.firstBlock = new f(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + kt * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in e || "dataLength" in e) {
-        const r = e.bufferLength ?? gt;
-        let i = t.allocUI32(r * (e.dataLength ?? 1));
-        k(this.firstBlock.data, p, i.bufferPosition, i.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(m.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + kt * Uint32Array.BYTES_PER_ELEMENT, 2);
-      let r = e?.dataLength ?? 1, i = e?.bufferLength ?? gt, o = t.allocUI32(i * r);
-      k(this.firstBlock.data, p, o.bufferPosition, o.bufferByteOffset), this.bufferLength = i;
-      const a = e?.type ?? Uint32Array;
-      a === Uint32Array ? this.type = 0 : a === Int32Array ? this.type = 1 : a === Float32Array && (this.type = 2), this.dataLength = r;
-    }
-    this.cachedPointer = this.firstBlock.data[0], this.cachedFullDataBlock = this.getFullDataBlock();
-  }
-  at(t) {
-    let e = this.length;
-    if (t >= e || t < 0)
-      throw new Error(`${t} is out of bounds ${e}`);
-    let r = this.getFullDataBlock();
-    return this.getDataBlock(r, t);
-  }
-  get(t, e = 0) {
-    if (e >= this.dataLength)
-      throw new Error(`${e} is out of dataLength bounds ${this.dataLength}`);
-    if (t >= this.length || t < 0)
-      throw new Error(`${t} is out of bounds ${this.length}`);
-    return this.getFullDataBlock()[t * this.dataLength + e];
-  }
-  push(t) {
-    let e = this.dataLength;
-    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 i = this.getFullDataBlock(), o = this.length, a = e * o;
-    return r ? i[a] = t : i.set(t, a), Atomics.add(this.firstBlock.data, E, 1) + 1 >= this.bufferLength && this.growBuffer(), o;
-  }
-  pop() {
-    let t = Atomics.sub(this.firstBlock.data, E, 1), 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, E, 1);
-    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, i = this.getFullDataBlock();
-    for (let o = t; o < e; o++)
-      for (let a = 0; a < r; a++)
-        i[o * r + a] = i[(o + 1) * r + a];
-    Atomics.sub(this.firstBlock.data, E, 1);
-  }
-  clear() {
-    this.firstBlock.data[E] = 0;
-  }
-  *[Symbol.iterator]() {
-    let t = this.getFullDataBlock(), e = this.dataLength, r = this.length * e;
-    for (let i = 0; i < r; i += e)
-      yield t.subarray(i, i + 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, p);
-    if (this.cachedPointer === t && this.cachedFullDataBlock)
-      return this.cachedFullDataBlock;
-    let e = y(t), r = new f(this.memory, e), i;
-    switch (this.type) {
-      case 1:
-        i = new Int32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
-        break;
-      case 0:
-        i = new Uint32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
-        break;
-      case 2:
-        i = new Float32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
-        break;
-      default:
-        throw new Error(`Unknown data block type ${this.type}`);
-    }
-    return this.cachedPointer = t, this.cachedFullDataBlock = i, i;
-  }
-  getDataBlock(t, e) {
-    const r = e * this.dataLength;
-    return t.subarray(r, r + this.dataLength);
-  }
-  growBuffer() {
-    let e = this.bufferLength * 2, r = this.dataLength, i = c(this.firstBlock.data, p), o = new f(this.memory, i), a = this.getFullDataBlock(), n = this.memory.allocUI32(e * r), l;
-    switch (this.type) {
-      case 1:
-        l = new Int32Array(n.data.buffer, n.bufferByteOffset, r * e);
-        break;
-      case 0:
-        l = new Uint32Array(n.data.buffer, n.bufferByteOffset, r * e);
-        break;
-      case 2:
-        l = new Float32Array(n.data.buffer, n.bufferByteOffset, r * e);
-        break;
-      default:
-        throw new Error(`Unknown data block type ${this.type}`);
-    }
-    l.set(a);
-    const h = n.pointer;
-    U(this.firstBlock.data, p, h), this.bufferLength = e, o.free(), this.cachedPointer = h, this.cachedFullDataBlock = l;
-  }
-  free() {
-    let t = c(this.firstBlock.data, p);
-    new f(this.memory, t).free(), this.firstBlock.free();
-  }
-  getSharedMemory() {
-    return {
-      firstBlock: this.firstBlock.getSharedMemory()
-    };
-  }
-}
-class oe {
-  static ALLOCATE_COUNT = u.ALLOCATE_COUNT;
-  heap;
-  list;
-  cache = /* @__PURE__ */ new Map();
-  constructor(t, e) {
-    e ? this.list = new u(t, e) : this.list = new u(t), this.heap = t, this.list.onDelete = (r) => {
-      let i = Atomics.load(r, 0);
-      if (i) {
-        let o = this.cache.get(i);
-        o || (o = this.initItem(i)), o && (o.free(), this.cache.delete(i));
-      }
-    };
-  }
-  get length() {
-    return this.list.length;
-  }
-  clear() {
-    this.list.clear(), this.cache.clear();
-  }
-  insert(t) {
-    this.list.insert(t.pointer), this.cache.set(t.pointer, t);
-  }
-  delete(t) {
-    return this.cache.delete(t.pointer), this.list.deleteValue(t.pointer);
-  }
-  getByPointer(t) {
-    let e = this.cache.get(t);
-    return e || (e = this.initItem(t), e && this.cache.set(t, e)), e;
-  }
-  *[Symbol.iterator]() {
-    let t = this.list[Symbol.iterator]();
-    for (let { data: e, deleteCurrent: r } of t) {
-      let i = Atomics.load(e, 0);
-      if (!i)
-        continue;
-      let o = this.cache.get(i);
-      o || (o = this.initItem(i), o && this.cache.set(i, o)), o && (yield {
-        item: o,
-        deleteCurrent: r
-      });
-    }
-  }
-  forEach(t, e) {
-    for (let { item: r } of this)
-      (!e || e(r)) && t(r);
-  }
-  find(t) {
-    for (let { item: e } of this)
-      if (t(e))
-        return e;
-  }
-  filter(t) {
-    let e = [];
-    for (let { item: r } of this)
-      t(r) && e.push(r);
-    return e;
-  }
-  map(t) {
-    const e = [];
-    for (let { item: r } of this)
-      e.push(t(r));
-    return e;
-  }
-  getSharedMemory() {
-    return this.list.getSharedMemory();
-  }
-  free() {
-    this.list.free(), this.cache.clear();
-  }
-}
-const P = 0, At = 1, pt = 2, v = 3, Et = v + m.ALLOCATE_COUNT;
-class St {
-  static ALLOCATE_COUNT = 3 + m.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, P) - 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;
-  }
-  get recycleBufferLength() {
-    return this.recycleVector.bufferLength;
-  }
-  get byteMultipler() {
-    return this.type === 3 ? 2 : 1;
-  }
-  constructor(t, e) {
-    if (this.memory = t, e && "firstBlock" in e)
-      this.firstBlock = new f(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + At * Uint32Array.BYTES_PER_ELEMENT, 2), this.pointerVector = new m(t, {
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + v * Uint32Array.BYTES_PER_ELEMENT
-        }
-      }), this.recycleVector = new m(t, {
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + Et * Uint32Array.BYTES_PER_ELEMENT
-        }
-      });
-    else {
-      this.firstBlock = t.allocUI32(St.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + At * Uint32Array.BYTES_PER_ELEMENT, 2);
-      let r = e?.dataLength ?? 1, i = e?.maxChunkSize ?? 100;
-      this.pointerVector = new m(t, {
-        type: Uint32Array,
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + v * Uint32Array.BYTES_PER_ELEMENT
-        }
-      }), this.recycleVector = new m(t, {
-        type: Uint32Array,
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + Et * 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 = i;
-      let a = t.allocUI32(i * r * this.byteMultipler);
-      this.pointerVector.push(a.pointer);
-    }
-  }
-  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.popNumber() : r = Atomics.add(this.firstBlock.data, P, 1);
-    let i = this.getFullDataBlock(r), o = r % this.maxChunkSize;
-    return i.set(t, e * o), r;
-  }
-  deleteIndex(t) {
-    this.recycleVector.push(t);
-  }
-  clear() {
-    this.firstBlock.data[P] = 0, this.recycleVector.clear();
-  }
-  *[Symbol.iterator]() {
-    const t = {};
-    for (let i of this.recycleVector)
-      t[i[0]] = !0;
-    let e = this.getFullDataBlock(0), r = 0;
-    for (let i = 0; i < Atomics.load(this.firstBlock.data, P); i++)
-      if (!t[i]) {
-        let o = Math.floor(i / this.maxChunkSize);
-        o !== r && (e = this.getFullDataBlock(i), r = o), yield this.getDataBlock(e, i % this.maxChunkSize);
-      }
-  }
-  getFullDataBlock(t) {
-    let e = Math.floor(t / this.maxChunkSize), r = this.cachedFullDataBlock[e];
-    if (r)
-      return r;
-    if (e >= this.pointerVector.length) {
-      let a = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
-      this.pointerVector.push(a.pointer);
-    }
-    let i = new f(this.memory, y(this.pointerVector.get(e))), o;
-    switch (this.type) {
-      case 1:
-        o = new Int32Array(i.data.buffer, i.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      case 0:
-        o = new Uint32Array(i.data.buffer, i.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      case 2:
-        o = new Float32Array(i.data.buffer, i.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      case 3:
-        o = new Float64Array(i.data.buffer, i.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      default:
-        throw new Error(`Unknown data block type ${this.type}`);
-    }
-    return this.cachedFullDataBlock[e] = o, o;
-  }
-  getDataBlock(t, e) {
-    const r = e * this.dataLength;
-    return t.subarray(r, r + this.dataLength);
-  }
-  free() {
-    this.recycleVector.free();
-    for (let t of this.pointerVector) {
-      let e = t[0];
-      new f(this.memory, y(e)).free();
-    }
-    this.pointerVector.free(), this.firstBlock.free();
-  }
-  getSharedMemory() {
-    return {
-      firstBlock: this.firstBlock.getSharedMemory()
-    };
-  }
-}
-class ae {
-  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, i = e?.maxChunkSize ?? 100;
-    this.dataLength = r, this.maxChunkSize = i, this.typeConstructor = e.type, this.typeConstructor === Float64Array && (this.byteMultipler = 2);
-    let o = t.allocUI32(i * 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 i = Math.floor(r / this.maxChunkSize);
-    if (i >= this.pointers.length) {
-      let l = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
-      this.pointers.push(l.pointer);
-      let h = new this.typeConstructor(l.data.buffer, l.bufferByteOffset, this.dataLength * this.maxChunkSize);
-      this.fullDataBlocks[i] = h;
-    }
-    let o = this.fullDataBlocks[i], a = r % this.maxChunkSize, n = this.dataLength * a;
-    return e ? o[n] = t : o.set(t, n), r;
-  }
-  deleteIndex(t) {
-    this.recycledIndexes.push(t);
-  }
-  clear() {
-    this.totalLength = 0, this.recycledIndexes = [];
-  }
-  *[Symbol.iterator]() {
-    const t = {};
-    for (let i of this.recycledIndexes)
-      t[i] = !0;
-    let e = this.getFullDataBlock(0), r = 0;
-    for (let i = 0; i < this.totalLength; i++)
-      if (!t[i]) {
-        let o = Math.floor(i / this.maxChunkSize);
-        o !== r && (e = this.getFullDataBlock(i), r = o), yield this.getDataBlock(e, i % this.maxChunkSize);
-      }
-  }
-  getFullDataBlock(t) {
-    let e = Math.floor(t / this.maxChunkSize), r = this.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 i = new f(this.memory, y(this.pointers[e])), o = new this.typeConstructor(i.data.buffer, i.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 f(this.memory, y(t)).free();
-    this.pointers = [], this.recycledIndexes = [], this.totalLength = 0, this.fullDataBlocks = {};
-  }
-}
-const Tt = new ArrayBuffer(4), Ot = new Uint32Array(Tt), F = new Uint16Array(Tt);
-function ne(s, t) {
-  return qt(Atomics.load(s, t));
-}
-function le(s, t, e, r) {
-  Atomics.store(s, t, Jt(e, r));
-}
-function qt(s) {
-  return Ot[0] = s, [F[0], F[1]];
-}
-function Jt(s, t) {
-  return F[0] = s, F[1] = t, Ot[0];
-}
-const _t = new ArrayBuffer(8), Ct = new BigUint64Array(_t), B = new Uint16Array(_t);
-function fe(s, t) {
-  return Ct[0] = Atomics.load(s, t), [B[0], B[1], B[2], B[3]];
-}
-function he(s, t, e, r, i, o = 0) {
-  B[0] = e, B[1] = r, B[2] = i, B[3] = o, Atomics.store(s, t, Ct[0]);
-}
-const It = new ArrayBuffer(4), Mt = new Float32Array(It), Nt = new Int32Array(It);
-function Pt(s, t) {
-  return s instanceof Float32Array && (s = new Int32Array(s.buffer, s.byteOffset, s.length)), q(Atomics.load(s, t));
-}
-function ce(s, t, e) {
-  s instanceof Float32Array && (s = new Int32Array(s.buffer, s.byteOffset, s.length)), Atomics.store(s, t, z(e));
-}
-function q(s) {
-  return Nt[0] = s, Mt[0];
-}
-function z(s) {
-  return Mt[0] = s, Nt[0];
-}
-function ue(s, t, e) {
-  return s instanceof Float32Array && (s = new Int32Array(s.buffer, s.byteOffset, s.length)), q(Atomics.exchange(s, t, z(e)));
-}
-function Ut(s, t, e, r) {
-  return s instanceof Float32Array && (s = new Int32Array(s.buffer, s.byteOffset, s.length)), q(Atomics.compareExchange(s, t, z(e), z(r)));
-}
-function de(s, t, e, r) {
-  let i, o;
-  do
-    i = Atomics.load(s, t), o = Math.min(i + e, r);
-  while (Atomics.compareExchange(s, t, i, o) !== i);
-  return o;
-}
-function ye(s, t, e, r) {
-  let i, o;
-  do
-    i = Atomics.load(s, t), o = Math.max(i - e, r);
-  while (Atomics.compareExchange(s, t, i, o) !== i);
-  return o;
-}
-function me(s, t, e, r) {
-  let i, o;
-  do
-    i = Pt(s, t), o = Math.min(i + e, r);
-  while (Ut(s, t, i, o) !== i);
-  return o;
-}
-function Be(s, t, e, r) {
-  let i, o;
-  do
-    i = Pt(s, t), o = Math.max(i - e, r);
-  while (Ut(s, t, i, o) !== i);
-  return o;
-}
-const Dt = new ArrayBuffer(8), xt = new Float64Array(Dt), Ft = new BigInt64Array(Dt);
-function be(s, t) {
-  return s instanceof Float64Array && (s = new BigInt64Array(s.buffer, s.byteOffset, s.length)), J(Atomics.load(s, t));
-}
-function ke(s, t, e) {
-  s instanceof Float64Array && (s = new BigInt64Array(s.buffer, s.byteOffset, s.length)), Atomics.store(s, t, R(e));
-}
-function J(s) {
-  return Ft[0] = s, xt[0];
-}
-function R(s) {
-  return xt[0] = s, Ft[0];
-}
-function ge(s, t, e) {
-  return s instanceof Float64Array && (s = new BigInt64Array(s.buffer, s.byteOffset, s.length)), J(Atomics.exchange(s, t, R(e)));
-}
-function Ae(s, t, e, r) {
-  return s instanceof Float64Array && (s = new BigInt64Array(s.buffer, s.byteOffset, s.length)), J(Atomics.compareExchange(s, t, R(e), R(r)));
-}
-const w = 0, j = 1, S = 2;
-function pe(s, t = 0) {
-  for (; Atomics.compareExchange(s, t, w, j) === S; )
-    Atomics.wait(s, t, S);
-  Atomics.add(s, t + 1, 1);
-}
-function Ee(s, t = 0) {
-  let e = Atomics.compareExchange(s, t, w, S);
-  for (; e !== w; )
-    Atomics.wait(s, t, e), e = Atomics.compareExchange(s, t, w, S);
-}
-function we(s, t = 0) {
-  Atomics.sub(s, t + 1, 1) - 1 <= 0 && (Atomics.compareExchange(s, t, j, w) !== j && console.warn("We are unlocking when it was not read locked!"), Atomics.notify(s, t));
-}
-function Le(s, t = 0) {
-  Atomics.compareExchange(s, t, S, w) !== S && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(s, t);
-}
-const Se = 2;
-export {
-  f as AllocatedMemory,
-  Qt as BYTE_OFFSET_BIT_COUNT,
-  oe as CachedItemList,
-  ae as LocalPool,
-  tt as MAX_BYTE_OFFSET_LENGTH,
-  et as MAX_POSITION_LENGTH,
-  G as MemoryBuffer,
-  ie as MemoryHeap,
-  te as POSITION_BIT_COUNT,
-  Se as READ_WRITE_LOCK_ALLOCATE_COUNT,
-  re as SIMPLE_LOCK_ALLOCATE_COUNT,
-  u as SharedList,
-  wt as SharedMap,
-  se as SharedPointerList,
-  St as SharedPool,
-  Lt as SharedString,
-  m as SharedVector,
-  me as addAtomicFloat32,
-  de as addAtomicInt,
-  Ut as compareExchangeFloat32,
-  Ae as compareExchangeFloat64,
-  Jt as convert16To32,
-  qt as convert32To16,
-  z as convertFloat32ToInt32,
-  R as convertFloat64ToInt64,
-  q as convertInt32ToFloat32,
-  J as convertInt64ToFloat64,
-  L as createPointer,
-  ue as exchangeFloat32,
-  ge as exchangeFloat64,
-  y as getPointer,
-  ne as load16From32,
-  fe as load16From64,
-  Pt as loadFloat32,
-  be as loadFloat64,
-  c as loadPointer,
-  O as loadRawPointer,
-  x as lock,
-  pe as readLock,
-  we as readUnlock,
-  ee as replacePointer,
-  H as replaceRawPointer,
-  le as store16In32,
-  he as store16In64,
-  ce as storeFloat32,
-  ke as storeFloat64,
-  k as storePointer,
-  U as storeRawPointer,
-  Be as subtractAtomicFloat,
-  ye as subtractAtomicInt,
-  b as unlock,
-  Ee as writeLock,
-  Le as writeUnlock
-};
-//# sourceMappingURL=shared-memory-objects.js.map