@daneren2005/shared-memory-objects 1.6.1 → 1.6.3

package/README.md

@@ -78,7 +78,7 @@ Freshly allocated with the default options:
 
 | Structure                       | Used Memory |
 | ------------------------------- | ----------- |
-| SharedList                      | 16 bytes    |
+| SharedList                      | 32 bytes    |
 | SharedVector                    | 32 bytes    |
 | SharedStack                     | 144 bytes   |
 | SharedPool                      | 664 bytes   |
@@ -88,13 +88,14 @@ Freshly allocated with the default options:
 | SharedSpatialGrid (20x20 cells) | 8816 bytes  |
 | SharedSpatialGrid (80x80 cells) | 56816 bytes |
 | SharedSpatialMap (default)      | 8984 bytes  |
+| SharedSpatialMap (Float64)      | 14984 bytes |
 | SharedSpatialMap (2048 buckets) | 23384 bytes |
 
 `SharedQuadtree`'s footprint is dominated by its fixed node array, which is allocated once up front and never grows.  The default `maxLevels` of 4 is a complete tree of 341 nodes (`(4^(maxLevels+1) - 1) / 3`), so the number scales with `maxLevels`: a deeper tree resolves smaller entities but costs `~2 u32` per node.  The rest is its internal `SharedPool` of entity records and the `SharedMap` that indexes entities by id, whose header blocks are inlined into the tree's own allocation (the same way `SharedPool` inlines its two stacks) so the whole spine is one contiguous block instead of three separate pointer resources.  The record (id, `x/y/w/h`, node, bucket link) is stored at the configured precision, defaulting to `Float32` to match a physics engine that keeps positions in `Float32`.  `Float32` stays exact as long as entity ids and the entity count both stay under 2^24 (~16.7M); pass `type: Float64Array` if you need ids or a capacity beyond that (constructing a `Float32` tree with `maxEntities` over 2^24 throws), at the cost of more memory per entity.
 
 `SharedSpatialGrid`'s footprint is likewise dominated by its fixed cell array (`cols x rows` cells at `~2 u32` each), so it scales with cell count rather than `maxLevels`: `cols = ceil(width / gridSize)` and `rows = ceil(height / gridSize)`, so a smaller `gridSize` resolves finer at the cost of more cells (the 20x20 grid above is a 1000x1000 world at `gridSize` 50; the 80x80 grid is a 4000x4000 world at `gridSize` 50).  The rest is two inlined `SharedPool`s - one of entity records (the occupied cell rectangle, keyed by an inlined `SharedMap` of id -> index) and one of per-cell "slot" records (`id`, anchor cell, bucket link) - since a multi-cell entity needs one slot per cell it overlaps.  `maxSlots` therefore defaults to `maxEntities * 4` to leave headroom for spanning entities.  Coordinate precision follows the same `Float32`-default rule as the quadtree (ids, both pools' indices, and cell indices must stay under 2^24 for `Float32`; pass `type: Float64Array` otherwise).
 
-`SharedSpatialMap` starts at 8984 bytes with its default 256 buckets, about 87% less than the former fixed 8192-bucket table's 70312 bytes. When the number of allocated slots exceeds half the active bucket count, it doubles the count and rebuilds the bucket chains. Its 256-bucket pages remain at stable addresses, while their pointers live in a `SharedStack` that grows in segments. `buckets` is therefore an initial size hint rather than a permanent sizing decision; `map.buckets` reports the current count. `maxBuckets` can stop growth for a deliberately collision-heavy or memory-capped table and otherwise defaults high enough to preserve the target load through `maxSlots`. The rest is the same two inlined `SharedPool`s as the grid - one of entity records and one of per-cell slot records. `maxSlots` defaults to `maxEntities * 4`, and coordinate precision follows the same `Float32`-default rule.
+`SharedSpatialMap` starts at 8984 bytes with its default 256 buckets, about 87% less than the former fixed 8192-bucket table's 70312 bytes. When the number of allocated slots exceeds half the active bucket count, it doubles the count and rebuilds the bucket chains. Its 256-bucket pages remain at stable addresses, while their pointers live in a `SharedStack` that grows in segments. `buckets` is therefore an initial size hint rather than a permanent sizing decision; `map.buckets` reports the current count. `maxBuckets` can stop growth for a deliberately collision-heavy or memory-capped table and otherwise defaults high enough to preserve the target load through `maxSlots`. The rest is the same two inlined `SharedPool`s as the grid - one of entity records and one of per-cell slot records. `maxSlots` defaults to `maxEntities * 4`, and coordinate precision follows the same `Float32`-default rule. Ids must be integers in `[0, 2^24)` for `Float32` or `[0, 2^32)` for `Float64` (the id map's keys are uint32); `insert`, `update`, and `bulkInsert` throw on anything else rather than storing an entity that could never be found or removed again.
 
 All three spatial indexes accept `bulkInsert(entities)`, where each entity has `{ id, x, y, width?, height? }`. Duplicate ids keep their last value. The method retains the normal thread-safety guarantees while reserving entity and slot ranges with one atomic operation, sizing the ID map once, and writing records directly into their pool blocks; `SharedSpatialMap` also sizes its bucket table once before linking a new batch. When an explicit entity or slot capacity is at most 16384, its pool uses one bounded contiguous chunk instead of a series of 100-record chunks. Larger and default capacities retain incremental allocation so an empty index does not reserve excessive memory.
 

package/dist/allocated-memory.js

@@ -1,5 +1,5 @@
 import { createPointer as e } from "./utils/pointer.js";
-//#region src/allocated-memory.ts
+// src/allocated-memory.ts
 var t = class t {
 	memory;
 	bufferPosition;
@@ -49,7 +49,6 @@ var t = class t {
 		};
 	}
 };
-//#endregion
 export { t as default };
 
 //# sourceMappingURL=allocated-memory.js.map

package/dist/cached-item-list.js

@@ -1,5 +1,5 @@
 import e from "./shared-list.js";
-//#region src/cached-item-list.ts
+// src/cached-item-list.ts
 var t = class {
 	static ALLOCATE_COUNT = e.ALLOCATE_COUNT;
 	heap;
@@ -70,7 +70,6 @@ var t = class {
 		this.list.free(), this.cache.clear();
 	}
 };
-//#endregion
 export { t as default };
 
 //# sourceMappingURL=cached-item-list.js.map

package/dist/constant-string.js

@@ -1,6 +1,6 @@
-import { getPointer as e, loadRawPointer as t, storeRawPointer as n } from "./utils/pointer.js";
-import r from "./allocated-memory.js";
-//#region src/constant-string.ts
+import e from "./allocated-memory.js";
+import { getPointer as t, loadRawPointer as n, storeRawPointer as r } from "./utils/pointer.js";
+// src/constant-string.ts
 var i = {
 	1: Uint8Array,
 	2: Uint16Array
@@ -9,17 +9,17 @@ var i = {
 	memory;
 	allocatedMemory;
 	value;
-	constructor(e, t) {
-		this.memory = e, typeof t == "string" ? (this.allocatedMemory = this.memory.allocUI32(c.ALLOCATE_COUNT), this.writeString(t), this.value = t) : (this.allocatedMemory = new r(e, t), this.value = this.readString());
+	constructor(t, n) {
+		this.memory = t, typeof n == "string" ? (this.allocatedMemory = this.memory.allocUI32(c.ALLOCATE_COUNT), this.writeString(n), this.value = n) : (this.allocatedMemory = new e(t, n), this.value = this.readString());
 	}
 	writeString(e) {
 		let t = this.createString(e);
-		n(this.allocatedMemory.data, a, t.pointer), Atomics.store(this.allocatedMemory.data, o, e.length), Atomics.store(this.allocatedMemory.data, s, t.charType);
+		r(this.allocatedMemory.data, a, t.pointer), Atomics.store(this.allocatedMemory.data, o, e.length), Atomics.store(this.allocatedMemory.data, s, t.charType);
 	}
 	readString() {
-		let n = t(this.allocatedMemory.data, a);
-		if (n === 0) return "";
-		let { bufferPosition: r, bufferByteOffset: c } = e(n, this.memory.positionBits), u = i[Atomics.load(this.allocatedMemory.data, s)], d = Atomics.load(this.allocatedMemory.data, o);
+		let e = n(this.allocatedMemory.data, a);
+		if (e === 0) return "";
+		let { bufferPosition: r, bufferByteOffset: c } = t(e, this.memory.positionBits), u = i[Atomics.load(this.allocatedMemory.data, s)], d = Atomics.load(this.allocatedMemory.data, o);
 		return l(new u(this.memory.buffers[r].buf, c, d));
 	}
 	createString(e) {
@@ -46,10 +46,10 @@ var i = {
 		return this.allocatedMemory.pointer;
 	}
 	free() {
-		let n = t(this.allocatedMemory.data, a);
-		if (n) {
-			let { bufferPosition: t, bufferByteOffset: r } = e(n, this.memory.positionBits);
-			this.memory.buffers[t].free(r);
+		let e = n(this.allocatedMemory.data, a);
+		if (e) {
+			let { bufferPosition: n, bufferByteOffset: r } = t(e, this.memory.positionBits);
+			this.memory.buffers[n].free(r);
 		}
 		this.allocatedMemory.free();
 	}
@@ -61,7 +61,6 @@ function l(e) {
 	for (let r = 0; r < e.length; r += t) n += String.fromCharCode.apply(null, e.subarray(r, r + t));
 	return n;
 }
-//#endregion
 export { c as default };
 
 //# sourceMappingURL=constant-string.js.map

package/dist/local-pool.js

@@ -1,7 +1,7 @@
-import { getPointer as e } from "./utils/pointer.js";
-import t from "./allocated-memory.js";
+import e from "./allocated-memory.js";
+import { getPointer as t } from "./utils/pointer.js";
 import { getArrayTypeCode as n, getByteMultipler as r } from "./utils/array-type.js";
-//#region src/local-pool.ts
+// src/local-pool.ts
 var i = class {
 	memory;
 	pointers = [];
@@ -75,7 +75,7 @@ var i = class {
 			let e = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
 			this.pointers.push(e.pointer);
 		}
-		let a = new t(this.memory, e(this.pointers[r], this.memory.positionBits)), o = new this.typeConstructor(a.data.buffer, a.bufferByteOffset, this.dataLength * this.maxChunkSize);
+		let a = new e(this.memory, t(this.pointers[r], this.memory.positionBits)), o = new this.typeConstructor(a.data.buffer, a.bufferByteOffset, this.dataLength * this.maxChunkSize);
 		return this.fullDataBlocks[r] = o, o;
 	}
 	getDataBlock(e, t) {
@@ -83,11 +83,10 @@ var i = class {
 		return e.subarray(n, n + this.dataLength);
 	}
 	free() {
-		for (let n of this.pointers) new t(this.memory, e(n, this.memory.positionBits)).free();
+		for (let n of this.pointers) new e(this.memory, t(n, this.memory.positionBits)).free();
 		this.pointers = [], this.recycledIndexes = [], this.totalLength = 0, this.fullDataBlocks = {};
 	}
 };
-//#endregion
 export { i as default };
 
 //# sourceMappingURL=local-pool.js.map

package/dist/lock/read-write-lock.js

@@ -30,7 +30,6 @@ function a(e, t = 0) {
 	Atomics.compareExchange(e, t, -1, 0) !== -1 && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(e, t), Atomics.notify(e, t + 1);
 }
 var o = 2;
-//#endregion
 export { o as READ_WRITE_LOCK_ALLOCATE_COUNT, t as readLock, i as readUnlock, r as tryWriteLock, n as writeLock, a as writeUnlock };
 
 //# sourceMappingURL=read-write-lock.js.map

package/dist/lock/simple-lock.js

@@ -10,7 +10,6 @@ function t(e, t = 0) {
 	Atomics.exchange(e, t, 0) === 2 && Atomics.notify(e, t, 1);
 }
 var n = 1;
-//#endregion
 export { n as SIMPLE_LOCK_ALLOCATE_COUNT, e as lock, t as unlock };
 
 //# sourceMappingURL=simple-lock.js.map

package/dist/memory-buffer.js

@@ -1,6 +1,6 @@
 import { lock as e, unlock as t } from "./lock/simple-lock.js";
 import { typedArray as n } from "./utils/typedarray.js";
-//#region src/memory-buffer.ts
+// src/memory-buffer.ts
 var r = 0, i = 1, a = 2, o = 3, s = 4, c = 5, l = 6, u = 7, d = 1, f = 2, p = {
 	u8: 1,
 	u8c: 1,
@@ -260,7 +260,6 @@ function T(e, t) {
 	return t--, e + t & ~t;
 }
 var E = T(52, 8);
-//#endregion
 export { E as FIRST_BLOCK_DATA_BYTE_OFFSET, y as SIZEOF_MEM_BLOCK, m as SIZEOF_STATE, S as default };
 
 //# sourceMappingURL=memory-buffer.js.map

package/dist/memory-heap.js

@@ -1,8 +1,8 @@
-import { MAX_BYTE_OFFSET_LENGTH as e, positionBitsForBufferSize as t } from "./utils/pointer.js";
-import n from "./allocated-memory.js";
+import e from "./allocated-memory.js";
+import { MAX_BYTE_OFFSET_LENGTH as t, positionBitsForBufferSize as n } from "./utils/pointer.js";
 import r, { FIRST_BLOCK_DATA_BYTE_OFFSET as i } from "./memory-buffer.js";
-//#region src/memory-heap.ts
-var a = e, o = 2 ** 31, s = 0, c = 1, l = 2, u = 3, d = 4, f = class {
+// src/memory-heap.ts
+var a = t, o = 2 ** 31, s = 0, c = 1, l = 2, u = 3, d = 4, f = class {
 	buffers;
 	onGrowBufferHandlers = [];
 	isClone;
@@ -18,29 +18,29 @@ var a = e, o = 2 ** 31, s = 0, c = 1, l = 2, u = 3, d = 4, f = class {
 	get maxAllocationLength() {
 		return Math.floor((this.bufferSize - 36 - 16) / Uint32Array.BYTES_PER_ELEMENT);
 	}
-	constructor(e) {
-		if (e && "buffers" in e) this.buffers = e.buffers.map((e) => new r({
+	constructor(t) {
+		if (t && "buffers" in t) this.buffers = t.buffers.map((e) => new r({
 			buf: e,
 			skipInitialization: !0
-		})), this.memory = new n(this, {
+		})), this.memory = new e(this, {
 			bufferPosition: 0,
 			bufferByteOffset: i
 		}), this.positionBits = this.memory.data[u], this.isClone = !0;
 		else {
 			"SharedArrayBuffer" in globalThis || console.warn("SharedArrayBuffer is not working: falling back to ArrayBuffer");
-			let r = e?.bufferSize ?? a;
+			let r = t?.bufferSize ?? a;
 			if (r > o) throw Error(`Buffer size ${r} is greater than max ${o} that we can reference with pointers`);
-			this.positionBits = t(r);
+			this.positionBits = n(r);
 			let i = this.createBuffer(r);
 			this.buffers = [i];
 			let f = i.callocAs("u32", d);
-			if (f) this.memory = new n(this, {
+			if (f) this.memory = new e(this, {
 				bufferPosition: 0,
 				bufferByteOffset: f.byteOffset
 			});
 			else throw Error("Failed to initialize first byte from buffer");
-			this.memory.data[s] = r, this.memory.data[l] = e?.autoGrowSize ?? 100, this.memory.data[u] = this.positionBits, this.isClone = !1;
-			for (let t = 1; t < (e?.initialBuffers ?? 1); t++) this.buffers.push(this.createBuffer(r));
+			this.memory.data[s] = r, this.memory.data[l] = t?.autoGrowSize ?? 100, this.memory.data[u] = this.positionBits, this.isClone = !1;
+			for (let e = 1; e < (t?.initialBuffers ?? 1); e++) this.buffers.push(this.createBuffer(r));
 			this.memory.data[c] = this.buffers.length;
 		}
 	}
@@ -75,28 +75,28 @@ var a = e, o = 2 ** 31, s = 0, c = 1, l = 2, u = 3, d = 4, f = class {
 		}
 		return this.growBuffer(), !0;
 	}
-	allocUI32(e) {
-		e = Math.ceil(e);
-		let t = this.buffers.length;
-		for (let r = 0; r < t; r++) {
-			let i = (this.allocCursor + r) % t, a = this.buffers[i];
+	allocUI32(t) {
+		t = Math.ceil(t);
+		let n = this.buffers.length;
+		for (let r = 0; r < n; r++) {
+			let i = (this.allocCursor + r) % n, a = this.buffers[i];
 			if (!a) continue;
-			let o = a.callocAs("u32", e);
-			if (o) return this.allocCursor = i, i === this.buffers.length - 1 && Atomics.load(this.memory.data, c) === this.buffers.length && this.memory.data[l] < 100 && this.memory.data[l] > 0 && a.top / a.end > this.memory.data[l] / 100 && this.growBuffer(), new n(this, {
+			let o = a.callocAs("u32", t);
+			if (o) return this.allocCursor = i, i === this.buffers.length - 1 && Atomics.load(this.memory.data, c) === this.buffers.length && this.memory.data[l] < 100 && this.memory.data[l] > 0 && a.top / a.end > this.memory.data[l] / 100 && this.growBuffer(), new e(this, {
 				data: o,
 				buffer: a
 			});
 		}
 		if (this.buffers.length >= this.maxBuffers) throw Error(`Can't initialize a new buffer since it would have a position greater than the max of ${this.maxBuffers}`);
-		let r = this.growBuffer(), i = r.callocAs("u32", e);
-		if (i) return this.allocCursor = this.buffers.indexOf(r), new n(this, {
+		let r = this.growBuffer(), i = r.callocAs("u32", t);
+		if (i) return this.allocCursor = this.buffers.indexOf(r), new e(this, {
 			data: i,
 			buffer: r
 		});
-		throw Error(`Unable to allocate ${e} numbers even after adding a new buffer`);
+		throw Error(`Unable to allocate ${t} numbers even after adding a new buffer`);
 	}
-	getSharedAlloc(e) {
-		if (this.buffers[e.bufferPosition] !== void 0) return new n(this, e);
+	getSharedAlloc(t) {
+		if (this.buffers[t.bufferPosition] !== void 0) return new e(this, t);
 	}
 	get currentUsed() {
 		return this.totalAllocated - this.buffers.reduce((e, t) => e + t.stats().available, 0);
@@ -108,7 +108,6 @@ var a = e, o = 2 ** 31, s = 0, c = 1, l = 2, u = 3, d = 4, f = class {
 		return { buffers: this.buffers.map((e) => e.buf) };
 	}
 };
-//#endregion
 export { f as default };
 
 //# sourceMappingURL=memory-heap.js.map

package/dist/serialize-object.js

@@ -1,6 +1,6 @@
-import { getPointer as e } from "./utils/pointer.js";
-import t from "./allocated-memory.js";
-//#region src/serialize-object.ts
+import e from "./allocated-memory.js";
+import { getPointer as t } from "./utils/pointer.js";
+// src/serialize-object.ts
 var n = 52361700;
 function r(e, t) {
 	let r = [], i = Object.keys(t);
@@ -16,7 +16,7 @@ function r(e, t) {
 	return s.getArray(Float32Array, 0, r.length).set(r), s;
 }
 function i(n, r) {
-	return a(new t(n, e(r, n.positionBits)));
+	return a(new e(n, t(r, n.positionBits)));
 }
 function a(e) {
 	let t = new Float32Array(e.data.buffer, e.bufferByteOffset);
@@ -41,7 +41,6 @@ function a(e) {
 function o(e, t) {
 	for (let n = 0; n < t.length; n++) e.push(t.charCodeAt(n));
 }
-//#endregion
 export { a as createObjectFromMemory, i as createObjectFromPointer, r as serializeObjectToMemory };
 
 //# sourceMappingURL=serialize-object.js.map

package/dist/shared-list.js

@@ -1,8 +1,8 @@
-import { loadPointer as e, loadRawPointer as t, replaceRawPointer as n, storeRawPointer as r } from "./utils/pointer.js";
-import i from "./allocated-memory.js";
+import e from "./allocated-memory.js";
+import { loadPointer as t, loadRawPointer as n, replaceRawPointer as r, storeRawPointer as i } from "./utils/pointer.js";
 import { readLock as a, readUnlock as o, tryWriteLock as s, writeLock as c, writeUnlock as l } from "./lock/read-write-lock.js";
 import { getArrayTypeCode as u, getByteMultipler as d, isBigIntType as f, isFloatType as p, makeArrayView as m } from "./utils/array-type.js";
-//#region src/shared-list.ts
+// src/shared-list.ts
 var h = 7, g = 2, _ = g * Uint32Array.BYTES_PER_ELEMENT, v = 0, y = 1, b = 2, x = 4, S = 5, C = 0, w = 1, T = 16, E = class {
 	static ALLOCATE_COUNT = h;
 	memory;
@@ -22,15 +22,15 @@ var h = 7, g = 2, _ = g * Uint32Array.BYTES_PER_ELEMENT, v = 0, y = 1, b = 2, x
 		return Atomics.load(this.firstBlock.data, b);
 	}
 	get usedMemory() {
-		let t = this.firstBlock.usedMemory, { bufferPosition: n, bufferByteOffset: r } = e(this.firstBlock.data, v, this.positionBits);
-		for (; r;) {
-			let a = new i(this.memory, {
-				bufferPosition: n,
-				bufferByteOffset: r
+		let n = this.firstBlock.usedMemory, { bufferPosition: r, bufferByteOffset: i } = t(this.firstBlock.data, v, this.positionBits);
+		for (; i;) {
+			let a = new e(this.memory, {
+				bufferPosition: r,
+				bufferByteOffset: i
 			});
-			t += a.usedMemory, {bufferPosition: n, bufferByteOffset: r} = e(a.data, C, this.positionBits);
+			n += a.usedMemory, {bufferPosition: r, bufferByteOffset: i} = t(a.data, C, this.positionBits);
 		}
-		return t;
+		return n;
 	}
 	get type() {
 		return this.cachedType;
@@ -44,27 +44,27 @@ var h = 7, g = 2, _ = g * Uint32Array.BYTES_PER_ELEMENT, v = 0, y = 1, b = 2, x
 	set dataLength(e) {
 		Atomics.store(this.uint16Array, 1, e);
 	}
-	constructor(e, t) {
-		this.memory = e, this.positionBits = e.positionBits, this.positionMask = (1 << this.positionBits) - 1, t && "firstBlock" in t ? (this.firstBlock = new i(e, t.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + 3 * Uint32Array.BYTES_PER_ELEMENT, 2)) : (this.firstBlock = t && t.initWithBlock ? new i(e, t.initWithBlock) : e.allocUI32(h), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + 3 * Uint32Array.BYTES_PER_ELEMENT, 2), r(this.firstBlock.data, y, this.firstBlock.pointer), this.type = u(t?.type ?? Uint32Array), this.dataLength = t?.dataLength ?? 1), this.lockArray = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + S * Uint32Array.BYTES_PER_ELEMENT, 2), this.cachedType = Atomics.load(this.uint16Array, 0), this.cachedDataLength = Math.max(1, Atomics.load(this.uint16Array, 1)), this.cachedByteMultipler = d(this.cachedType), this.cachedIsBigInt = f(this.cachedType), this.cachedIsFloat = p(this.cachedType);
+	constructor(t, n) {
+		this.memory = t, this.positionBits = t.positionBits, this.positionMask = (1 << this.positionBits) - 1, n && "firstBlock" in n ? (this.firstBlock = new e(t, n.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + 3 * Uint32Array.BYTES_PER_ELEMENT, 2)) : (this.firstBlock = n && n.initWithBlock ? new e(t, n.initWithBlock) : t.allocUI32(h), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + 3 * Uint32Array.BYTES_PER_ELEMENT, 2), i(this.firstBlock.data, y, this.firstBlock.pointer), this.type = u(n?.type ?? Uint32Array), this.dataLength = n?.dataLength ?? 1), this.lockArray = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + S * Uint32Array.BYTES_PER_ELEMENT, 2), this.cachedType = Atomics.load(this.uint16Array, 0), this.cachedDataLength = Math.max(1, Atomics.load(this.uint16Array, 1)), this.cachedByteMultipler = d(this.cachedType), this.cachedIsBigInt = f(this.cachedType), this.cachedIsFloat = p(this.cachedType);
 	}
 	insert(e) {
 		Array.isArray(e) || (e = [e]);
-		let r = this.cachedDataLength;
-		if (e.length > r) throw Error(`Can't insert ${e.length} array into shared list of ${r} dataLength`);
-		let i = this.memory.allocUI32(g + r * this.cachedByteMultipler), a = this.getDataBlock(i.data.buffer, i.data.byteOffset), o = i.pointer, s = a;
+		let t = this.cachedDataLength;
+		if (e.length > t) throw Error(`Can't insert ${e.length} array into shared list of ${t} dataLength`);
+		let i = this.memory.allocUI32(g + t * this.cachedByteMultipler), a = this.getDataBlock(i.data.buffer, i.data.byteOffset), o = i.pointer, s = a;
 		for (let t = 0; t < e.length; t++) this.cachedIsFloat ? s[t] = e[t] : (this.cachedIsBigInt, Atomics.store(a, t, e[t]));
 		let c = this.positionBits, l = this.positionMask;
 		for (;;) {
-			let e = t(this.firstBlock.data, y), r = this.getBufferView(e & l);
-			if (!r) continue;
-			let i = (e >>> c >>> 2) + C, a = Atomics.load(r, i);
-			if (e === t(this.firstBlock.data, y)) {
+			let e = n(this.firstBlock.data, y), t = this.getBufferView(e & l);
+			if (!t) continue;
+			let i = (e >>> c >>> 2) + C, a = Atomics.load(t, i);
+			if (e === n(this.firstBlock.data, y)) {
 				if (a === 0) {
-					if (Atomics.compareExchange(r, i, 0, o) === 0) {
-						n(this.firstBlock.data, y, o, e);
+					if (Atomics.compareExchange(t, i, 0, o) === 0) {
+						r(this.firstBlock.data, y, o, e);
 						break;
 					}
-				} else n(this.firstBlock.data, y, a, e);
+				} else r(this.firstBlock.data, y, a, e);
 			}
 		}
 		Atomics.add(this.firstBlock.data, b, 1);
@@ -110,18 +110,18 @@ var h = 7, g = 2, _ = g * Uint32Array.BYTES_PER_ELEMENT, v = 0, y = 1, b = 2, x
 		}
 	}
 	reclaimTombstones(e) {
-		let i = this.firstBlock.pointer, a = this.firstBlock.data, o = C, s = this.positionBits, c = this.positionMask, l = 0, u = t(a, o);
+		let t = this.firstBlock.pointer, a = this.firstBlock.data, o = C, s = this.positionBits, c = this.positionMask, l = 0, u = n(a, o);
 		for (; u;) {
-			let t = u & c, d = this.memory.buffers[t];
+			let n = u & c, d = this.memory.buffers[n];
 			if (!d) break;
-			let f = this.getBufferView(t), p = u >>> s, m = p >>> 2, h = Atomics.load(f, m + C);
+			let f = this.getBufferView(n), p = u >>> s, m = p >>> 2, h = Atomics.load(f, m + C);
 			if (Atomics.load(f, m + w)) {
 				if (h === 0 && !e) break;
-				r(a, o, h), n(this.firstBlock.data, y, i, u), d.free(p), l++;
-			} else i = u, a = f, o = m + C;
+				i(a, o, h), r(this.firstBlock.data, y, t, u), d.free(p), l++;
+			} else t = u, a = f, o = m + C;
 			u = h;
 		}
-		return e && r(this.firstBlock.data, y, i), l && Atomics.sub(this.firstBlock.data, x, l), l;
+		return e && i(this.firstBlock.data, y, t), l && Atomics.sub(this.firstBlock.data, x, l), l;
 	}
 	clear() {
 		c(this.lockArray);
@@ -132,13 +132,13 @@ var h = 7, g = 2, _ = g * Uint32Array.BYTES_PER_ELEMENT, v = 0, y = 1, b = 2, x
 		}
 	}
 	clearLocked() {
-		let e, i = !1;
-		for (; !i;) {
-			if (e = t(this.firstBlock.data, v), !e) return;
-			i = n(this.firstBlock.data, v, 0, e);
+		let e, t = !1;
+		for (; !t;) {
+			if (e = n(this.firstBlock.data, v), !e) return;
+			t = r(this.firstBlock.data, v, 0, e);
 		}
 		if (!e) return;
-		r(this.firstBlock.data, y, this.firstBlock.pointer);
+		i(this.firstBlock.data, y, this.firstBlock.pointer);
 		let a = 0, o = this.positionBits, s = this.positionMask, c = e;
 		for (; c;) {
 			let e = c & s, t = this.memory.buffers[e];
@@ -149,14 +149,14 @@ var h = 7, g = 2, _ = g * Uint32Array.BYTES_PER_ELEMENT, v = 0, y = 1, b = 2, x
 		Atomics.sub(this.firstBlock.data, b, a), Atomics.store(this.firstBlock.data, x, 0);
 	}
 	*[Symbol.iterator]() {
-		let e = 0, n = this.positionBits, r = this.positionMask;
+		let e = 0, t = this.positionBits, r = this.positionMask;
 		a(this.lockArray);
 		try {
-			let i = t(this.firstBlock.data, v);
+			let i = n(this.firstBlock.data, v);
 			for (; i;) {
-				let t = i & r, a = this.getBufferView(t);
+				let n = i & r, a = this.getBufferView(n);
 				if (!a) return;
-				let o = i >>> n, s = o >>> 2;
+				let o = i >>> t, s = o >>> 2;
 				if (i = Atomics.load(a, s + C), Atomics.load(a, s + w)) continue;
 				let c = a.buffer, l = s + w;
 				yield {
@@ -186,18 +186,17 @@ var h = 7, g = 2, _ = g * Uint32Array.BYTES_PER_ELEMENT, v = 0, y = 1, b = 2, x
 		return m(this.cachedType, e, n, this.cachedDataLength);
 	}
 	free() {
-		let { bufferPosition: t, bufferByteOffset: n } = e(this.firstBlock.data, v, this.positionBits);
-		for (; n;) {
-			let r = new i(this.memory, {
-				bufferPosition: t,
-				bufferByteOffset: n
+		let { bufferPosition: n, bufferByteOffset: r } = t(this.firstBlock.data, v, this.positionBits);
+		for (; r;) {
+			let i = new e(this.memory, {
+				bufferPosition: n,
+				bufferByteOffset: r
 			});
-			({bufferPosition: t, bufferByteOffset: n} = e(r.data, C, this.positionBits)), this.onDelete && !Atomics.load(r.data, w) && this.onDelete(this.getDataBlock(r.data.buffer, r.data.byteOffset)), r.free();
+			({bufferPosition: n, bufferByteOffset: r} = t(i.data, C, this.positionBits)), this.onDelete && !Atomics.load(i.data, w) && this.onDelete(this.getDataBlock(i.data.buffer, i.data.byteOffset)), i.free();
 		}
 		this.firstBlock.free();
 	}
 };
-//#endregion
 export { E as default };
 
 //# sourceMappingURL=shared-list.js.map