@daneren2005/shared-memory-objects 0.0.21 → 1.1.0

package/dist/shared-memory-objects.js

@@ -1,1674 +0,0 @@
-const he = 20, ce = 12, et = Math.pow(2, 20), rt = Math.pow(2, 12);
-function c(i, t = 0) {
-  return B(Atomics.load(i, t));
-}
-function O(i, t = 0) {
-  return Atomics.load(i, t);
-}
-function k(i, t = 0, e, r) {
-  Atomics.store(i, t, L(e, r));
-}
-function x(i, t = 0, e) {
-  Atomics.store(i, t, e);
-}
-function ue(i, t, e, r, s, o) {
-  let a = L(s, o);
-  return Atomics.compareExchange(i, t, a, L(e, r)) === a;
-}
-function V(i, t, e, r) {
-  return Atomics.compareExchange(i, t, r, e) === r;
-}
-function B(i) {
-  return {
-    bufferPosition: i & 4095,
-    bufferByteOffset: i >>> 12
-  };
-}
-function L(i, t) {
-  return i + (t << 12);
-}
-class h {
-  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 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 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 de = 1, Vt = {
-  5120: "i8",
-  5121: "u8",
-  5122: "i16",
-  5123: "u16",
-  5124: "i32",
-  5125: "u32",
-  5126: "f32"
-}, Kt = {
-  f32: Float32Array,
-  f64: Float64Array
-}, Gt = {
-  i8: Int8Array,
-  i16: Int16Array,
-  i32: Int32Array
-}, Xt = {
-  u8: Uint8Array,
-  u8c: Uint8ClampedArray,
-  u16: Uint16Array,
-  u32: Uint32Array
-}, Zt = {
-  i64: BigInt64Array,
-  u64: BigUint64Array
-}, Wt = {
-  ...Kt,
-  ...Gt,
-  ...Xt
-}, vt = (i) => {
-  const t = Vt[i];
-  return t !== void 0 ? t : i;
-};
-function jt(i, ...t) {
-  const e = Zt[i];
-  return new (e || Wt[vt(i)])(...t);
-}
-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;
-  u32;
-  state;
-  lock;
-  constructor(t = {}) {
-    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`);
-      const r = this.initialTop(e), s = t.end != null ? Math.min(t.end, this.buf.byteLength) : this.buf.byteLength;
-      if (r >= s)
-        throw new Error(
-          `insufficient address range (0x${this.start.toString(
-            16
-          )} - 0x${s.toString(16)})`
-        );
-      this.align = e, this.doCompact = t.compact !== !1, this.doSplit = t.split !== !1, this.minSplit = t.minSplit || 16, this.end = s, this.top = r, this._free = 0, this._used = 0;
-    }
-  }
-  stats() {
-    const t = (r) => {
-      let s = 0, o = 0;
-      for (; r; )
-        if (s++, 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: s, 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 s = this.mallocAs(t, e);
-    return s && s.fill(r), s;
-  }
-  mallocAs(t, e) {
-    const r = this.malloc(e * qt[t]);
-    return r ? jt(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;
-    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 l = this.blockSize(o), n = o + l >= s;
-      if (n || l >= e) {
-        let f = this.mallocTop(
-          o,
-          a,
-          l,
-          e,
-          n
-        );
-        return g(this.lock), f;
-      }
-      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 l = _(o);
-      return g(this.lock), l;
-    }
-    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 a = r - s;
-      a >= this.minSplit && this.splitBlock(t, s, a);
-    }
-    return _(t);
-  }
-  realloc(t, e) {
-    if (e <= 0)
-      return 0;
-    const r = C(t);
-    let s = 0, o = this._used, a = 0;
-    for (; o; ) {
-      if (o === r) {
-        [s, a] = this.reallocBlock(o, e);
-        break;
-      }
-      o = this.blockNext(o);
-    }
-    return s && s !== r && this.u8.copyWithin(
-      _(s),
-      _(r),
-      a
-    ), _(s);
-  }
-  reallocBlock(t, e) {
-    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 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 + 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)
-      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 = C(e);
-    let r = this._used;
-    for (; r; ) {
-      if (r === e)
-        return this.blockSize(e) - y;
-      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;
-    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(), g(this.lock), !0;
-      s = r, r = this.blockNext(r);
-    }
-    return g(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[nt];
-  }
-  set align(t) {
-    this.state[nt] = t;
-  }
-  get end() {
-    return this.state[at];
-  }
-  set end(t) {
-    this.state[at] = t;
-  }
-  get top() {
-    return Atomics.load(this.state, ot);
-  }
-  set top(t) {
-    Atomics.store(this.state, ot, t);
-  }
-  get _free() {
-    return Atomics.load(this.state, it);
-  }
-  set _free(t) {
-    Atomics.store(this.state, it, t);
-  }
-  get _used() {
-    return Atomics.load(this.state, st);
-  }
-  set _used(t) {
-    Atomics.store(this.state, st, t);
-  }
-  get doCompact() {
-    return !!(this.state[A] & K);
-  }
-  set doCompact(t) {
-    t ? this.state[A] |= 1 << K - 1 : this.state[A] &= ~K;
-  }
-  get doSplit() {
-    return !!(this.state[A] & G);
-  }
-  set doSplit(t) {
-    t ? this.state[A] |= 1 << G - 1 : this.state[A] &= ~G;
-  }
-  get minSplit() {
-    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[lt] = t;
-  }
-  blockSize(t) {
-    return Atomics.load(this.u32, (t >> 2) + X);
-  }
-  /**
-   * Sets & returns given block size.
-   *
-   * @param block -
-   * @param size -
-   */
-  setBlockSize(t, e) {
-    return Atomics.store(this.u32, (t >> 2) + X, e), e;
-  }
-  blockNext(t) {
-    return Atomics.load(this.u32, (t >> 2) + Z);
-  }
-  /**
-   * Sets block next pointer to `next`. Use zero to indicate list end.
-   *
-   * @param block -
-   */
-  setBlockNext(t, e) {
-    Atomics.store(this.u32, (t >> 2) + Z, e);
-  }
-  /**
-   * Initializes block header with given `size` and `next` pointer. Returns `block`.
-   *
-   * @param block -
-   * @param size -
-   * @param next -
-   */
-  initBlock(t, e, r) {
-    const s = t >>> 2;
-    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));
-  }
-  splitBlock(t, e, r) {
-    this.insert(
-      this.initBlock(
-        t + this.setBlockSize(t, e),
-        r,
-        0
-      )
-    ), this.doCompact && this.compact();
-  }
-  initialTop(t = this.align) {
-    return I(this.start + ft + y, t) - y;
-  }
-  /**
-   * 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, s, o = !1;
-    for (; t; ) {
-      for (s = t, r = this.blockNext(t); r && s + this.blockSize(s) === r; )
-        s = r, r = this.blockNext(r);
-      if (s !== t) {
-        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, 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);
-    }
-    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 _ = (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,
-  u16: 2,
-  i16: 2,
-  u32: 4,
-  i32: 4,
-  i64: 8,
-  u64: 8,
-  f32: 4,
-  f64: 8
-}, Jt = [
-  "B",
-  "kB",
-  "MB",
-  "GB",
-  "TB",
-  "PB",
-  "EB",
-  "ZB",
-  "YB"
-], Qt = [
-  "B",
-  "KiB",
-  "MiB",
-  "GiB",
-  "TiB",
-  "PiB",
-  "EiB",
-  "ZiB",
-  "YiB"
-], te = [
-  "b",
-  "kbit",
-  "Mbit",
-  "Gbit",
-  "Tbit",
-  "Pbit",
-  "Ebit",
-  "Zbit",
-  "Ybit"
-], ee = [
-  "b",
-  "kibit",
-  "Mibit",
-  "Gibit",
-  "Tibit",
-  "Pibit",
-  "Eibit",
-  "Zibit",
-  "Yibit"
-], ht = (i, t, e) => {
-  let r = i;
-  return typeof t == "string" || Array.isArray(t) ? r = i.toLocaleString(t, e) : (t === !0 || e !== void 0) && (r = i.toLocaleString(void 0, e)), r;
-}, _t = (i) => {
-  if (typeof i == "number")
-    return Math.log10(i);
-  const t = i.toString(10);
-  return t.length + Math.log10(`0.${t.slice(0, 15)}`);
-}, re = (i) => typeof i == "number" ? Math.log(i) : _t(i) * Math.log(10), ie = (i, t) => {
-  if (typeof i == "number")
-    return i / t;
-  const e = i / BigInt(t), r = i % BigInt(t);
-  return Number(e) + Number(r) / t;
-}, ct = (i, t) => {
-  if (t === void 0)
-    return i;
-  if (typeof t != "number" || !Number.isSafeInteger(t) || t < 0)
-    throw new TypeError(`Expected fixedWidth to be a non-negative integer, got ${typeof t}: ${t}`);
-  return t === 0 ? i : i.length < t ? i.padStart(t, " ") : i;
-}, se = (i) => {
-  const { minimumFractionDigits: t, maximumFractionDigits: e } = i;
-  if (!(t === void 0 && e === void 0))
-    return {
-      ...t !== void 0 && { minimumFractionDigits: t },
-      ...e !== void 0 && { maximumFractionDigits: e },
-      roundingMode: "trunc"
-    };
-};
-function oe(i, t) {
-  if (typeof i != "bigint" && !Number.isFinite(i))
-    throw new TypeError(`Expected a finite number, got ${typeof i}: ${i}`);
-  t = {
-    bits: !1,
-    binary: !1,
-    space: !0,
-    nonBreakingSpace: !1,
-    ...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 f = ` 0${r}${e[0]}`;
-    return ct(f, t.fixedWidth);
-  }
-  const o = i < 0, a = o ? "-" : t.signed ? "+" : "";
-  o && (i = -i);
-  const l = se(t);
-  let n;
-  if (i < 1) {
-    const f = ht(i, t.locale, l);
-    n = a + f + r + e[0];
-  } else {
-    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 T = ht(Number(i), t.locale, l), H = e[f];
-    n = a + T + r + H;
-  }
-  return ct(n, t.fixedWidth);
-}
-const ae = 8192, ut = 0, v = 1, N = 2;
-class ye {
-  buffers;
-  onGrowBufferHandlers = [];
-  isClone;
-  memory;
-  get bufferSize() {
-    return this.memory.data[ut];
-  }
-  constructor(t) {
-    if (t && "buffers" in t)
-      this.buffers = t.buffers.map((e) => new W({
-        buf: e,
-        skipInitialization: !0
-      })), this.memory = new h(this, {
-        bufferPosition: 0,
-        bufferByteOffset: 40
-      }), this.isClone = !0;
-    else {
-      "SharedArrayBuffer" in globalThis || console.warn("SharedArrayBuffer is not working: falling back to ArrayBuffer");
-      const e = t?.bufferSize ?? 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);
-      this.buffers = [
-        r
-      ];
-      const s = r.callocAs("u32", 3);
-      if (s)
-        this.memory = new h(this, {
-          bufferPosition: 0,
-          bufferByteOffset: s.byteOffset
-        });
-      else
-        throw new Error("Failed to initialize first byte from buffer");
-      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 W({
-      buf: t.buffer,
-      skipInitialization: !0
-    });
-  }
-  growBuffer() {
-    const t = this.createBuffer();
-    let e = Atomics.add(this.memory.data, v, 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 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
-      // 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 s = 0; s < this.buffers.length; s++) {
-      const o = this.buffers[s];
-      if (!o)
-        continue;
-      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
-        });
-    }
-    if (this.buffers.length >= rt)
-      throw new Error(`Can't initialize a new buffer since it would have a position greater than the max of ${rt}`);
-    let e = this.growBuffer();
-    const r = e.callocAs("u32", t);
-    if (r)
-      return new h(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 h(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;
-  }
-  prettyMemory() {
-    return `${dt(this.currentUsed)} / ${dt(this.totalAllocated)}`;
-  }
-  getSharedMemory() {
-    return {
-      buffers: this.buffers.map((t) => t.buf)
-    };
-  }
-}
-function dt(i) {
-  return oe(i, {
-    binary: !0,
-    minimumFractionDigits: 1,
-    maximumFractionDigits: 1
-  });
-}
-const yt = 4, Bt = 1, p = 2;
-class u {
-  static ALLOCATE_COUNT = yt;
-  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, p);
-  }
-  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 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(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;
-    }
-  }
-  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(Bt + e), s = this.getDataBlock(r.data), o = r.pointer;
-    for (let n = 0; n < t.length; n++)
-      s instanceof Int32Array || s instanceof Uint32Array ? Atomics.store(s, n, t[n]) : s[n] = t[n];
-    let a, 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
-      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)
-      if (t(e, r))
-        return s(), !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 = V(this.firstBlock.data, 1, 0, e);
-    }
-    if (!t)
-      return;
-    V(this.firstBlock.data, 0, 0, t);
-    let s = 0, o = t;
-    for (; o; ) {
-      let { bufferPosition: a, bufferByteOffset: l } = B(o), n = this.memory.buffers[a];
-      if (!n)
-        break;
-      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, p, s);
-  }
-  *[Symbol.iterator]() {
-    let t = 0, { bufferPosition: e, bufferByteOffset: r } = c(this.firstBlock.data, 0), s = this.firstBlock.data, o = 0, a = 0;
-    for (; r; ) {
-      let l = this.memory.buffers[e];
-      if (!l)
-        return;
-      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: f,
-        index: t,
-        deleteCurrent: () => {
-          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 = n, o = T, a = H, t++);
-    }
-  }
-  forEach(t) {
-    for (let e of this)
-      t(e.data);
-  }
-  getSharedMemory() {
-    return {
-      firstBlock: this.firstBlock.getSharedMemory()
-    };
-  }
-  getDataBlock(t) {
-    const e = t.byteOffset + Bt * 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 h(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 mt = 10;
-class Ot {
-  static ALLOCATE_COUNT = 4;
-  memory;
-  // Memory order: Pointer, Lock, Length, MaxHash
-  pointerMemory;
-  lock;
-  get hashMemory() {
-    return new h(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 h(t, e.firstBlock);
-    else {
-      this.pointerMemory = t.allocUI32(Ot.ALLOCATE_COUNT);
-      let r = t.allocUI32(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 = 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), a, l = c(t.data, o);
-    if (l.bufferByteOffset === 0) {
-      a = new u(this.memory, {
-        dataLength: 2
-      });
-      let f = a.getSharedMemory();
-      k(t.data, o, f.firstBlock.bufferPosition, f.firstBlock.bufferByteOffset);
-    } else
-      a = new u(this.memory, {
-        firstBlock: l
-      });
-    let n = !0;
-    return a.deleteValue(r) && (n = !1), a.insert([r, s]), n;
-  }
-  get(t) {
-    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: a } of o)
-      if (a[0] === e)
-        return a[1];
-  }
-  has(t) {
-    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: a } of o)
-      if (a[0] === e)
-        return !0;
-    return !1;
-  }
-  delete(t) {
-    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: 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 a = c(s.data, o);
-      if (a.bufferByteOffset === 0)
-        continue;
-      let l = new u(this.memory, {
-        firstBlock: a
-      });
-      for (let { data: n } of l)
-        this.setHashKey(r, e, n[0], n[1]);
-    }
-    k(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, e);
-  }
-  hash(t, e) {
-    return t % e;
-  }
-  free() {
-    for (let t = 0; t < this.maxHash; t++) {
-      let e = 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 P(i) {
-  return typeof i == "number" ? i : typeof i == "string" ? ne(i) : 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;
-  switch (t) {
-    case 3:
-      e ^= (i.charCodeAt(r + 2) & 255) << 16;
-    case 2:
-      e ^= (i.charCodeAt(r + 1) & 255) << 8;
-    case 1:
-      e ^= i.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 Be {
-  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: s } = c(e, 0), o = new h(this.memory, {
-        bufferPosition: r,
-        bufferByteOffset: s
-      });
-      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 bt = {
-  1: Uint8Array,
-  2: Uint16Array
-}, U = 0, gt = 1, kt = 2, At = 3;
-class Mt {
-  static ALLOCATE_COUNT = 4;
-  memory;
-  allocatedMemory;
-  lock;
-  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 + 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);
-    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 === "")
-      return {
-        pointer: 0,
-        charType: 1
-        /* ASCII */
-      };
-    let e = [];
-    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: a.pointer,
-      charType: s
-    };
-  }
-  get value() {
-    let t = O(this.allocatedMemory.data, U);
-    if (this.cachedPointer === t && this.cachedString !== void 0)
-      return this.cachedString;
-    if (t === 0)
-      return "";
-    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);
-    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, U);
-    e && this.memory.buffers[t].free(e), this.allocatedMemory.free();
-  }
-}
-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, d);
-  }
-  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, pt);
-  }
-  set bufferLength(t) {
-    Atomics.store(this.firstBlock.data, pt, t);
-  }
-  get pointer() {
-    return this.firstBlock.pointer;
-  }
-  cachedFullDataBlock;
-  cachedPointer;
-  constructor(t, e) {
-    if (this.memory = t, e && "firstBlock" in e) {
-      if (this.firstBlock = new h(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + 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));
-        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(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();
-  }
-  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 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, 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 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[d] = 0;
-  }
-  *[Symbol.iterator]() {
-    let t = this.getFullDataBlock(), e = this.dataLength, r = this.length * e;
-    for (let s = 0; s < r; s += e)
-      yield t.subarray(s, s + 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, E);
-    if (this.cachedPointer === t && this.cachedFullDataBlock)
-      return this.cachedFullDataBlock;
-    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);
-        break;
-      case 0:
-        s = new Uint32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
-        break;
-      case 2:
-        s = 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 = s, s;
-  }
-  getDataBlock(t, e) {
-    const r = e * this.dataLength;
-    return t.subarray(r, r + this.dataLength);
-  }
-  growBuffer() {
-    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:
-        n = new Int32Array(l.data.buffer, l.bufferByteOffset, r * e);
-        break;
-      case 0:
-        n = new Uint32Array(l.data.buffer, l.bufferByteOffset, r * e);
-        break;
-      case 2:
-        n = new Float32Array(l.data.buffer, l.bufferByteOffset, r * e);
-        break;
-      default:
-        throw new Error(`Unknown data block type ${this.type}`);
-    }
-    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, E);
-    new h(this.memory, t).free(), this.firstBlock.free();
-  }
-  getSharedMemory() {
-    return {
-      firstBlock: this.firstBlock.getSharedMemory()
-    };
-  }
-}
-class me {
-  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 s = Atomics.load(r, 0);
-      if (s) {
-        let o = this.cache.get(s);
-        o || (o = this.initItem(s)), o && (o.free(), this.cache.delete(s));
-      }
-    };
-  }
-  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 s = Atomics.load(e, 0);
-      if (!s)
-        continue;
-      let o = this.cache.get(s);
-      o || (o = this.initItem(s), o && this.cache.set(s, 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 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;
-  uint16Array;
-  pointerVector;
-  recycleVector;
-  cachedFullDataBlock = {};
-  get length() {
-    return Atomics.load(this.firstBlock.data, D) - this.recycleVector.length;
-  }
-  get maxChunkSize() {
-    return this.firstBlock.data[St];
-  }
-  set maxChunkSize(t) {
-    Atomics.store(this.firstBlock.data, St, 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 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 m(t, {
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + Tt * Uint32Array.BYTES_PER_ELEMENT
-        }
-      });
-    else {
-      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 m(t, {
-        type: Uint32Array,
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          bufferByteOffset: this.firstBlock.bufferByteOffset + q * Uint32Array.BYTES_PER_ELEMENT
-        }
-      }), this.recycleVector = new m(t, {
-        type: Uint32Array,
-        firstBlock: {
-          bufferPosition: this.firstBlock.bufferPosition,
-          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 a = t.allocUI32(s * 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, D, 1);
-    let s = this.getFullDataBlock(r), o = r % this.maxChunkSize;
-    return s.set(t, e * o), r;
-  }
-  deleteIndex(t) {
-    this.recycleVector.push(t);
-  }
-  clear() {
-    this.firstBlock.data[D] = 0, 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, 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);
-      }
-  }
-  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 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);
-        break;
-      case 0:
-        o = new Uint32Array(s.data.buffer, s.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      case 2:
-        o = new Float32Array(s.data.buffer, s.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      case 3:
-        o = new Float64Array(s.data.buffer, s.bufferByteOffset, this.dataLength * this.maxChunkSize);
-        break;
-      default:
-        throw new Error(`Unknown data block type ${this.type}`);
-    }
-    return this.cachedFullDataBlock[e] = o, o;
-  }
-  getDataBlock(t, e) {
-    const r = e * this.dataLength;
-    return t.subarray(r, r + this.dataLength);
-  }
-  free() {
-    this.recycleVector.free();
-    for (let t of this.pointerVector) {
-      let e = t[0];
-      new h(this.memory, B(e)).free();
-    }
-    this.pointerVector.free(), this.firstBlock.free();
-  }
-  getSharedMemory() {
-    return {
-      firstBlock: this.firstBlock.getSharedMemory()
-    };
-  }
-}
-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 ke(i, t, e, r) {
-  Atomics.store(i, t, fe(e, r));
-}
-function le(i) {
-  return Nt[0] = i, [R[0], R[1]];
-}
-function fe(i, t) {
-  return R[0] = i, R[1] = t, Nt[0];
-}
-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 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 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 Ft[0] = i, xt[0];
-}
-function $(i) {
-  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 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 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 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 Te(i, t, e, r) {
-  let s, o;
-  do
-    s = zt(i, t), o = Math.min(s + e, r);
-  while (Rt(i, t, s, o) !== s);
-}
-function _e(i, t, e, r) {
-  let s, o;
-  do
-    s = zt(i, t), o = Math.max(s - e, r);
-  while (Rt(i, t, s, o) !== s);
-}
-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 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 Y(i) {
-  return Yt[0] = i, Ht[0];
-}
-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, Y(e), Y(r)));
-}
-const w = 0, J = 1, S = 2;
-function Ne(i, t = 0) {
-  for (; Atomics.compareExchange(i, t, w, J) === S; )
-    Atomics.wait(i, t, S);
-  Atomics.add(i, t + 1, 1);
-}
-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.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 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,
-  W as MemoryBuffer,
-  ye as MemoryHeap,
-  ce as POSITION_BIT_COUNT,
-  xe as READ_WRITE_LOCK_ALLOCATE_COUNT,
-  de as SIMPLE_LOCK_ALLOCATE_COUNT,
-  u as SharedList,
-  Ot as SharedMap,
-  Be as SharedPointerList,
-  Ct as SharedPool,
-  Mt as SharedString,
-  m as SharedVector,
-  Te as addAtomicFloat32,
-  Le as addAtomicInt,
-  Rt as compareExchangeFloat32,
-  Ie as compareExchangeFloat64,
-  fe as convert16To32,
-  le as convert32To16,
-  $ as convertFloat32ToInt32,
-  Y as convertFloat64ToInt64,
-  Q as convertInt32ToFloat32,
-  tt as convertInt64ToFloat64,
-  L as createPointer,
-  we as exchangeFloat32,
-  Ce as exchangeFloat64,
-  B as getPointer,
-  ge as load16From32,
-  Ae as load16From64,
-  zt as loadFloat32,
-  Oe as loadFloat64,
-  c as loadPointer,
-  O as loadRawPointer,
-  z as lock,
-  Ne as readLock,
-  Ue as readUnlock,
-  ue as replacePointer,
-  V as replaceRawPointer,
-  ke as store16In32,
-  pe as store16In64,
-  Ee as storeFloat32,
-  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