@daneren2005/shared-memory-objects 0.0.9 → 0.0.11

package/dist/shared-memory-objects.js

@@ -0,0 +1,1325 @@
+var Pt = Object.defineProperty;
+var Nt = (s, t, e) => t in s ? Pt(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var l = (s, t, e) => (Nt(s, typeof t != "symbol" ? t + "" : t, e), e);
+const Vt = 20, te = 12, q = Math.pow(2, 20), J = Math.pow(2, 12);
+function h(s, t = 0) {
+  return S(Atomics.load(s, t));
+}
+function O(s, t = 0) {
+  return Atomics.load(s, t);
+}
+function A(s, t = 0, e, r) {
+  Atomics.store(s, t, w(e, r));
+}
+function W(s, t = 0, e) {
+  Atomics.store(s, t, e);
+}
+function ee(s, t, e, r, i, o) {
+  let a = w(i, o);
+  return Atomics.compareExchange(s, t, a, w(e, r)) === a;
+}
+function $(s, t, e, r) {
+  return Atomics.compareExchange(s, t, r, e) === r;
+}
+function S(s) {
+  return {
+    bufferPosition: s & 4095,
+    bufferByteOffset: s >>> 12
+  };
+}
+function w(s, t) {
+  return s + (t << 12);
+}
+class c {
+  constructor(t, e) {
+    l(this, "memory");
+    l(this, "bufferPosition");
+    l(this, "buffer");
+    l(this, "data");
+    this.memory = t, "buffer" in e ? (this.data = e.data, this.buffer = e.buffer, this.bufferPosition = this.memory.buffers.indexOf(e.buffer)) : (this.bufferPosition = e.bufferPosition, this.buffer = t.buffers[e.bufferPosition], this.data = new Uint32Array(this.buffer.buf, e.bufferByteOffset));
+  }
+  get bufferByteOffset() {
+    return this.data.byteOffset;
+  }
+  get pointer() {
+    return w(this.bufferPosition, this.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 Z = 0, U = 1;
+function C(s, t = 0) {
+  for (; Atomics.compareExchange(s, t, Z, U) !== Z; )
+    "WorkerGlobalScope" in self && Atomics.wait(s, t, U);
+}
+function B(s, t = 0) {
+  Atomics.compareExchange(s, t, U, Z) !== U && console.warn("We are unlocking when it was not locked!"), Atomics.notify(s, t);
+}
+const re = 1, It = {
+  5120: "i8",
+  5121: "u8",
+  5122: "i16",
+  5123: "u16",
+  5124: "i32",
+  5125: "u32",
+  5126: "f32"
+}, Ut = {
+  f32: Float32Array,
+  f64: Float64Array
+}, Ct = {
+  i8: Int8Array,
+  i16: Int16Array,
+  i32: Int32Array
+}, Dt = {
+  u8: Uint8Array,
+  u8c: Uint8ClampedArray,
+  u16: Uint16Array,
+  u32: Uint32Array
+}, Ft = {
+  // eslint-disable-next-line
+  i64: BigInt64Array,
+  // eslint-disable-next-line
+  u64: BigUint64Array
+}, xt = {
+  ...Ut,
+  ...Ct,
+  ...Dt
+}, Rt = (s) => {
+  const t = It[s];
+  return t !== void 0 ? t : s;
+};
+function $t(s, ...t) {
+  const e = Ft[s];
+  return new (e || xt[Rt(s)])(...t);
+}
+const Q = 0, V = 1, tt = 2, et = 3, rt = 4, k = 5, it = 6, Y = 1, H = 2, st = 8 * 4, z = 0, K = 1, y = 2 * 4;
+class G {
+  constructor(t = {}) {
+    l(this, "buf");
+    l(this, "start");
+    l(this, "u8");
+    l(this, "u32");
+    l(this, "state");
+    l(this, "lock");
+    if (this.buf = t.buf ? t.buf : new ArrayBuffer(t.size || 4096), this.start = t.start != null ? M(Math.max(t.start, 0), 4) : 0, this.u8 = new Uint8Array(this.buf), this.u32 = new Uint32Array(this.buf), this.state = new Uint32Array(this.buf, this.start, st / 4), this.lock = new Int32Array(this.buf, this.start + this.state.byteLength - 4, 1), !t.skipInitialization) {
+      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 * Yt[t]);
+    return r ? $t(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;
+    C(this.lock);
+    const e = M(t + y, this.align), r = this.end;
+    let i = this.top, o = this._free, a = 0;
+    for (; o; ) {
+      const n = this.blockSize(o), f = o + n >= i;
+      if (f || n >= e) {
+        let u = this.mallocTop(
+          o,
+          a,
+          n,
+          e,
+          f
+        );
+        return B(this.lock), u;
+      }
+      a = o, o = this.blockNext(o);
+    }
+    if (o = i, i = o + e, i <= r) {
+      this.initBlock(o, e, this._used), this._used = o, this.top = i;
+      let n = _(o);
+      return B(this.lock), n;
+    }
+    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);
+  }
+  realloc(t, e) {
+    if (e <= 0)
+      return 0;
+    const r = L(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(
+      _(i),
+      _(r),
+      a
+    ), _(i);
+  }
+  reallocBlock(t, e) {
+    const r = this.blockSize(t), i = t + r, o = i >= this.top, a = M(e + y, 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), [L(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 = L(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;
+    C(this.lock), e = L(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[rt];
+  }
+  set align(t) {
+    this.state[rt] = t;
+  }
+  get end() {
+    return this.state[et];
+  }
+  set end(t) {
+    this.state[et] = t;
+  }
+  get top() {
+    return Atomics.load(this.state, tt);
+  }
+  set top(t) {
+    Atomics.store(this.state, tt, t);
+  }
+  get _free() {
+    return Atomics.load(this.state, Q);
+  }
+  set _free(t) {
+    Atomics.store(this.state, Q, t);
+  }
+  get _used() {
+    return Atomics.load(this.state, V);
+  }
+  set _used(t) {
+    Atomics.store(this.state, V, t);
+  }
+  get doCompact() {
+    return !!(this.state[k] & Y);
+  }
+  set doCompact(t) {
+    t ? this.state[k] |= 1 << Y - 1 : this.state[k] &= ~Y;
+  }
+  get doSplit() {
+    return !!(this.state[k] & H);
+  }
+  set doSplit(t) {
+    t ? this.state[k] |= 1 << H - 1 : this.state[k] &= ~H;
+  }
+  get minSplit() {
+    return this.state[it];
+  }
+  set minSplit(t) {
+    if (t <= y)
+      throw new Error(`illegal min split threshold: ${t}, require at least ${y + 1}`);
+    this.state[it] = t;
+  }
+  blockSize(t) {
+    return Atomics.load(this.u32, (t >> 2) + z);
+  }
+  /**
+   * Sets & returns given block size.
+   *
+   * @param block -
+   * @param size -
+   */
+  setBlockSize(t, e) {
+    return Atomics.store(this.u32, (t >> 2) + z, e), e;
+  }
+  blockNext(t) {
+    return Atomics.load(this.u32, (t >> 2) + K);
+  }
+  /**
+   * Sets block next pointer to `next`. Use zero to indicate list end.
+   *
+   * @param block -
+   */
+  setBlockNext(t, e) {
+    Atomics.store(this.u32, (t >> 2) + K, 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 + z, e), Atomics.store(this.u32, i + K, 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 M(this.start + st + 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, 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 f = this.blockNext(t);
+        for (; f && f !== n; ) {
+          const u = this.blockNext(f);
+          this.setBlockNext(f, 0), f = u;
+        }
+        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 _ = (s) => s > 0 ? s + y : 0, L = (s) => s > 0 ? s - y : 0, M = (s, t) => (t--, s + t & ~t), Yt = {
+  u8: 1,
+  u8c: 1,
+  i8: 1,
+  u16: 2,
+  i16: 2,
+  u32: 4,
+  i32: 4,
+  i64: 8,
+  u64: 8,
+  f32: 4,
+  f64: 8
+}, Ht = [
+  "B",
+  "kB",
+  "MB",
+  "GB",
+  "TB",
+  "PB",
+  "EB",
+  "ZB",
+  "YB"
+], zt = [
+  "B",
+  "KiB",
+  "MiB",
+  "GiB",
+  "TiB",
+  "PiB",
+  "EiB",
+  "ZiB",
+  "YiB"
+], Kt = [
+  "b",
+  "kbit",
+  "Mbit",
+  "Gbit",
+  "Tbit",
+  "Pbit",
+  "Ebit",
+  "Zbit",
+  "Ybit"
+], Gt = [
+  "b",
+  "kibit",
+  "Mibit",
+  "Gibit",
+  "Tibit",
+  "Pibit",
+  "Eibit",
+  "Zibit",
+  "Yibit"
+], ot = (s, t, e) => {
+  let r = s;
+  return typeof t == "string" || Array.isArray(t) ? r = s.toLocaleString(t, e) : (t === !0 || e !== void 0) && (r = s.toLocaleString(void 0, e)), r;
+};
+function Xt(s, t) {
+  if (!Number.isFinite(s))
+    throw new TypeError(`Expected a finite number, got ${typeof s}: ${s}`);
+  t = {
+    bits: !1,
+    binary: !1,
+    space: !0,
+    ...t
+  };
+  const e = t.bits ? t.binary ? Gt : Kt : t.binary ? zt : Ht, r = t.space ? " " : "";
+  if (t.signed && s === 0)
+    return ` 0${r}${e[0]}`;
+  const i = s < 0, o = i ? "-" : t.signed ? "+" : "";
+  i && (s = -s);
+  let a;
+  if (t.minimumFractionDigits !== void 0 && (a = { minimumFractionDigits: t.minimumFractionDigits }), t.maximumFractionDigits !== void 0 && (a = { maximumFractionDigits: t.maximumFractionDigits, ...a }), s < 1) {
+    const p = ot(s, t.locale, a);
+    return o + p + r + e[0];
+  }
+  const n = Math.min(Math.floor(t.binary ? Math.log(s) / Math.log(1024) : Math.log10(s) / 3), e.length - 1);
+  s /= (t.binary ? 1024 : 1e3) ** n, a || (s = s.toPrecision(3));
+  const f = ot(Number(s), t.locale, a), u = e[n];
+  return o + f + r + u;
+}
+const Wt = 8192, at = 0, X = 1, P = 2;
+class ie {
+  constructor(t) {
+    l(this, "buffers");
+    l(this, "onGrowBufferHandlers", []);
+    l(this, "isClone");
+    l(this, "memory");
+    if (t && "buffers" in t)
+      this.buffers = t.buffers.map((e) => new G({
+        buf: e,
+        skipInitialization: !0
+      })), this.memory = new c(this, {
+        bufferPosition: 0,
+        bufferByteOffset: 40
+      }), this.isClone = !0;
+    else {
+      "SharedArrayBuffer" in globalThis || console.warn("SharedArrayBuffer is not working: falling back to ArrayBuffer");
+      const e = (t == null ? void 0 : t.bufferSize) ?? Wt;
+      if (e > q)
+        throw new Error(`Buffer size ${e} is greater than max ${q} that we can reference with pointers`);
+      let r = this.createBuffer(e);
+      this.buffers = [
+        r
+      ];
+      const i = r.callocAs("u32", 3);
+      if (i)
+        this.memory = new c(this, {
+          bufferPosition: 0,
+          bufferByteOffset: i.byteOffset
+        });
+      else
+        throw new Error("Failed to initialize first byte from buffer");
+      this.memory.data[at] = e, this.memory.data[X] = 1, this.memory.data[P] = (t == null ? void 0 : t.autoGrowSize) ?? 100, this.isClone = !1;
+      for (let o = 1; o < ((t == null ? void 0 : t.initialBuffers) ?? 1); o++)
+        this.buffers.push(this.createBuffer(e));
+    }
+  }
+  get bufferSize() {
+    return this.memory.data[at];
+  }
+  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, X, 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, X) === this.buffers.length && this.memory.data[P] < 100 && this.memory.data[P] > 0 && o.top / o.end > this.memory.data[P] / 100 && this.growBuffer(), new c(this, {
+          data: a,
+          buffer: o
+        });
+    }
+    if (this.buffers.length >= J)
+      throw new Error(`Can't initialize a new buffer since it would have a position greater than the max of ${J}`);
+    let e = this.growBuffer();
+    const r = e.callocAs("u32", t);
+    if (r)
+      return new c(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 c(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 `${ft(this.currentUsed)} / ${ft(this.totalAllocated)}`;
+  }
+  getSharedMemory() {
+    return {
+      buffers: this.buffers.map((t) => t.buf)
+    };
+  }
+}
+function ft(s) {
+  return Xt(s, {
+    binary: !0,
+    minimumFractionDigits: 1,
+    maximumFractionDigits: 1
+  });
+}
+const nt = 4, lt = 1, E = 2;
+class d {
+  constructor(t, e) {
+    l(this, "memory");
+    /* First block
+    	32 index 0
+    	uint16 0 - next buffer position
+    	uint16 1 - next buffer index
+    	32 index 1
+    	uint16 2 - last buffer position
+    	uint16 3 - last buffer index
+    	32 index 2
+    	uint32 4 - length
+    	32 index 3
+    	uint16 6 - type
+    	uint16 7 - data length (defaults to 1 number per data)
+    */
+    /* Other blocks
+    	32 index 0
+    	uint16 0 - next buffer position
+    	uint16 1 - next buffer index
+    	32 index 1 => data
+    */
+    l(this, "firstBlock");
+    l(this, "uint16Array");
+    l(this, "onDelete");
+    if (this.memory = t, e && "firstBlock" in e)
+      this.firstBlock = new c(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (E + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
+    else {
+      e && e.initWithBlock ? this.firstBlock = new c(t, e.initWithBlock) : this.firstBlock = t.allocUI32(nt), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + (E + 1) * Uint32Array.BYTES_PER_ELEMENT, 2);
+      const r = (e == null ? void 0 : e.type) ?? Uint32Array;
+      r === Uint32Array ? this.type = 0 : r === Int32Array ? this.type = 1 : r === Float32Array && (this.type = 2), this.dataLength = (e == null ? void 0 : e.dataLength) ?? 1;
+    }
+  }
+  get length() {
+    return Atomics.load(this.firstBlock.data, E);
+  }
+  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);
+  }
+  insert(t) {
+    typeof t == "number" && (t = [t]);
+    let e = this.dataLength;
+    if (t.length > e)
+      throw new Error(`Can't insert ${t.length} array into shared list of ${e} dataLength`);
+    let r = this.memory.allocUI32(lt + e), i = this.getDataBlock(r.data), o = r.pointer;
+    for (let f = 0; f < t.length; f++)
+      i instanceof Int32Array || i instanceof Uint32Array ? Atomics.store(i, f, t[f]) : i[f] = t[f];
+    let a, n = !1;
+    for (; !n; )
+      a = O(this.firstBlock.data, 1), n = $(this.firstBlock.data, 1, o, a);
+    if (a) {
+      let { bufferPosition: f, bufferByteOffset: u } = S(a), p = new Uint32Array(this.memory.buffers[f].buf, u, 1);
+      W(p, 0, o);
+    } else
+      W(this.firstBlock.data, 0, o);
+    Atomics.add(this.firstBlock.data, E, 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 = $(this.firstBlock.data, 1, 0, e);
+    }
+    if (!t)
+      return;
+    $(this.firstBlock.data, 0, 0, t);
+    let i = 0, o = t;
+    for (; o; ) {
+      let { bufferPosition: a, bufferByteOffset: n } = S(o), f = this.memory.buffers[a];
+      if (!f)
+        break;
+      let u = new Uint32Array(f.buf, n, 2);
+      o = O(u, 0), i++, this.onDelete && this.onDelete(this.getDataBlock(u)), f.free(u.byteOffset);
+    }
+    Atomics.sub(this.firstBlock.data, E, i);
+  }
+  *[Symbol.iterator]() {
+    let t = 0, { bufferPosition: e, bufferByteOffset: r } = h(this.firstBlock.data, 0), i = this.firstBlock.data, o = 0, a = 0;
+    for (; r; ) {
+      let n = this.memory.buffers[e];
+      if (!n)
+        return;
+      let f = new Uint32Array(n.buf, r, 2), u = this.getDataBlock(f), p = e, Mt = r;
+      ({ bufferPosition: e, bufferByteOffset: r } = h(f, 0));
+      let j = !0;
+      yield {
+        data: u,
+        index: t,
+        deleteCurrent: () => {
+          A(i, 0, e, r), r || A(this.firstBlock.data, 1, o, a), this.onDelete && this.onDelete(this.getDataBlock(f)), n.free(f.byteOffset), Atomics.sub(this.firstBlock.data, E, 1), j = !1;
+        }
+      }, j && (i = f, o = p, a = Mt, t++);
+    }
+  }
+  forEach(t) {
+    for (let e of this)
+      t(e.data);
+  }
+  getSharedMemory() {
+    return {
+      firstBlock: this.firstBlock.getSharedMemory()
+    };
+  }
+  getDataBlock(t) {
+    const e = t.byteOffset + lt * 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 } = h(this.firstBlock.data, 0);
+    for (; e; ) {
+      let r = new c(this.memory, {
+        bufferPosition: t,
+        bufferByteOffset: e
+      });
+      ({ bufferPosition: t, bufferByteOffset: e } = h(r.data, 0)), this.onDelete && this.onDelete(this.getDataBlock(r.data)), r.free();
+    }
+    this.firstBlock.free();
+  }
+}
+l(d, "ALLOCATE_COUNT", nt);
+const ht = 10, F = class F {
+  constructor(t, e) {
+    l(this, "memory");
+    // Memory order: Pointer, Lock, Length, MaxHash
+    l(this, "pointerMemory");
+    l(this, "lock");
+    if (this.memory = t, e)
+      this.pointerMemory = new c(t, e.firstBlock);
+    else {
+      this.pointerMemory = t.allocUI32(F.ALLOCATE_COUNT);
+      let r = t.allocUI32(ht);
+      A(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, ht);
+    }
+    this.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + Uint32Array.BYTES_PER_ELEMENT, 1);
+  }
+  get hashMemory() {
+    return new c(this.memory, h(this.pointerMemory.data, 0));
+  }
+  get length() {
+    return Atomics.load(this.pointerMemory.data, 2);
+  }
+  get maxHash() {
+    return Atomics.load(this.pointerMemory.data, 3);
+  }
+  set(t, e) {
+    this.length >= this.maxHash * 2 && this.growHashTable();
+    let r = N(t);
+    this.setHashKey(this.hashMemory, this.maxHash, r, e) && Atomics.add(this.pointerMemory.data, 2, 1);
+  }
+  setHashKey(t, e, r, i) {
+    let o = this.hash(r, e), a, n = h(t.data, o);
+    if (n.bufferByteOffset === 0) {
+      a = new d(this.memory, {
+        dataLength: 2
+      });
+      let u = a.getSharedMemory();
+      A(t.data, o, u.firstBlock.bufferPosition, u.firstBlock.bufferByteOffset);
+    } else
+      a = new d(this.memory, {
+        firstBlock: n
+      });
+    let f = !0;
+    return a.deleteValue(r) && (f = !1), a.insert([r, i]), f;
+  }
+  get(t) {
+    let e = N(t), r = this.hash(e, this.maxHash), i = h(this.hashMemory.data, r);
+    if (i.bufferByteOffset === 0)
+      return;
+    let o = new d(this.memory, {
+      firstBlock: i
+    });
+    for (let { data: a } of o)
+      if (a[0] === e)
+        return a[1];
+  }
+  has(t) {
+    let e = N(t), r = this.hash(e, this.maxHash), i = h(this.hashMemory.data, r);
+    if (i.bufferByteOffset === 0)
+      return !1;
+    let o = new d(this.memory, {
+      firstBlock: i
+    });
+    for (let { data: a } of o)
+      if (a[0] === e)
+        return !0;
+    return !1;
+  }
+  delete(t) {
+    let e = N(t), r = this.hash(e, this.maxHash), i = h(this.hashMemory.data, r);
+    if (i.bufferByteOffset === 0)
+      return !1;
+    let o = new d(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 = h(i.data, o);
+      if (a.bufferByteOffset === 0)
+        continue;
+      let n = new d(this.memory, {
+        firstBlock: a
+      });
+      for (let { data: f } of n)
+        this.setHashKey(r, e, f[0], f[1]);
+    }
+    A(this.pointerMemory.data, 0, r.bufferPosition, r.bufferByteOffset), Atomics.store(this.pointerMemory.data, 3, e);
+  }
+  hash(t, e) {
+    return t % e;
+  }
+  free() {
+    for (let t = 0; t < this.maxHash; t++) {
+      let e = h(this.hashMemory.data, t);
+      if (e.bufferByteOffset === 0)
+        continue;
+      new d(this.memory, {
+        firstBlock: e
+      }).free();
+    }
+    this.hashMemory.free(), this.pointerMemory.free();
+  }
+  getSharedMemory() {
+    return {
+      firstBlock: this.pointerMemory.getSharedMemory()
+    };
+  }
+};
+l(F, "ALLOCATE_COUNT", 4);
+let ct = F;
+function N(s) {
+  return typeof s == "number" ? s : typeof s == "string" ? Zt(s) : s;
+}
+function Zt(s) {
+  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 {
+  constructor(t, e) {
+    l(this, "memory");
+    l(this, "list");
+    this.memory = t, e ? this.list = new d(t, e) : this.list = new d(t);
+  }
+  get length() {
+    return this.list.length;
+  }
+  insert(t) {
+    this.list.insert(w(t.memory.bufferPosition, t.memory.bufferByteOffset));
+  }
+  delete(t) {
+    return this.list.deleteValue(w(t.memory.bufferPosition, t.memory.bufferByteOffset));
+  }
+  *[Symbol.iterator]() {
+    let t = this.list[Symbol.iterator]();
+    for (let { data: e } of t) {
+      let { bufferPosition: r, bufferByteOffset: i } = h(e, 0), o = new c(this.memory, {
+        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 ut = {
+  1: Uint8Array,
+  2: Uint16Array
+}, I = 0, dt = 1, yt = 2, mt = 3, x = class x {
+  constructor(t, e) {
+    l(this, "memory");
+    l(this, "allocatedMemory");
+    l(this, "lock");
+    l(this, "cachedPointer");
+    l(this, "cachedString");
+    this.memory = t, typeof e == "string" ? (this.allocatedMemory = this.memory.allocUI32(x.ALLOCATE_COUNT), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + mt * this.allocatedMemory.data.BYTES_PER_ELEMENT), this.updateString(e)) : (this.allocatedMemory = new c(t, e), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + mt * this.allocatedMemory.data.BYTES_PER_ELEMENT), "value" in e && this.updateString(e.value));
+  }
+  updateString(t) {
+    let e = this.createString(t);
+    C(this.lock), W(this.allocatedMemory.data, I, e.pointer), Atomics.store(this.allocatedMemory.data, dt, t.length), Atomics.store(this.allocatedMemory.data, yt, e.charType), B(this.lock), this.cachedPointer = e.pointer, this.cachedString = t;
+  }
+  createString(t) {
+    if (t === "")
+      return {
+        pointer: 0,
+        charType: 1
+        /* ASCII */
+      };
+    let e = [];
+    for (let f = 0; f < t.length; f++)
+      e.push(t.charCodeAt(f));
+    let i = Math.max(...e) > 255 ? 2 : 1, o = ut[i], a = this.memory.allocUI32(Math.ceil(t.length / (4 / o.BYTES_PER_ELEMENT))), n = new o(a.data.buffer, a.data.byteOffset, t.length);
+    for (let f = 0; f < t.length; f++)
+      n[f] = t.charCodeAt(f);
+    return {
+      pointer: a.pointer,
+      charType: i
+    };
+  }
+  get value() {
+    let t = O(this.allocatedMemory.data, I);
+    if (this.cachedPointer === t && this.cachedString !== void 0)
+      return this.cachedString;
+    if (t === 0)
+      return "";
+    let { bufferPosition: e, bufferByteOffset: r } = S(t);
+    C(this.lock);
+    let i = Atomics.load(this.allocatedMemory.data, yt), o = ut[i], a = Atomics.load(this.allocatedMemory.data, dt), n = new o(this.memory.buffers[e].buf, r, a), f = String.fromCharCode.apply(null, n);
+    return B(this.lock), this.cachedPointer = t, this.cachedString = f, f;
+  }
+  set value(t) {
+    let { bufferPosition: e, bufferByteOffset: r } = h(this.allocatedMemory.data, I);
+    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 } = h(this.allocatedMemory.data, I);
+    e && this.memory.buffers[t].free(e), this.allocatedMemory.free();
+  }
+};
+l(x, "ALLOCATE_COUNT", 4);
+let bt = x;
+const m = 1, Bt = 2, At = 3, vt = 4, R = class R {
+  constructor(t, e) {
+    l(this, "memory");
+    // Pointer, List Length, Buffer Length, Type/DataLength
+    l(this, "firstBlock");
+    l(this, "uint16Array");
+    l(this, "cachedFullDataBlock");
+    l(this, "cachedPointer");
+    if (this.memory = t, e && "firstBlock" in e)
+      this.firstBlock = new c(t, e.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + At * Uint32Array.BYTES_PER_ELEMENT, 2);
+    else {
+      this.firstBlock = t.allocUI32(R.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + At * Uint32Array.BYTES_PER_ELEMENT, 2);
+      let r = (e == null ? void 0 : e.dataLength) ?? 1, i = (e == null ? void 0 : e.bufferLength) ?? vt, o = t.allocUI32(i * r);
+      A(this.firstBlock.data, 0, o.bufferPosition, o.bufferByteOffset), this.bufferLength = i;
+      const a = (e == null ? void 0 : e.type) ?? Uint32Array;
+      a === Uint32Array ? this.type = 0 : a === Int32Array ? this.type = 1 : a === Float32Array && (this.type = 2), this.dataLength = r;
+    }
+    this.cachedPointer = this.firstBlock.data[0], this.cachedFullDataBlock = this.getFullDataBlock(this.dataLength);
+  }
+  get length() {
+    return Atomics.load(this.firstBlock.data, m);
+  }
+  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 Atomics.load(this.firstBlock.data, Bt);
+  }
+  set bufferLength(t) {
+    Atomics.store(this.firstBlock.data, Bt, t);
+  }
+  at(t) {
+    let e = this.length;
+    if (t >= e || t < 0)
+      throw new Error(`${t} is out of bounds ${e}`);
+    let r = h(this.firstBlock.data, 0), i = new c(this.memory, r);
+    return this.getDataBlock(i.data, t);
+  }
+  get(t, e = 0) {
+    if (e >= this.dataLength)
+      throw new Error(`${e} is out of dataLength bounds ${this.dataLength}`);
+    return this.at(t)[e];
+  }
+  push(t) {
+    typeof t == "number" && (t = [t]);
+    let e = this.dataLength;
+    if (t.length > e)
+      throw new Error(`Can't insert ${t.length} array into shared list of ${e} dataLength`);
+    let r = this.getFullDataBlock(e), i = this.length;
+    return r.set(t, e * i), Atomics.add(this.firstBlock.data, m, m) + 1 >= this.bufferLength && this.growBuffer(), i;
+  }
+  pop() {
+    let t = Atomics.sub(this.firstBlock.data, m, m), e = h(this.firstBlock.data, 0), r = new c(this.memory, e);
+    return this.getDataBlock(r.data, t - 1);
+  }
+  deleteIndex(t) {
+    let e = this.length;
+    if (t >= e || t < 0)
+      throw new Error(`${t} is out of bounds ${e}`);
+    let r = this.dataLength, i = this.getFullDataBlock(r);
+    for (let o = t; o < e; o++)
+      for (let a = 0; a < r; a++)
+        i[o * r + a] = i[(o + 1) * r + a];
+    Atomics.sub(this.firstBlock.data, m, m);
+  }
+  clear() {
+    this.firstBlock.data[m] = 0;
+  }
+  *[Symbol.iterator]() {
+    let t = h(this.firstBlock.data, 0), e = new c(this.memory, t);
+    for (let r = 0; r < this.length; r++)
+      yield this.getDataBlock(e.data, r);
+  }
+  getFullDataBlock(t) {
+    let e = Atomics.load(this.firstBlock.data, 0);
+    if (this.cachedPointer === e && this.cachedFullDataBlock)
+      return this.cachedFullDataBlock;
+    let r = S(e), i = new c(this.memory, r), o;
+    switch (this.type) {
+      case 1:
+        o = new Int32Array(i.data.buffer, i.bufferByteOffset, t * this.bufferLength);
+        break;
+      case 0:
+        o = new Uint32Array(i.data.buffer, i.bufferByteOffset, t * this.bufferLength);
+        break;
+      case 2:
+        o = new Float32Array(i.data.buffer, i.bufferByteOffset, t * this.bufferLength);
+        break;
+      default:
+        throw new Error(`Unknown data block type ${this.type}`);
+    }
+    return this.cachedPointer = e, this.cachedFullDataBlock = o, o;
+  }
+  getDataBlock(t, e) {
+    switch (this.type) {
+      case 1:
+        return new Int32Array(t.buffer, t.byteOffset + e * this.dataLength * 4, this.dataLength);
+      case 0:
+        return new Uint32Array(t.buffer, t.byteOffset + e * this.dataLength * 4, this.dataLength);
+      case 2:
+        return new Float32Array(t.buffer, t.byteOffset + e * this.dataLength * 4, this.dataLength);
+      default:
+        throw new Error(`Unknown data block type ${this.type}`);
+    }
+  }
+  growBuffer() {
+    let e = this.bufferLength * 2, r = this.dataLength, i = h(this.firstBlock.data, 0), o = new c(this.memory, i), a = this.getFullDataBlock(r), n = this.memory.allocUI32(e * r), f;
+    switch (this.type) {
+      case 1:
+        f = new Int32Array(n.data.buffer, n.bufferByteOffset, r * this.bufferLength);
+        break;
+      case 0:
+        f = new Uint32Array(n.data.buffer, n.bufferByteOffset, r * this.bufferLength);
+        break;
+      case 2:
+        f = new Float32Array(n.data.buffer, n.bufferByteOffset, r * this.bufferLength);
+        break;
+      default:
+        throw new Error(`Unknown data block type ${this.type}`);
+    }
+    f.set(a), A(this.firstBlock.data, 0, n.bufferPosition, n.bufferByteOffset), this.bufferLength = e, o.free();
+  }
+  free() {
+    let t = h(this.firstBlock.data, 0);
+    new c(this.memory, t).free(), this.firstBlock.free();
+  }
+  getSharedMemory() {
+    return {
+      firstBlock: this.firstBlock.getSharedMemory()
+    };
+  }
+};
+l(R, "ALLOCATE_COUNT", 4);
+let kt = R;
+class jt {
+  constructor(t, e) {
+    l(this, "heap");
+    l(this, "list");
+    l(this, "cache", /* @__PURE__ */ new Map());
+    e ? this.list = new d(t, e) : this.list = new d(t), this.heap = t, this.list.onDelete = (r) => {
+      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();
+  }
+}
+l(jt, "ALLOCATE_COUNT", d.ALLOCATE_COUNT);
+const Et = new ArrayBuffer(4), gt = new Uint32Array(Et), D = new Uint16Array(Et);
+function oe(s, t) {
+  return qt(Atomics.load(s, t));
+}
+function ae(s, t, e, r) {
+  Atomics.store(s, t, Jt(e, r));
+}
+function qt(s) {
+  return gt[0] = s, [D[0], D[1]];
+}
+function Jt(s, t) {
+  return D[0] = s, D[1] = t, gt[0];
+}
+const wt = new ArrayBuffer(8), Tt = new BigUint64Array(wt), b = new Uint16Array(wt);
+function fe(s, t) {
+  return Tt[0] = Atomics.load(s, t), [b[0], b[1], b[2], b[3]];
+}
+function ne(s, t, e, r, i, o = 0) {
+  b[0] = e, b[1] = r, b[2] = i, b[3] = o, Atomics.store(s, t, Tt[0]);
+}
+const pt = new ArrayBuffer(4), _t = new Float32Array(pt), Ot = new Int32Array(pt);
+function le(s, t) {
+  return St(Atomics.load(s, t));
+}
+function he(s, t, e) {
+  Atomics.store(s, t, Lt(e));
+}
+function St(s) {
+  return Ot[0] = s, _t[0];
+}
+function Lt(s) {
+  return _t[0] = s, Ot[0];
+}
+function ce(s, t, e) {
+  return St(Atomics.exchange(s, t, Lt(e)));
+}
+const g = 0, v = 1, T = 2;
+function ue(s, t = 0) {
+  for (; Atomics.compareExchange(s, t, g, v) === T; )
+    Atomics.wait(s, t, T);
+  Atomics.add(s, t + 1, 1);
+}
+function de(s, t = 0) {
+  let e = Atomics.compareExchange(s, t, g, T);
+  for (; e !== g; )
+    Atomics.wait(s, t, e), e = Atomics.compareExchange(s, t, g, T);
+}
+function ye(s, t = 0) {
+  Atomics.sub(s, t + 1, 1) - 1 <= 0 && (Atomics.compareExchange(s, t, v, g) !== v && console.warn("We are unlocking when it was not read locked!"), Atomics.notify(s, t));
+}
+function me(s, t = 0) {
+  Atomics.compareExchange(s, t, T, g) !== T && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(s, t);
+}
+const be = 2;
+export {
+  c as AllocatedMemory,
+  Vt as BYTE_OFFSET_BIT_COUNT,
+  jt as CachedItemList,
+  q as MAX_BYTE_OFFSET_LENGTH,
+  J as MAX_POSITION_LENGTH,
+  G as MemoryBuffer,
+  ie as MemoryHeap,
+  te as POSITION_BIT_COUNT,
+  be as READ_WRITE_LOCK_ALLOCATE_COUNT,
+  re as SIMPLE_LOCK_ALLOCATE_COUNT,
+  d as SharedList,
+  ct as SharedMap,
+  se as SharedPointerList,
+  bt as SharedString,
+  kt as SharedVector,
+  Jt as convert16To32,
+  qt as convert32To16,
+  Lt as convertFloat32ToInt32,
+  St as convertInt32ToFloat32,
+  w as createPointer,
+  ce as exchangeFloat32,
+  S as getPointer,
+  oe as load16From32,
+  fe as load16From64,
+  le as loadFloat32,
+  h as loadPointer,
+  O as loadRawPointer,
+  C as lock,
+  ue as readLock,
+  ye as readUnlock,
+  ee as replacePointer,
+  $ as replaceRawPointer,
+  ae as store16In32,
+  ne as store16In64,
+  he as storeFloat32,
+  A as storePointer,
+  W as storeRawPointer,
+  B as unlock,
+  de as writeLock,
+  me as writeUnlock
+};