@daneren2005/shared-memory-objects 1.6.1 → 1.6.3

package/dist/shared-map.js

@@ -1,9 +1,9 @@
-import { getPointer as e, storeRawPointer as t } from "./utils/pointer.js";
-import n from "./allocated-memory.js";
-import { getArrayTypeCode as r, getByteMultipler as i, makeArrayView as a } from "./utils/array-type.js";
-import { lock as o, unlock as s } from "./lock/simple-lock.js";
-import { get32BitHash as c, mix32 as l } from "./utils/hash.js";
-//#region src/shared-map.ts
+import e from "./allocated-memory.js";
+import { getPointer as t, storeRawPointer as n } from "./utils/pointer.js";
+import { get32BitHash as r, mix32 as i } from "./utils/hash.js";
+import { lock as a, unlock as o } from "./lock/simple-lock.js";
+import { getArrayTypeCode as s, getByteMultipler as c, makeArrayView as l } from "./utils/array-type.js";
+// src/shared-map.ts
 var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4, x = 5, S = class S {
 	static ALLOCATE_COUNT = 6;
 	memory;
@@ -19,14 +19,14 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 	cachedValues;
 	cachedCapacity = 0;
 	ensureTable() {
-		let t = this.pointerMemory.data, r = t[g], i = t[b];
+		let n = this.pointerMemory.data, r = n[g], i = n[b];
 		if (r === this.cachedTablePointer && i === this.cachedCapacity && this.cachedSlots) return;
-		let a = new n(this.memory, e(r, this.memory.positionBits));
+		let a = new e(this.memory, t(r, this.memory.positionBits));
 		this.cachedTableMemory = a, this.cachedSlots = a.data, this.cachedValues = this.makeValuesView(a, i), this.cachedCapacity = i, this.cachedTablePointer = r;
 	}
 	makeValuesView(e, t) {
 		let n = e.bufferByteOffset + t * 2 * Uint32Array.BYTES_PER_ELEMENT;
-		return a(this.cachedType, e.data.buffer, n, t);
+		return l(this.cachedType, e.data.buffer, n, t);
 	}
 	tableLength(e) {
 		return e * (2 + this.cachedValueUnits);
@@ -44,39 +44,39 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 		return this.cachedType;
 	}
 	get usedMemory() {
-		o(this.lock);
+		a(this.lock);
 		try {
 			return this.ensureTable(), (this.ownsFirstBlock ? this.pointerMemory.usedMemory : 0) + this.cachedTableMemory.usedMemory;
 		} finally {
-			s(this.lock);
+			o(this.lock);
 		}
 	}
-	constructor(e, t) {
-		this.memory = e, t && "firstBlock" in t ? t.firstBlock instanceof n ? (this.pointerMemory = t.firstBlock, this.initialize(t), this.ownsFirstBlock = !1) : this.pointerMemory = new n(e, {
+	constructor(t, n) {
+		this.memory = t, n && "firstBlock" in n ? n.firstBlock instanceof e ? (this.pointerMemory = n.firstBlock, this.initialize(n), this.ownsFirstBlock = !1) : this.pointerMemory = new e(t, {
 			length: S.ALLOCATE_COUNT,
-			...t.firstBlock
-		}) : (this.pointerMemory = e.allocUI32(S.ALLOCATE_COUNT), this.initialize(t)), this.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + _ * Uint32Array.BYTES_PER_ELEMENT, 1), this.cachedType = Atomics.load(this.pointerMemory.data, x), this.cachedValueUnits = i(this.cachedType), this.maxTableCapacity = 2 ** Math.floor(Math.log2(this.memory.maxAllocationLength / (2 + this.cachedValueUnits)));
+			...n.firstBlock
+		}) : (this.pointerMemory = t.allocUI32(S.ALLOCATE_COUNT), this.initialize(n)), this.lock = new Int32Array(this.pointerMemory.data.buffer, this.pointerMemory.bufferByteOffset + _ * Uint32Array.BYTES_PER_ELEMENT, 1), this.cachedType = Atomics.load(this.pointerMemory.data, x), this.cachedValueUnits = c(this.cachedType), this.maxTableCapacity = 2 ** Math.floor(Math.log2(this.memory.maxAllocationLength / (2 + this.cachedValueUnits)));
 	}
 	initialize(e) {
-		let n = e && "type" in e ? e.type : void 0, a = r(n ?? Uint32Array);
-		this.cachedValueUnits = i(a);
-		let o = e && "capacity" in e ? e.capacity : void 0, s = p;
-		for (; s < (o ?? p);) s *= 2;
-		if (s * (2 + this.cachedValueUnits) > this.memory.maxAllocationLength) throw Error(`SharedMap capacity ${s} exceeds the largest contiguous allocation`);
-		let c = this.memory.allocUI32(s * (2 + this.cachedValueUnits));
-		t(this.pointerMemory.data, g, c.pointer), Atomics.store(this.pointerMemory.data, b, s), Atomics.store(this.pointerMemory.data, x, a);
+		let t = e && "type" in e ? e.type : void 0, r = s(t ?? Uint32Array);
+		this.cachedValueUnits = c(r);
+		let i = e && "capacity" in e ? e.capacity : void 0, a = p;
+		for (; a < (i ?? p);) a *= 2;
+		if (a * (2 + this.cachedValueUnits) > this.memory.maxAllocationLength) throw Error(`SharedMap capacity ${a} exceeds the largest contiguous allocation`);
+		let o = this.memory.allocUI32(a * (2 + this.cachedValueUnits));
+		n(this.pointerMemory.data, g, o.pointer), Atomics.store(this.pointerMemory.data, b, a), Atomics.store(this.pointerMemory.data, x, r);
 	}
 	set(e, t) {
-		o(this.lock);
+		a(this.lock);
 		try {
 			this.setNoLock(e, t);
 		} finally {
-			s(this.lock);
+			o(this.lock);
 		}
 	}
 	setAll(e) {
 		let t = Array.from(e);
-		o(this.lock);
+		a(this.lock);
 		try {
 			let e = this.pointerMemory.data, n = e[v] + e[y] + t.length;
 			if (n * h > e[b] * m) {
@@ -86,18 +86,18 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 			}
 			for (let [e, n] of t) this.setNoLock(e, n);
 		} finally {
-			s(this.lock);
+			o(this.lock);
 		}
 	}
 	setNoLock(e, t) {
-		let n = c(e), r = this.pointerMemory.data;
-		(r[v] + r[y] + 1) * h > r[b] * m && this.resizeForInsert(e), this.ensureTable();
-		let i = this.cachedSlots, a = this.cachedValues, o = this.cachedCapacity, s = o - 1, p = o, g = l(n) & s, _ = -1;
+		let n = r(e), a = this.pointerMemory.data;
+		(a[v] + a[y] + 1) * h > a[b] * m && this.resizeForInsert(e), this.ensureTable();
+		let o = this.cachedSlots, s = this.cachedValues, c = this.cachedCapacity, l = c - 1, p = c, g = i(n) & l, _ = -1;
 		for (;;) {
-			let e = i[g];
+			let e = o[g];
 			if (e === u) {
 				let e = _ >= 0 ? _ : g;
-				i[e] = d, i[p + e] = n, a[e] = t, r[v]++, _ >= 0 && r[y]--;
+				o[e] = d, o[p + e] = n, s[e] = t, a[v]++, _ >= 0 && a[y]--;
 				return;
 			}
 			if (e === f) {
@@ -106,37 +106,37 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 					this.reuseTombstone(g, n, t);
 					return;
 				}
-			} else if (i[p + g] === n) {
-				a[g] = t;
+			} else if (o[p + g] === n) {
+				s[g] = t;
 				return;
 			}
-			g = g + 1 & s;
+			g = g + 1 & l;
 		}
 	}
 	update(e, t) {
-		let n = c(e);
-		o(this.lock);
+		let n = r(e);
+		a(this.lock);
 		try {
 			let r = this.pointerMemory.data;
 			(r[v] + r[y] + 1) * h > r[b] * m && this.resizeForInsert(e), this.ensureTable();
-			let i = this.cachedSlots, a = this.cachedValues, o = this.cachedCapacity, s = o - 1, c = l(n) & s, p = -1;
+			let a = this.cachedSlots, o = this.cachedValues, s = this.cachedCapacity, c = s - 1, l = i(n) & c, p = -1;
 			for (;;) {
-				let e = i[c];
+				let e = a[l];
 				if (e === u) {
-					let e = t(void 0), s = p >= 0 ? p : c;
-					return i[s] = d, i[o + s] = n, a[s] = e, r[v]++, p >= 0 && r[y]--, e;
+					let e = t(void 0), i = p >= 0 ? p : l;
+					return a[i] = d, a[s + i] = n, o[i] = e, r[v]++, p >= 0 && r[y]--, e;
 				}
 				if (e === f) {
-					if (c === p) return this.reuseTombstone(c, n, t);
-					p < 0 && (p = c);
-				} else if (i[o + c] === n) {
-					let e = t(a[c]);
-					return a[c] = e, e;
+					if (l === p) return this.reuseTombstone(l, n, t);
+					p < 0 && (p = l);
+				} else if (a[s + l] === n) {
+					let e = t(o[l]);
+					return o[l] = e, e;
 				}
-				c = c + 1 & s;
+				l = l + 1 & c;
 			}
 		} finally {
-			s(this.lock);
+			o(this.lock);
 		}
 	}
 	resizeForInsert(e) {
@@ -149,52 +149,52 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 		return i[e] = d, i[this.cachedCapacity + e] = t, a[e] = r, this.pointerMemory.data[v]++, this.pointerMemory.data[y]--, r;
 	}
 	get(e) {
-		o(this.lock);
+		a(this.lock);
 		try {
 			return this.getNoLock(e);
 		} finally {
-			s(this.lock);
+			o(this.lock);
 		}
 	}
 	getAll(e) {
-		o(this.lock);
+		a(this.lock);
 		try {
 			let t = [];
 			for (let n of e) t.push(this.getNoLock(n));
 			return t;
 		} finally {
-			s(this.lock);
+			o(this.lock);
 		}
 	}
 	getNoLock(e) {
-		let t = c(e);
+		let t = r(e);
 		this.ensureTable();
-		let n = this.cachedSlots, r = this.cachedValues, i = this.cachedCapacity, a = i - 1, o = i, s = l(t) & a, f = s;
+		let n = this.cachedSlots, a = this.cachedValues, o = this.cachedCapacity, s = o - 1, c = o, l = i(t) & s, f = l;
 		do {
-			let e = n[s];
+			let e = n[l];
 			if (e === u) return;
-			if (e === d && n[o + s] === t) return r[s];
-			s = s + 1 & a;
-		} while (s !== f);
+			if (e === d && n[c + l] === t) return a[l];
+			l = l + 1 & s;
+		} while (l !== f);
 	}
 	has(e) {
 		return this.get(e) !== void 0;
 	}
 	delete(e) {
-		let t = c(e);
-		o(this.lock);
+		let t = r(e);
+		a(this.lock);
 		try {
 			this.ensureTable();
-			let e = this.pointerMemory.data, n = this.cachedSlots, r = this.cachedCapacity, i = r - 1, a = r, o = l(t) & i, s = o;
+			let e = this.pointerMemory.data, n = this.cachedSlots, r = this.cachedCapacity, a = r - 1, o = r, s = i(t) & a, c = s;
 			do {
-				let r = n[o];
+				let r = n[s];
 				if (r === u) return !1;
-				if (r === d && n[a + o] === t) return n[o] = f, e[v]--, e[y]++, !0;
-				o = o + 1 & i;
-			} while (o !== s);
+				if (r === d && n[o + s] === t) return n[s] = f, e[v]--, e[y]++, !0;
+				s = s + 1 & a;
+			} while (s !== c);
 			return !1;
 		} finally {
-			s(this.lock);
+			o(this.lock);
 		}
 	}
 	*[Symbol.iterator]() {
@@ -204,19 +204,19 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 	}
 	resize(e) {
 		this.ensureTable();
-		let n = this.cachedTableMemory, r = this.cachedSlots, i = this.cachedValues, a = this.cachedCapacity, o = a, s = Atomics.load(this.pointerMemory.data, v), c = e ?? a;
-		if (e === void 0 && (s + 1) * h > a * m && (c = a * 2), this.tableLength(c) > this.memory.maxAllocationLength) {
+		let t = this.cachedTableMemory, r = this.cachedSlots, a = this.cachedValues, o = this.cachedCapacity, s = o, c = Atomics.load(this.pointerMemory.data, v), l = e ?? o;
+		if (e === void 0 && (c + 1) * h > o * m && (l = o * 2), this.tableLength(l) > this.memory.maxAllocationLength) {
 			let e = Math.floor(this.memory.maxAllocationLength / (2 + this.cachedValueUnits) * m / h);
-			throw Error(`SharedMap can't grow to capacity ${c}: its table would exceed the largest contiguous allocation (${this.memory.maxAllocationLength} u32s, ~${e} entries). Use larger buffers or shard across multiple maps.`);
+			throw Error(`SharedMap can't grow to capacity ${l}: its table would exceed the largest contiguous allocation (${this.memory.maxAllocationLength} u32s, ~${e} entries). Use larger buffers or shard across multiple maps.`);
 		}
-		let f = this.memory.allocUI32(this.tableLength(c)), p = f.data, _ = this.makeValuesView(f, c), x = c - 1, S = c;
-		for (let e = 0; e < a; e++) {
+		let f = this.memory.allocUI32(this.tableLength(l)), p = f.data, _ = this.makeValuesView(f, l), x = l - 1, S = l;
+		for (let e = 0; e < o; e++) {
 			if (r[e] !== d) continue;
-			let t = r[o + e], n = i[e], a = l(t) & x;
-			for (; p[a] !== u;) a = a + 1 & x;
-			p[a] = d, p[S + a] = t, _[a] = n;
+			let t = r[s + e], n = a[e], o = i(t) & x;
+			for (; p[o] !== u;) o = o + 1 & x;
+			p[o] = d, p[S + o] = t, _[o] = n;
 		}
-		t(this.pointerMemory.data, g, f.pointer), Atomics.store(this.pointerMemory.data, b, c), Atomics.store(this.pointerMemory.data, y, 0), this.cachedTablePointer = 0, this.cachedSlots = void 0, n.free();
+		n(this.pointerMemory.data, g, f.pointer), Atomics.store(this.pointerMemory.data, b, l), Atomics.store(this.pointerMemory.data, y, 0), this.cachedTablePointer = 0, this.cachedSlots = void 0, t.free();
 	}
 	free() {
 		this.ensureTable(), this.cachedTableMemory.free(), this.ownsFirstBlock && this.pointerMemory.free();
@@ -225,7 +225,6 @@ var u = 0, d = 1, f = 2, p = 16, m = 3, h = 4, g = 0, _ = 1, v = 2, y = 3, b = 4
 		return { firstBlock: this.pointerMemory.getSharedMemory() };
 	}
 };
-//#endregion
 export { S as default };
 
 //# sourceMappingURL=shared-map.js.map

package/dist/shared-pointer-list.js

@@ -1,31 +1,31 @@
-import { createPointer as e, loadPointer as t } from "./utils/pointer.js";
-import n from "./allocated-memory.js";
-import r from "./shared-list.js";
-//#region src/shared-pointer-list.ts
+import e from "./allocated-memory.js";
+import t from "./shared-list.js";
+import { createPointer as n, loadPointer as r } from "./utils/pointer.js";
+// src/shared-pointer-list.ts
 var i = class {
 	memory;
 	list;
-	constructor(e, t) {
-		this.memory = e, this.list = t ? new r(e, t) : new r(e);
+	constructor(e, n) {
+		this.memory = e, this.list = n ? new t(e, n) : new t(e);
 	}
 	get length() {
 		return this.list.length;
 	}
-	insert(t) {
-		this.list.insert(e(t.memory.bufferPosition, t.memory.bufferByteOffset, this.memory.positionBits));
+	insert(e) {
+		this.list.insert(n(e.memory.bufferPosition, e.memory.bufferByteOffset, this.memory.positionBits));
 	}
-	delete(t) {
-		let n = this.list.deleteValue(e(t.memory.bufferPosition, t.memory.bufferByteOffset, this.memory.positionBits));
-		return this.list.compact(), n;
+	delete(e) {
+		let t = this.list.deleteValue(n(e.memory.bufferPosition, e.memory.bufferByteOffset, this.memory.positionBits));
+		return this.list.compact(), t;
 	}
 	compact() {
 		this.list.compact();
 	}
 	*[Symbol.iterator]() {
-		let e = this.list[Symbol.iterator]();
-		for (let { data: r } of e) {
-			let { bufferPosition: e, bufferByteOffset: i } = t(r, 0, this.memory.positionBits), a = new n(this.memory, {
-				bufferPosition: e,
+		let t = this.list[Symbol.iterator]();
+		for (let { data: n } of t) {
+			let { bufferPosition: t, bufferByteOffset: i } = r(n, 0, this.memory.positionBits), a = new e(this.memory, {
+				bufferPosition: t,
 				bufferByteOffset: i
 			});
 			yield this.createItem(a);
@@ -45,7 +45,6 @@ var i = class {
 		this.list.free();
 	}
 };
-//#endregion
 export { i as default };
 
 //# sourceMappingURL=shared-pointer-list.js.map

package/dist/shared-pool.d.ts

@@ -39,6 +39,7 @@ export default class SharedPool<T extends NumericArray = Uint32Array> implements
     reserveContiguous(count: number): number;
     deleteIndex(index: number): void;
     clear(): void;
+    getRecycledMask(): Uint8Array;
     [Symbol.iterator](): Generator<T, void, unknown>;
     entries(): IterableIterator<[number, T]>;
     private getFullDataBlock;

package/dist/shared-pool.js

@@ -1,14 +1,14 @@
-import { getPointer as e, loadRawPointer as t, storeRawPointer as n } from "./utils/pointer.js";
-import r from "./allocated-memory.js";
-import { getArrayTypeCode as i, getByteMultipler as a, makeArrayView as o } from "./utils/array-type.js";
-import { lock as s, unlock as c } from "./lock/simple-lock.js";
-import l from "./shared-stack.js";
-//#region src/shared-pool.ts
+import e from "./allocated-memory.js";
+import { lock as t, unlock as n } from "./lock/simple-lock.js";
+import r from "./shared-stack.js";
+import { getPointer as i, loadRawPointer as a, storeRawPointer as o } from "./utils/pointer.js";
+import { getArrayTypeCode as s, getByteMultipler as c, makeArrayView as l } from "./utils/array-type.js";
+// src/shared-pool.ts
 var u = 0, d = 1, f = 2, p = 3, m = 4, h = 5, g = 100, _ = 1e6, v = 1e5, y = class y {
 	static ALLOCATE_COUNT = 6;
 	static getAllocateCount(e, t) {
-		let n = t?.maxChunkSize ?? g, r = t?.maxLength ?? _, i = t?.maxRecycledLength ?? v, a = l.getMaxSegmentLength(e.maxAllocationLength), o = l.getAllocateCount(r / n, void 0, a), s = l.getAllocateCount(i, void 0, a);
-		return y.ALLOCATE_COUNT + o + s;
+		let n = t?.maxChunkSize ?? g, i = t?.maxLength ?? _, a = t?.maxRecycledLength ?? v, o = r.getMaxSegmentLength(e.maxAllocationLength), s = r.getAllocateCount(i / n, void 0, o), c = r.getAllocateCount(a, void 0, o);
+		return y.ALLOCATE_COUNT + s + c;
 	}
 	memory;
 	firstBlock;
@@ -52,29 +52,29 @@ var u = 0, d = 1, f = 2, p = 3, m = 4, h = 5, g = 100, _ = 1e6, v = 1e5, y = cla
 	}
 	get usedMemory() {
 		let t = this.ownsFirstBlock ? this.firstBlock.usedMemory : 0;
-		for (let n of this.pointerStack) t += new r(this.memory, e(n, this.memory.positionBits)).usedMemory;
+		for (let n of this.pointerStack) t += new e(this.memory, i(n, this.memory.positionBits)).usedMemory;
 		return t + this.pointerStack.usedMemory + this.recycleStack.usedMemory;
 	}
-	constructor(n, i) {
-		this.memory = n, i && "firstBlock" in i ? (this.firstBlock = i.firstBlock instanceof r ? i.firstBlock : new r(n, {
+	constructor(t, n) {
+		this.memory = t, n && "firstBlock" in n ? (this.firstBlock = n.firstBlock instanceof e ? n.firstBlock : new e(t, {
 			length: y.ALLOCATE_COUNT,
-			...i.firstBlock
-		}), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + d * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in i || "dataLength" in i || "maxLength" in i || "maxChunkSize" in i || "maxRecycledLength" in i ? (this.initialize(i), this.ownsFirstBlock = !1) : (this.pointerStack = new l(n, { firstBlock: e(t(this.firstBlock.data, m), n.positionBits) }), this.recycleStack = new l(n, { firstBlock: e(t(this.firstBlock.data, h), n.positionBits) }), this.ownsFirstBlock = !0)) : (this.firstBlock = n.allocUI32(y.getAllocateCount(n, i)), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + d * Uint32Array.BYTES_PER_ELEMENT, 2), this.initialize(i), this.ownsFirstBlock = !0), this.cachedType = this.uint16Array[0], this.cachedDataLength = Math.max(1, this.uint16Array[1]), this.cachedMaxChunkSize = this.firstBlock.data[f], this.cachedByteMultipler = a(this.cachedType), this.maxLength = this.cachedMaxChunkSize * this.pointerStack.maxLength, this.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + p * Uint32Array.BYTES_PER_ELEMENT, 1);
+			...n.firstBlock
+		}), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + d * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in n || "dataLength" in n || "maxLength" in n || "maxChunkSize" in n || "maxRecycledLength" in n ? (this.initialize(n), this.ownsFirstBlock = !1) : (this.pointerStack = new r(t, { firstBlock: i(a(this.firstBlock.data, m), t.positionBits) }), this.recycleStack = new r(t, { firstBlock: i(a(this.firstBlock.data, h), t.positionBits) }), this.ownsFirstBlock = !0)) : (this.firstBlock = t.allocUI32(y.getAllocateCount(t, n)), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + d * Uint32Array.BYTES_PER_ELEMENT, 2), this.initialize(n), this.ownsFirstBlock = !0), this.cachedType = this.uint16Array[0], this.cachedDataLength = Math.max(1, this.uint16Array[1]), this.cachedMaxChunkSize = this.firstBlock.data[f], this.cachedByteMultipler = c(this.cachedType), this.maxLength = this.cachedMaxChunkSize * this.pointerStack.maxLength, this.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + p * Uint32Array.BYTES_PER_ELEMENT, 1);
 	}
 	initialize(e) {
-		let t = e?.dataLength ?? 1, r = e?.maxChunkSize ?? g, o = e?.maxLength ?? _, s = e?.maxRecycledLength ?? v, c = l.getMaxSegmentLength(this.memory.maxAllocationLength), u = o / r, d = l.getAllocateCount(u, void 0, c), f = l.getAllocateCount(s, void 0, c);
-		this.pointerStack = new l(this.memory, {
+		let t = e?.dataLength ?? 1, n = e?.maxChunkSize ?? g, i = e?.maxLength ?? _, a = e?.maxRecycledLength ?? v, l = r.getMaxSegmentLength(this.memory.maxAllocationLength), u = i / n, d = r.getAllocateCount(u, void 0, l), f = r.getAllocateCount(a, void 0, l);
+		this.pointerStack = new r(this.memory, {
 			firstBlock: this.firstBlock.getSubAllocation(y.ALLOCATE_COUNT, d),
 			type: Uint32Array,
 			maxLength: u
-		}), n(this.firstBlock.data, m, this.pointerStack.pointer), this.recycleStack = new l(this.memory, {
+		}), o(this.firstBlock.data, m, this.pointerStack.pointer), this.recycleStack = new r(this.memory, {
 			firstBlock: this.firstBlock.getSubAllocation(y.ALLOCATE_COUNT + d, f),
 			type: Uint32Array,
-			maxLength: s
-		}), n(this.firstBlock.data, h, this.recycleStack.pointer);
-		let p = i(e?.type ?? Uint32Array);
-		this.type = p, this.dataLength = t, this.maxChunkSize = r;
-		let b = a(p), x = this.memory.allocUI32(r * t * b);
+			maxLength: a
+		}), o(this.firstBlock.data, h, this.recycleStack.pointer);
+		let p = s(e?.type ?? Uint32Array);
+		this.type = p, this.dataLength = t, this.maxChunkSize = n;
+		let b = c(p), x = this.memory.allocUI32(n * t * b);
 		this.pointerStack.push(x.pointer);
 	}
 	at(e) {
@@ -118,6 +118,11 @@ var u = 0, d = 1, f = 2, p = 3, m = 4, h = 5, g = 100, _ = 1e6, v = 1e5, y = cla
 	clear() {
 		this.firstBlock.data[u] = 0, this.recycleStack.clear();
 	}
+	getRecycledMask() {
+		let e = Atomics.load(this.firstBlock.data, u), t = new Uint8Array(e);
+		for (let n of this.recycleStack) n < e && (t[n] = 1);
+		return t;
+	}
 	*[Symbol.iterator]() {
 		let e = {};
 		for (let t of this.recycleStack) e[t] = !0;
@@ -136,22 +141,22 @@ var u = 0, d = 1, f = 2, p = 3, m = 4, h = 5, g = 100, _ = 1e6, v = 1e5, y = cla
 			e !== i && (r = this.getFullDataBlock(a), i = e), yield [a, this.getDataBlock(r, a % t)];
 		}
 	}
-	getFullDataBlock(t) {
-		let n = Math.floor(t / this.cachedMaxChunkSize), i = this.cachedFullDataBlock[n];
-		if (i) return i;
-		if (n >= this.pointerStack.length) {
-			s(this.growLock);
+	getFullDataBlock(r) {
+		let a = Math.floor(r / this.cachedMaxChunkSize), o = this.cachedFullDataBlock[a];
+		if (o) return o;
+		if (a >= this.pointerStack.length) {
+			t(this.growLock);
 			try {
-				for (; n >= this.pointerStack.length;) {
+				for (; a >= this.pointerStack.length;) {
 					let e = this.memory.allocUI32(this.cachedMaxChunkSize * this.cachedDataLength * this.cachedByteMultipler);
 					this.pointerStack.push(e.pointer);
 				}
 			} finally {
-				c(this.growLock);
+				n(this.growLock);
 			}
 		}
-		let a = new r(this.memory, e(this.pointerStack.at(n), this.memory.positionBits)), l = this.cachedDataLength * this.cachedMaxChunkSize, u = o(this.cachedType, a.data.buffer, a.bufferByteOffset, l);
-		return this.cachedFullDataBlock[n] = u, u;
+		let s = new e(this.memory, i(this.pointerStack.at(a), this.memory.positionBits)), c = this.cachedDataLength * this.cachedMaxChunkSize, u = l(this.cachedType, s.data.buffer, s.bufferByteOffset, c);
+		return this.cachedFullDataBlock[a] = u, u;
 	}
 	getDataBlock(e, t) {
 		let n = this.cachedDataLength, r = t * n;
@@ -159,14 +164,13 @@ var u = 0, d = 1, f = 2, p = 3, m = 4, h = 5, g = 100, _ = 1e6, v = 1e5, y = cla
 	}
 	free() {
 		this.recycleStack.free();
-		for (let t of this.pointerStack) new r(this.memory, e(t, this.memory.positionBits)).free();
+		for (let t of this.pointerStack) new e(this.memory, i(t, this.memory.positionBits)).free();
 		this.pointerStack.free(), this.ownsFirstBlock && this.firstBlock.free();
 	}
 	getSharedMemory() {
 		return { firstBlock: this.firstBlock.getSharedMemory() };
 	}
 };
-//#endregion
 export { y as default };
 
 //# sourceMappingURL=shared-pool.js.map

package/dist/shared-pool.js.map

@@ -1 +1 @@
-{"version":3,"file":"shared-pool.js","names":["AllocatedMemory","SharedStack","LENGTH_INDEX","TYPE_INDEX","MAX_CHUNK_SIZE_INDEX","GROW_LOCK_INDEX","POINTER_STACK_INDEX","RECYCLE_STACK_INDEX","DEFAULT_MAX_CHUNK_SIZE","DEFAULT_MAX_LENGTH","DEFAULT_MAX_RECYCLED_LENGTH","SharedPool","maxChunkSize","config","maxLength","maxRecycledLength","maxSegmentLength","memory","pointerStackAllocateCount","recycleStackAllocateCount","value","total","pointer","getPointer","loadRawPointer","getByteMultipler","dataLength","pointerStackMaxLength","storeRawPointer","typeCode","getArrayTypeCode","byteMultipler","firstArray","dataBlock","index","dataIndex","isSingleValue","values","newIndex","startIndex","i","count","recycledValues","length","dataBlockIndex","newDataBlockIndex","pointerIndex","cachedDataBlock","newArray","array","blockLength","data","makeArrayView","start","rawData"],"sources":["../src/shared-pool.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport { lock, unlock } from './lock/simple-lock';\nimport type MemoryHeap from './memory-heap';\nimport SharedStack from './shared-stack';\nimport { getPointer, loadRawPointer, storeRawPointer } from './utils/pointer';\nimport { getArrayTypeCode, getByteMultipler, makeArrayView, type NumericArray, type NumericArrayIO, type TypedArrayConstructor } from './utils/array-type';\n\nconst LENGTH_INDEX = 0;\nconst TYPE_INDEX = 1;\nconst MAX_CHUNK_SIZE_INDEX = 2;\n// Guards appending a chunk pointer so only one thread grows the pointer stack at a time\nconst GROW_LOCK_INDEX = 3;\n// Pointers to the two backing SharedStacks (their own firstBlocks): the chunk pointers and the recycled indexes\nconst POINTER_STACK_INDEX = 4;\nconst RECYCLE_STACK_INDEX = 5;\n\nconst DEFAULT_MAX_CHUNK_SIZE = 100;\nconst DEFAULT_MAX_LENGTH = 1_000_000;\nconst DEFAULT_MAX_RECYCLED_LENGTH = 100_000;\n\n// Array with stable indexes and maximum contiguous memory sizes (necessary to fit large data sets into max 1MB buffers).\n// The chunk pointers and the recycled indexes both live in SharedStacks, whose segments are never moved or freed once\n// published, so concurrent readers never touch memory that is being reclaimed.\n// https://plflib.org/colony.htm for future enhancements - it seems to be an optimized version of what we were aiming for with this\nexport default class SharedPool<T extends NumericArray = Uint32Array> implements Iterable<T> {\n\tstatic readonly ALLOCATE_COUNT = 6;\n\n\t// u32s a pool with this config needs for its firstBlock, including both inlined stacks. Lets an owner (e.g.\n\t// SharedQuadtree) reserve one contiguous slice and hand it back through the config's firstBlock to inline the pool.\n\tstatic getAllocateCount(memory: MemoryHeap, config?: SharedPoolConfig<NumericArray>): number {\n\t\tlet maxChunkSize = config?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;\n\t\tlet maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;\n\t\tlet maxRecycledLength = config?.maxRecycledLength ?? DEFAULT_MAX_RECYCLED_LENGTH;\n\t\tlet maxSegmentLength = SharedStack.getMaxSegmentLength(memory.maxAllocationLength);\n\t\tlet pointerStackAllocateCount = SharedStack.getAllocateCount(maxLength / maxChunkSize, undefined, maxSegmentLength);\n\t\tlet recycleStackAllocateCount = SharedStack.getAllocateCount(maxRecycledLength, undefined, maxSegmentLength);\n\t\treturn SharedPool.ALLOCATE_COUNT + pointerStackAllocateCount + recycleStackAllocateCount;\n\t}\n\n\tprivate memory: MemoryHeap;\n\n\t// Current Length, Type/DataLength, MaxChunkLength, Grow lock, Pointer stack, Recycle stack\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tprivate growLock: Int32Array;\n\tprivate pointerStack!: SharedStack;\n\tprivate recycleStack!: SharedStack;\n\treadonly maxLength: number;\n\n\t// False when firstBlock is a slice of another structure's memory (e.g. inlined in SharedQuadtree); that owner frees it\n\tprivate ownsFirstBlock: boolean;\n\n\t// Chunk views cached by pointer index. An array (dense, small integer keys) resolves faster than an object on the hot\n\t// get/set path and never needs rehashing.\n\tprivate cachedFullDataBlock: Array<T | undefined> = [];\n\n\t// Config is written once at construction and never mutated, so it is cached in plain fields\n\tprivate readonly cachedMaxChunkSize: number;\n\tprivate readonly cachedDataLength: number;\n\tprivate readonly cachedType: number;\n\tprivate readonly cachedByteMultipler: number;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX) - this.recycleStack.length;\n\t}\n\tget maxChunkSize(): number {\n\t\treturn this.cachedMaxChunkSize;\n\t}\n\tprivate set maxChunkSize(value: number) {\n\t\tAtomics.store(this.firstBlock.data, MAX_CHUNK_SIZE_INDEX, value);\n\t}\n\n\tget type(): number {\n\t\treturn this.cachedType;\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\tget dataLength(): number {\n\t\treturn this.cachedDataLength;\n\t}\n\tprivate set dataLength(value: number) {\n\t\tAtomics.store(this.uint16Array, 1, value);\n\t}\n\n\tget bufferLength(): number {\n\t\treturn this.cachedMaxChunkSize * this.pointerStack.length;\n\t}\n\tget byteMultipler(): number {\n\t\treturn this.cachedByteMultipler;\n\t}\n\n\t// Own internal memory (which already includes both stacks' inlined firstBlocks) plus every chunk buffer and the\n\t// segments each stack has grown. The stacks' usedMemory excludes their inlined firstBlocks, so they aren't double-counted.\n\tget usedMemory(): number {\n\t\tlet total = this.ownsFirstBlock ? this.firstBlock.usedMemory : 0;\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\ttotal += new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits)).usedMemory;\n\t\t}\n\t\treturn total + this.pointerStack.usedMemory + this.recycleStack.usedMemory;\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedPoolConfig<T> | SharedPoolMemory | SharedPoolMemory & SharedPoolConfig<T>) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\t// An AllocatedMemory instance is a caller-reserved slice (e.g. inlined in SharedQuadtree); a plain pointer is the\n\t\t\t// serialized clone path. Taking the instance directly keeps us off the pointer-resolving construction branch.\n\t\t\tthis.firstBlock = config.firstBlock instanceof AllocatedMemory\n\t\t\t\t? config.firstBlock\n\t\t\t\t: new AllocatedMemory(memory, { length: SharedPool.ALLOCATE_COUNT, ...config.firstBlock });\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\n\t\t\t// Memory passed together with config means the caller reserved the firstBlock slot for us to initialize in place\n\t\t\tif('type' in config || 'dataLength' in config || 'maxLength' in config || 'maxChunkSize' in config || 'maxRecycledLength' in config) {\n\t\t\t\tthis.initialize(config);\n\t\t\t\tthis.ownsFirstBlock = false;\n\t\t\t} else {\n\t\t\t\tthis.pointerStack = new SharedStack(memory, {\n\t\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, POINTER_STACK_INDEX), memory.positionBits),\n\t\t\t\t});\n\t\t\t\tthis.recycleStack = new SharedStack(memory, {\n\t\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX), memory.positionBits),\n\t\t\t\t});\n\t\t\t\tthis.ownsFirstBlock = true;\n\t\t\t}\n\t\t} else {\n\t\t\tthis.firstBlock = memory.allocUI32(SharedPool.getAllocateCount(memory, config));\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\t\t\tthis.initialize(config);\n\t\t\tthis.ownsFirstBlock = true;\n\t\t}\n\n\t\tthis.cachedType = this.uint16Array[0];\n\t\tthis.cachedDataLength = Math.max(1, this.uint16Array[1]);\n\t\tthis.cachedMaxChunkSize = this.firstBlock.data[MAX_CHUNK_SIZE_INDEX];\n\t\tthis.cachedByteMultipler = getByteMultipler(this.cachedType);\n\t\tthis.maxLength = this.cachedMaxChunkSize * this.pointerStack.maxLength;\n\n\t\tthis.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + GROW_LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, 1);\n\t}\n\n\t// Lay out the two inlined stacks (their firstBlocks sliced from ours), record their pointers, and seed the first chunk.\n\t// firstBlock and uint16Array must already be set. Used by both the fresh-alloc path and the inline-in-place path.\n\tprivate initialize(config?: SharedPoolConfig<T>) {\n\t\tlet dataLength = config?.dataLength ?? 1;\n\t\tlet maxChunkSize = config?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;\n\t\tlet maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;\n\t\tlet maxRecycledLength = config?.maxRecycledLength ?? DEFAULT_MAX_RECYCLED_LENGTH;\n\n\t\t// Each stack sizes its inlined firstBlock from its own maxLength, so compute both up front to lay them out. The\n\t\t// stacks cap their segments at what a buffer can hold, so size the inlined blocks against that same cap.\n\t\tlet maxSegmentLength = SharedStack.getMaxSegmentLength(this.memory.maxAllocationLength);\n\t\tlet pointerStackMaxLength = maxLength / maxChunkSize;\n\t\tlet pointerStackAllocateCount = SharedStack.getAllocateCount(pointerStackMaxLength, undefined, maxSegmentLength);\n\t\tlet recycleStackAllocateCount = SharedStack.getAllocateCount(maxRecycledLength, undefined, maxSegmentLength);\n\n\t\t// Inline both stacks' firstBlocks right after the pool header so the whole spine is one contiguous allocation\n\t\tthis.pointerStack = new SharedStack(this.memory, {\n\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT, pointerStackAllocateCount),\n\t\t\ttype: Uint32Array,\n\t\t\tmaxLength: pointerStackMaxLength,\n\t\t});\n\t\tstoreRawPointer(this.firstBlock.data, POINTER_STACK_INDEX, this.pointerStack.pointer);\n\t\tthis.recycleStack = new SharedStack(this.memory, {\n\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT + pointerStackAllocateCount, recycleStackAllocateCount),\n\t\t\ttype: Uint32Array,\n\t\t\tmaxLength: maxRecycledLength,\n\t\t});\n\t\tstoreRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX, this.recycleStack.pointer);\n\n\t\tlet typeCode = getArrayTypeCode(config?.type ?? Uint32Array);\n\t\tthis.type = typeCode;\n\t\tthis.dataLength = dataLength;\n\t\tthis.maxChunkSize = maxChunkSize;\n\n\t\tlet byteMultipler = getByteMultipler(typeCode);\n\t\tlet firstArray = this.memory.allocUI32(maxChunkSize * dataLength * byteMultipler);\n\t\tthis.pointerStack.push(firstArray.pointer);\n\t}\n\n\tat(index: number): T {\n\t\tlet dataBlock = this.getFullDataBlock(index);\n\t\treturn this.getDataBlock(dataBlock, index % this.cachedMaxChunkSize);\n\t}\n\tget(index: number, dataIndex = 0): T[number] {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(index) as NumericArrayIO;\n\t\treturn dataBlock[(index % this.cachedMaxChunkSize) * dataLength + dataIndex];\n\t}\n\tset(index: number, dataIndex: number, value: T[number]) {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(index) as NumericArrayIO;\n\t\tdataBlock[(index % this.cachedMaxChunkSize) * dataLength + dataIndex] = value;\n\t}\n\n\t// Resolve the chunk view holding an index once. Callers touching several fields of the same record read/write straight\n\t// into this view at blockOffset(index) + fieldIndex, avoiding a repeated chunk lookup per field.\n\tblockFor(index: number): T {\n\t\treturn this.getFullDataBlock(index);\n\t}\n\t// Base slot of a record within the view blockFor(index) returns.\n\tblockOffset(index: number): number {\n\t\treturn (index % this.cachedMaxChunkSize) * this.cachedDataLength;\n\t}\n\n\tpush(values: T[number] | Array<T[number]>): number {\n\t\tlet dataLength = this.cachedDataLength;\n\t\tconst isSingleValue = typeof values !== 'object';\n\t\tif(!isSingleValue && values.length > dataLength) {\n\t\t\tthrow new Error(`Can't insert ${values.length} array into shared list of ${dataLength} dataLength`);\n\t\t}\n\n\t\t// Reuse a recycled index if one is available. pop() can come back undefined when another thread drained the last\n\t\t// slot between our two calls, so fall through to a fresh index rather than trusting a length() read\n\t\tlet newIndex = this.recycleStack.length === 0 ? undefined : this.recycleStack.pop();\n\t\tif(newIndex === undefined) {\n\t\t\tnewIndex = Atomics.add(this.firstBlock.data, LENGTH_INDEX, 1);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(newIndex) as NumericArrayIO;\n\t\tlet startIndex = dataLength * (newIndex % this.cachedMaxChunkSize);\n\t\tif(isSingleValue) {\n\t\t\tdataBlock[startIndex] = values;\n\t\t} else {\n\t\t\tfor(let i = 0; i < values.length; i++) {\n\t\t\t\tdataBlock[startIndex + i] = values[i];\n\t\t\t}\n\t\t}\n\n\t\treturn newIndex;\n\t}\n\n\treserveContiguous(count: number): number {\n\t\tif(!Number.isInteger(count) || count < 0) {\n\t\t\tthrow new Error(`Can't reserve ${count} pool entries`);\n\t\t}\n\t\treturn Atomics.add(this.firstBlock.data, LENGTH_INDEX, count);\n\t}\n\n\tdeleteIndex(index: number) {\n\t\tthis.recycleStack.push(index);\n\t}\n\n\tclear() {\n\t\tthis.firstBlock.data[LENGTH_INDEX] = 0;\n\t\tthis.recycleStack.clear();\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleStack) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tconst maxChunkSize = this.cachedMaxChunkSize;\n\t\t// Snapshot the length once - iteration over a concurrently mutated pool is a snapshot anyway, and re-loading the\n\t\t// atomic every step is pure overhead\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < length; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield this.getDataBlock(dataBlock, i % maxChunkSize);\n\t\t\t}\n\t\t}\n\t}\n\n\t*entries(): IterableIterator<[number, T]> {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleStack) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tconst maxChunkSize = this.cachedMaxChunkSize;\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < length; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield [i, this.getDataBlock(dataBlock, i % maxChunkSize)];\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getFullDataBlock(index: number) {\n\t\tlet pointerIndex = Math.floor(index / this.cachedMaxChunkSize);\n\t\tlet cachedDataBlock = this.cachedFullDataBlock[pointerIndex];\n\t\tif(cachedDataBlock) {\n\t\t\treturn cachedDataBlock;\n\t\t}\n\t\tif(pointerIndex >= this.pointerStack.length) {\n\t\t\t// Only let a single thread append a new chunk at a time - otherwise two concurrent inserts landing in a new\n\t\t\t// chunk would each allocate + push a buffer, orphaning one and leaking memory\n\t\t\tlock(this.growLock);\n\t\t\ttry {\n\t\t\t\t// Re-check under the lock: another thread may have already appended the chunk while we were waiting\n\t\t\t\twhile(pointerIndex >= this.pointerStack.length) {\n\t\t\t\t\tlet newArray = this.memory.allocUI32(this.cachedMaxChunkSize * this.cachedDataLength * this.cachedByteMultipler);\n\t\t\t\t\tthis.pointerStack.push(newArray.pointer);\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tunlock(this.growLock);\n\t\t\t}\n\t\t}\n\n\t\tlet array = new AllocatedMemory(this.memory, getPointer(this.pointerStack.at(pointerIndex), this.memory.positionBits));\n\n\t\tlet blockLength = this.cachedDataLength * this.cachedMaxChunkSize;\n\t\tlet data = makeArrayView(this.cachedType, array.data.buffer, array.bufferByteOffset, blockLength) as T;\n\n\t\tthis.cachedFullDataBlock[pointerIndex] = data;\n\t\treturn data;\n\t}\n\n\tprivate getDataBlock(rawData: T, index: number): T {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tconst start = index * dataLength;\n\t\treturn rawData.subarray(start, start + dataLength) as T;\n\t}\n\n\tfree() {\n\t\tthis.recycleStack.free();\n\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\tlet memory = new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits));\n\t\t\tmemory.free();\n\t\t}\n\t\tthis.pointerStack.free();\n\t\tif(this.ownsFirstBlock) {\n\t\t\tthis.firstBlock.free();\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedPoolMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedPoolConfig<T extends NumericArray> {\n\tmaxChunkSize?: number\n\tmaxLength?: number\n\tmaxRecycledLength?: number\n\ttype?: TypedArrayConstructor<T>\n\tdataLength?: number\n}\ninterface SharedPoolMemory {\n\tfirstBlock: SharedAllocatedMemory | AllocatedMemory\n}\n\nexport type { SharedPoolConfig, SharedPoolMemory };\n"],"mappings":";;;;;;AAQA,IAAME,IAAe,GACfC,IAAa,GACbC,IAAuB,GAEvBC,IAAkB,GAElBC,IAAsB,GACtBC,IAAsB,GAEtBC,IAAyB,KACzBC,IAAqB,KACrBC,IAA8B,KAMfC,IAArB,MAAqBA,EAAwE;CAC5F,OAAgB,iBAAiB;CAIjC,OAAO,iBAAiB,GAAoB,GAAiD;EAC5F,IAAIC,IAAeC,GAAQ,gBAAgBL,GACvCM,IAAYD,GAAQ,aAAaJ,GACjCM,IAAoBF,GAAQ,qBAAqBH,GACjDM,IAAmBf,EAAY,oBAAoBgB,EAAO,mBAAmB,GAC7EC,IAA4BjB,EAAY,iBAAiBa,IAAYF,GAAc,KAAA,GAAWI,CAAgB,GAC9GG,IAA4BlB,EAAY,iBAAiBc,GAAmB,KAAA,GAAWC,CAAgB;EAC3G,OAAOL,EAAW,iBAAiBO,IAA4BC;CAChE;CAEA;CAGA;CACA;CACA;CACA;CACA;CACA;CAGA;CAIA,sBAAoD,CAAC;CAGrD;CACA;CACA;CACA;CAEA,IAAI,SAAiB;EACpB,OAAO,QAAQ,KAAK,KAAK,WAAW,MAAMjB,CAAY,IAAI,KAAK,aAAa;CAC7E;CACA,IAAI,eAAuB;EAC1B,OAAO,KAAK;CACb;CACA,IAAY,aAAa,GAAe;EACvC,QAAQ,MAAM,KAAK,WAAW,MAAME,GAAsBgB,CAAK;CAChE;CAEA,IAAI,OAAe;EAClB,OAAO,KAAK;CACb;CACA,IAAY,KAAK,GAAe;EAC/B,QAAQ,MAAM,KAAK,aAAa,GAAGA,CAAK;CACzC;CACA,IAAI,aAAqB;EACxB,OAAO,KAAK;CACb;CACA,IAAY,WAAW,GAAe;EACrC,QAAQ,MAAM,KAAK,aAAa,GAAGA,CAAK;CACzC;CAEA,IAAI,eAAuB;EAC1B,OAAO,KAAK,qBAAqB,KAAK,aAAa;CACpD;CACA,IAAI,gBAAwB;EAC3B,OAAO,KAAK;CACb;CAIA,IAAI,aAAqB;EACxB,IAAIC,IAAQ,KAAK,iBAAiB,KAAK,WAAW,aAAa;EAC/D,KAAI,IAAIC,KAAW,KAAK,cACvB,KAAS,IAAItB,EAAgB,KAAK,QAAQuB,EAAWD,GAAS,KAAK,OAAO,YAAY,CAAC,CAAC,CAAC;EAE1F,OAAOD,IAAQ,KAAK,aAAa,aAAa,KAAK,aAAa;CACjE;CAEA,YAAY,GAAoB,GAA0F;EAqCzH,AApCA,KAAK,SAASJ,GAEXJ,KAAU,gBAAgBA,KAG5B,KAAK,aAAaA,EAAO,sBAAsBb,IAC5Ca,EAAO,aACP,IAAIb,EAAgBiB,GAAQ;GAAE,QAAQN,EAAW;GAAgB,GAAGE,EAAO;EAAW,CAAC,GAC1F,KAAK,cAAc,IAAI,YAAY,KAAK,WAAW,KAAK,QAAQ,KAAK,WAAW,mBAAmBV,IAAa,YAAY,mBAAmB,CAAC,GAG7I,UAAUU,KAAU,gBAAgBA,KAAU,eAAeA,KAAU,kBAAkBA,KAAU,uBAAuBA,KAC5H,KAAK,WAAWA,CAAM,GACtB,KAAK,iBAAiB,OAEtB,KAAK,eAAe,IAAIZ,EAAYgB,GAAQ,EAC3C,YAAYM,EAAWC,EAAe,KAAK,WAAW,MAAMlB,CAAmB,GAAGW,EAAO,YAAY,EACtG,CAAC,GACD,KAAK,eAAe,IAAIhB,EAAYgB,GAAQ,EAC3C,YAAYM,EAAWC,EAAe,KAAK,WAAW,MAAMjB,CAAmB,GAAGU,EAAO,YAAY,EACtG,CAAC,GACD,KAAK,iBAAiB,QAGvB,KAAK,aAAaA,EAAO,UAAUN,EAAW,iBAAiBM,GAAQJ,CAAM,CAAC,GAC9E,KAAK,cAAc,IAAI,YAAY,KAAK,WAAW,KAAK,QAAQ,KAAK,WAAW,mBAAmBV,IAAa,YAAY,mBAAmB,CAAC,GAChJ,KAAK,WAAWU,CAAM,GACtB,KAAK,iBAAiB,KAGvB,KAAK,aAAa,KAAK,YAAY,IACnC,KAAK,mBAAmB,KAAK,IAAI,GAAG,KAAK,YAAY,EAAE,GACvD,KAAK,qBAAqB,KAAK,WAAW,KAAKT,IAC/C,KAAK,sBAAsBqB,EAAiB,KAAK,UAAU,GAC3D,KAAK,YAAY,KAAK,qBAAqB,KAAK,aAAa,WAE7D,KAAK,WAAW,IAAI,WAAW,KAAK,WAAW,KAAK,QAAQ,KAAK,WAAW,mBAAmBpB,IAAkB,YAAY,mBAAmB,CAAC;CAClJ;CAIA,WAAmB,GAA8B;EAChD,IAAIqB,IAAab,GAAQ,cAAc,GACnCD,IAAeC,GAAQ,gBAAgBL,GACvCM,IAAYD,GAAQ,aAAaJ,GACjCM,IAAoBF,GAAQ,qBAAqBH,GAIjDM,IAAmBf,EAAY,oBAAoB,KAAK,OAAO,mBAAmB,GAClF0B,IAAwBb,IAAYF,GACpCM,IAA4BjB,EAAY,iBAAiB0B,GAAuB,KAAA,GAAWX,CAAgB,GAC3GG,IAA4BlB,EAAY,iBAAiBc,GAAmB,KAAA,GAAWC,CAAgB;EAc3G,AAXA,KAAK,eAAe,IAAIf,EAAY,KAAK,QAAQ;GAChD,YAAY,KAAK,WAAW,iBAAiBU,EAAW,gBAAgBO,CAAyB;GACjG,MAAM;GACN,WAAWS;EACZ,CAAC,GACDC,EAAgB,KAAK,WAAW,MAAMtB,GAAqB,KAAK,aAAa,OAAO,GACpF,KAAK,eAAe,IAAIL,EAAY,KAAK,QAAQ;GAChD,YAAY,KAAK,WAAW,iBAAiBU,EAAW,iBAAiBO,GAA2BC,CAAyB;GAC7H,MAAM;GACN,WAAWJ;EACZ,CAAC,GACDa,EAAgB,KAAK,WAAW,MAAMrB,GAAqB,KAAK,aAAa,OAAO;EAEpF,IAAIsB,IAAWC,EAAiBjB,GAAQ,QAAQ,WAAW;EAG3D,AAFA,KAAK,OAAOgB,GACZ,KAAK,aAAaH,GAClB,KAAK,eAAed;EAEpB,IAAImB,IAAgBN,EAAiBI,CAAQ,GACzCG,IAAa,KAAK,OAAO,UAAUpB,IAAec,IAAaK,CAAa;EAChF,KAAK,aAAa,KAAKC,EAAW,OAAO;CAC1C;CAEA,GAAG,GAAkB;EACpB,IAAIC,IAAY,KAAK,iBAAiBC,CAAK;EAC3C,OAAO,KAAK,aAAaD,GAAWC,IAAQ,KAAK,kBAAkB;CACpE;CACA,IAAI,GAAe,IAAY,GAAc;EAC5C,IAAMR,IAAa,KAAK;EACxB,IAAGS,KAAaT,GACf,MAAU,MAAM,GAAGS,EAAU,+BAA+BT,GAAY;EAIzE,OADgB,KAAK,iBAAiBQ,CAC/B,CAAA,CAAWA,IAAQ,KAAK,qBAAsBR,IAAaS;CACnE;CACA,IAAI,GAAe,GAAmB,GAAkB;EACvD,IAAMT,IAAa,KAAK;EACxB,IAAGS,KAAaT,GACf,MAAU,MAAM,GAAGS,EAAU,+BAA+BT,GAAY;EAGzE,IAAIO,IAAY,KAAK,iBAAiBC,CAAK;EAC3C,EAAWA,IAAQ,KAAK,qBAAsBR,IAAaS,KAAaf;CACzE;CAIA,SAAS,GAAkB;EAC1B,OAAO,KAAK,iBAAiBc,CAAK;CACnC;CAEA,YAAY,GAAuB;EAClC,OAAQA,IAAQ,KAAK,qBAAsB,KAAK;CACjD;CAEA,KAAK,GAA8C;EAClD,IAAIR,IAAa,KAAK,kBAChBU,IAAgB,OAAOC,KAAW;EACxC,IAAG,CAACD,KAAiBC,EAAO,SAASX,GACpC,MAAU,MAAM,gBAAgBW,EAAO,OAAO,6BAA6BX,EAAW,YAAY;EAKnG,IAAIY,IAAW,KAAK,aAAa,WAAW,IAAI,KAAA,IAAY,KAAK,aAAa,IAAI;EAClF,AAAGA,MAAa,KAAA,MACf,IAAW,QAAQ,IAAI,KAAK,WAAW,MAAMpC,GAAc,CAAC;EAG7D,IAAI+B,IAAY,KAAK,iBAAiBK,CAAQ,GAC1CC,IAAab,KAAcY,IAAW,KAAK;EAC/C,IAAGF,GACF,EAAUG,KAAcF;OAExB,KAAI,IAAIG,IAAI,GAAGA,IAAIH,EAAO,QAAQ,KACjC,EAAUE,IAAaC,KAAKH,EAAOG;EAIrC,OAAOF;CACR;CAEA,kBAAkB,GAAuB;EACxC,IAAG,CAAC,OAAO,UAAUG,CAAK,KAAKA,IAAQ,GACtC,MAAU,MAAM,iBAAiBA,EAAM,cAAc;EAEtD,OAAO,QAAQ,IAAI,KAAK,WAAW,MAAMvC,GAAcuC,CAAK;CAC7D;CAEA,YAAY,GAAe;EAC1B,KAAK,aAAa,KAAKP,CAAK;CAC7B;CAEA,QAAQ;EAEP,AADA,KAAK,WAAW,KAAKhC,KAAgB,GACrC,KAAK,aAAa,MAAM;CACzB;CAEA,EAAE,OAAO,YAAY;EACpB,IAAMwC,IAA0C,CAAC;EACjD,KAAI,IAAItB,KAAS,KAAK,cACrB,EAAeA,KAAS;EAGzB,IAAMR,IAAe,KAAK,oBAGpB+B,IAAS,QAAQ,KAAK,KAAK,WAAW,MAAMzC,CAAY,GAC1D+B,IAAY,KAAK,iBAAiB,CAAC,GACnCW,IAAiB;EACrB,KAAI,IAAIJ,IAAI,GAAGA,IAAIG,GAAQ,KAC1B,IAAG,CAACD,EAAeF,IAAI;GACtB,IAAIK,IAAoB,KAAK,MAAML,IAAI5B,CAAY;GAKnD,AAJGiC,MAAsBD,MACxB,IAAY,KAAK,iBAAiBJ,CAAC,GACnC,IAAiBK,IAElB,MAAM,KAAK,aAAaZ,GAAWO,IAAI5B,CAAY;EACpD;CAEF;CAEA,CAAC,UAAyC;EACzC,IAAM8B,IAA0C,CAAC;EACjD,KAAI,IAAItB,KAAS,KAAK,cACrB,EAAeA,KAAS;EAGzB,IAAMR,IAAe,KAAK,oBACpB+B,IAAS,QAAQ,KAAK,KAAK,WAAW,MAAMzC,CAAY,GAC1D+B,IAAY,KAAK,iBAAiB,CAAC,GACnCW,IAAiB;EACrB,KAAI,IAAIJ,IAAI,GAAGA,IAAIG,GAAQ,KAC1B,IAAG,CAACD,EAAeF,IAAI;GACtB,IAAIK,IAAoB,KAAK,MAAML,IAAI5B,CAAY;GAKnD,AAJGiC,MAAsBD,MACxB,IAAY,KAAK,iBAAiBJ,CAAC,GACnC,IAAiBK,IAElB,MAAM,CAACL,GAAG,KAAK,aAAaP,GAAWO,IAAI5B,CAAY,CAAC;EACzD;CAEF;CAEA,iBAAyB,GAAe;EACvC,IAAIkC,IAAe,KAAK,MAAMZ,IAAQ,KAAK,kBAAkB,GACzDa,IAAkB,KAAK,oBAAoBD;EAC/C,IAAGC,GACF,OAAOA;EAER,IAAGD,KAAgB,KAAK,aAAa,QAAQ;GAG5C,EAAK,KAAK,QAAQ;GAClB,IAAI;IAEH,OAAMA,KAAgB,KAAK,aAAa,SAAQ;KAC/C,IAAIE,IAAW,KAAK,OAAO,UAAU,KAAK,qBAAqB,KAAK,mBAAmB,KAAK,mBAAmB;KAC/G,KAAK,aAAa,KAAKA,EAAS,OAAO;IACxC;GACD,UAAU;IACT,EAAO,KAAK,QAAQ;GACrB;EACD;EAEA,IAAIC,IAAQ,IAAIjD,EAAgB,KAAK,QAAQuB,EAAW,KAAK,aAAa,GAAGuB,CAAY,GAAG,KAAK,OAAO,YAAY,CAAC,GAEjHI,IAAc,KAAK,mBAAmB,KAAK,oBAC3CC,IAAOC,EAAc,KAAK,YAAYH,EAAM,KAAK,QAAQA,EAAM,kBAAkBC,CAAW;EAGhG,OADA,KAAK,oBAAoBJ,KAAgBK,GAClCA;CACR;CAEA,aAAqB,GAAY,GAAkB;EAClD,IAAMzB,IAAa,KAAK,kBAClB2B,IAAQnB,IAAQR;EACtB,OAAO4B,EAAQ,SAASD,GAAOA,IAAQ3B,CAAU;CAClD;CAEA,OAAO;EACN,KAAK,aAAa,KAAK;EAEvB,KAAI,IAAIJ,KAAW,KAAK,cAEvB,IADiBtB,EAAgB,KAAK,QAAQuB,EAAWD,GAAS,KAAK,OAAO,YAAY,CAC1F,CAAA,CAAO,KAAK;EAGb,AADA,KAAK,aAAa,KAAK,GACpB,KAAK,kBACP,KAAK,WAAW,KAAK;CAEvB;CAEA,kBAAoC;EACnC,OAAO,EACN,YAAY,KAAK,WAAW,gBAAgB,EAC7C;CACD;AACD"}
+{"version":3,"file":"shared-pool.js","names":["AllocatedMemory","SharedStack","LENGTH_INDEX","TYPE_INDEX","MAX_CHUNK_SIZE_INDEX","GROW_LOCK_INDEX","POINTER_STACK_INDEX","RECYCLE_STACK_INDEX","DEFAULT_MAX_CHUNK_SIZE","DEFAULT_MAX_LENGTH","DEFAULT_MAX_RECYCLED_LENGTH","SharedPool","maxChunkSize","config","maxLength","maxRecycledLength","maxSegmentLength","memory","pointerStackAllocateCount","recycleStackAllocateCount","value","total","pointer","getPointer","loadRawPointer","getByteMultipler","dataLength","pointerStackMaxLength","storeRawPointer","typeCode","getArrayTypeCode","byteMultipler","firstArray","dataBlock","index","dataIndex","isSingleValue","values","newIndex","startIndex","i","count","length","recycled","recycledValues","dataBlockIndex","newDataBlockIndex","pointerIndex","cachedDataBlock","newArray","array","blockLength","data","makeArrayView","start","rawData"],"sources":["../src/shared-pool.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport { lock, unlock } from './lock/simple-lock';\nimport type MemoryHeap from './memory-heap';\nimport SharedStack from './shared-stack';\nimport { getPointer, loadRawPointer, storeRawPointer } from './utils/pointer';\nimport { getArrayTypeCode, getByteMultipler, makeArrayView, type NumericArray, type NumericArrayIO, type TypedArrayConstructor } from './utils/array-type';\n\nconst LENGTH_INDEX = 0;\nconst TYPE_INDEX = 1;\nconst MAX_CHUNK_SIZE_INDEX = 2;\n// Guards appending a chunk pointer so only one thread grows the pointer stack at a time\nconst GROW_LOCK_INDEX = 3;\n// Pointers to the two backing SharedStacks (their own firstBlocks): the chunk pointers and the recycled indexes\nconst POINTER_STACK_INDEX = 4;\nconst RECYCLE_STACK_INDEX = 5;\n\nconst DEFAULT_MAX_CHUNK_SIZE = 100;\nconst DEFAULT_MAX_LENGTH = 1_000_000;\nconst DEFAULT_MAX_RECYCLED_LENGTH = 100_000;\n\n// Array with stable indexes and maximum contiguous memory sizes (necessary to fit large data sets into max 1MB buffers).\n// The chunk pointers and the recycled indexes both live in SharedStacks, whose segments are never moved or freed once\n// published, so concurrent readers never touch memory that is being reclaimed.\n// https://plflib.org/colony.htm for future enhancements - it seems to be an optimized version of what we were aiming for with this\nexport default class SharedPool<T extends NumericArray = Uint32Array> implements Iterable<T> {\n\tstatic readonly ALLOCATE_COUNT = 6;\n\n\t// u32s a pool with this config needs for its firstBlock, including both inlined stacks. Lets an owner (e.g.\n\t// SharedQuadtree) reserve one contiguous slice and hand it back through the config's firstBlock to inline the pool.\n\tstatic getAllocateCount(memory: MemoryHeap, config?: SharedPoolConfig<NumericArray>): number {\n\t\tlet maxChunkSize = config?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;\n\t\tlet maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;\n\t\tlet maxRecycledLength = config?.maxRecycledLength ?? DEFAULT_MAX_RECYCLED_LENGTH;\n\t\tlet maxSegmentLength = SharedStack.getMaxSegmentLength(memory.maxAllocationLength);\n\t\tlet pointerStackAllocateCount = SharedStack.getAllocateCount(maxLength / maxChunkSize, undefined, maxSegmentLength);\n\t\tlet recycleStackAllocateCount = SharedStack.getAllocateCount(maxRecycledLength, undefined, maxSegmentLength);\n\t\treturn SharedPool.ALLOCATE_COUNT + pointerStackAllocateCount + recycleStackAllocateCount;\n\t}\n\n\tprivate memory: MemoryHeap;\n\n\t// Current Length, Type/DataLength, MaxChunkLength, Grow lock, Pointer stack, Recycle stack\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tprivate growLock: Int32Array;\n\tprivate pointerStack!: SharedStack;\n\tprivate recycleStack!: SharedStack;\n\treadonly maxLength: number;\n\n\t// False when firstBlock is a slice of another structure's memory (e.g. inlined in SharedQuadtree); that owner frees it\n\tprivate ownsFirstBlock: boolean;\n\n\t// Chunk views cached by pointer index. An array (dense, small integer keys) resolves faster than an object on the hot\n\t// get/set path and never needs rehashing.\n\tprivate cachedFullDataBlock: Array<T | undefined> = [];\n\n\t// Config is written once at construction and never mutated, so it is cached in plain fields\n\tprivate readonly cachedMaxChunkSize: number;\n\tprivate readonly cachedDataLength: number;\n\tprivate readonly cachedType: number;\n\tprivate readonly cachedByteMultipler: number;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX) - this.recycleStack.length;\n\t}\n\tget maxChunkSize(): number {\n\t\treturn this.cachedMaxChunkSize;\n\t}\n\tprivate set maxChunkSize(value: number) {\n\t\tAtomics.store(this.firstBlock.data, MAX_CHUNK_SIZE_INDEX, value);\n\t}\n\n\tget type(): number {\n\t\treturn this.cachedType;\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\tget dataLength(): number {\n\t\treturn this.cachedDataLength;\n\t}\n\tprivate set dataLength(value: number) {\n\t\tAtomics.store(this.uint16Array, 1, value);\n\t}\n\n\tget bufferLength(): number {\n\t\treturn this.cachedMaxChunkSize * this.pointerStack.length;\n\t}\n\tget byteMultipler(): number {\n\t\treturn this.cachedByteMultipler;\n\t}\n\n\t// Own internal memory (which already includes both stacks' inlined firstBlocks) plus every chunk buffer and the\n\t// segments each stack has grown. The stacks' usedMemory excludes their inlined firstBlocks, so they aren't double-counted.\n\tget usedMemory(): number {\n\t\tlet total = this.ownsFirstBlock ? this.firstBlock.usedMemory : 0;\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\ttotal += new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits)).usedMemory;\n\t\t}\n\t\treturn total + this.pointerStack.usedMemory + this.recycleStack.usedMemory;\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedPoolConfig<T> | SharedPoolMemory | SharedPoolMemory & SharedPoolConfig<T>) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\t// An AllocatedMemory instance is a caller-reserved slice (e.g. inlined in SharedQuadtree); a plain pointer is the\n\t\t\t// serialized clone path. Taking the instance directly keeps us off the pointer-resolving construction branch.\n\t\t\tthis.firstBlock = config.firstBlock instanceof AllocatedMemory\n\t\t\t\t? config.firstBlock\n\t\t\t\t: new AllocatedMemory(memory, { length: SharedPool.ALLOCATE_COUNT, ...config.firstBlock });\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\n\t\t\t// Memory passed together with config means the caller reserved the firstBlock slot for us to initialize in place\n\t\t\tif('type' in config || 'dataLength' in config || 'maxLength' in config || 'maxChunkSize' in config || 'maxRecycledLength' in config) {\n\t\t\t\tthis.initialize(config);\n\t\t\t\tthis.ownsFirstBlock = false;\n\t\t\t} else {\n\t\t\t\tthis.pointerStack = new SharedStack(memory, {\n\t\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, POINTER_STACK_INDEX), memory.positionBits),\n\t\t\t\t});\n\t\t\t\tthis.recycleStack = new SharedStack(memory, {\n\t\t\t\t\tfirstBlock: getPointer(loadRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX), memory.positionBits),\n\t\t\t\t});\n\t\t\t\tthis.ownsFirstBlock = true;\n\t\t\t}\n\t\t} else {\n\t\t\tthis.firstBlock = memory.allocUI32(SharedPool.getAllocateCount(memory, config));\n\t\t\tthis.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + TYPE_INDEX * Uint32Array.BYTES_PER_ELEMENT, 2);\n\t\t\tthis.initialize(config);\n\t\t\tthis.ownsFirstBlock = true;\n\t\t}\n\n\t\tthis.cachedType = this.uint16Array[0];\n\t\tthis.cachedDataLength = Math.max(1, this.uint16Array[1]);\n\t\tthis.cachedMaxChunkSize = this.firstBlock.data[MAX_CHUNK_SIZE_INDEX];\n\t\tthis.cachedByteMultipler = getByteMultipler(this.cachedType);\n\t\tthis.maxLength = this.cachedMaxChunkSize * this.pointerStack.maxLength;\n\n\t\tthis.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + GROW_LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, 1);\n\t}\n\n\t// Lay out the two inlined stacks (their firstBlocks sliced from ours), record their pointers, and seed the first chunk.\n\t// firstBlock and uint16Array must already be set. Used by both the fresh-alloc path and the inline-in-place path.\n\tprivate initialize(config?: SharedPoolConfig<T>) {\n\t\tlet dataLength = config?.dataLength ?? 1;\n\t\tlet maxChunkSize = config?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;\n\t\tlet maxLength = config?.maxLength ?? DEFAULT_MAX_LENGTH;\n\t\tlet maxRecycledLength = config?.maxRecycledLength ?? DEFAULT_MAX_RECYCLED_LENGTH;\n\n\t\t// Each stack sizes its inlined firstBlock from its own maxLength, so compute both up front to lay them out. The\n\t\t// stacks cap their segments at what a buffer can hold, so size the inlined blocks against that same cap.\n\t\tlet maxSegmentLength = SharedStack.getMaxSegmentLength(this.memory.maxAllocationLength);\n\t\tlet pointerStackMaxLength = maxLength / maxChunkSize;\n\t\tlet pointerStackAllocateCount = SharedStack.getAllocateCount(pointerStackMaxLength, undefined, maxSegmentLength);\n\t\tlet recycleStackAllocateCount = SharedStack.getAllocateCount(maxRecycledLength, undefined, maxSegmentLength);\n\n\t\t// Inline both stacks' firstBlocks right after the pool header so the whole spine is one contiguous allocation\n\t\tthis.pointerStack = new SharedStack(this.memory, {\n\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT, pointerStackAllocateCount),\n\t\t\ttype: Uint32Array,\n\t\t\tmaxLength: pointerStackMaxLength,\n\t\t});\n\t\tstoreRawPointer(this.firstBlock.data, POINTER_STACK_INDEX, this.pointerStack.pointer);\n\t\tthis.recycleStack = new SharedStack(this.memory, {\n\t\t\tfirstBlock: this.firstBlock.getSubAllocation(SharedPool.ALLOCATE_COUNT + pointerStackAllocateCount, recycleStackAllocateCount),\n\t\t\ttype: Uint32Array,\n\t\t\tmaxLength: maxRecycledLength,\n\t\t});\n\t\tstoreRawPointer(this.firstBlock.data, RECYCLE_STACK_INDEX, this.recycleStack.pointer);\n\n\t\tlet typeCode = getArrayTypeCode(config?.type ?? Uint32Array);\n\t\tthis.type = typeCode;\n\t\tthis.dataLength = dataLength;\n\t\tthis.maxChunkSize = maxChunkSize;\n\n\t\tlet byteMultipler = getByteMultipler(typeCode);\n\t\tlet firstArray = this.memory.allocUI32(maxChunkSize * dataLength * byteMultipler);\n\t\tthis.pointerStack.push(firstArray.pointer);\n\t}\n\n\tat(index: number): T {\n\t\tlet dataBlock = this.getFullDataBlock(index);\n\t\treturn this.getDataBlock(dataBlock, index % this.cachedMaxChunkSize);\n\t}\n\tget(index: number, dataIndex = 0): T[number] {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(index) as NumericArrayIO;\n\t\treturn dataBlock[(index % this.cachedMaxChunkSize) * dataLength + dataIndex];\n\t}\n\tset(index: number, dataIndex: number, value: T[number]) {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(index) as NumericArrayIO;\n\t\tdataBlock[(index % this.cachedMaxChunkSize) * dataLength + dataIndex] = value;\n\t}\n\n\t// Resolve the chunk view holding an index once. Callers touching several fields of the same record read/write straight\n\t// into this view at blockOffset(index) + fieldIndex, avoiding a repeated chunk lookup per field.\n\tblockFor(index: number): T {\n\t\treturn this.getFullDataBlock(index);\n\t}\n\t// Base slot of a record within the view blockFor(index) returns.\n\tblockOffset(index: number): number {\n\t\treturn (index % this.cachedMaxChunkSize) * this.cachedDataLength;\n\t}\n\n\tpush(values: T[number] | Array<T[number]>): number {\n\t\tlet dataLength = this.cachedDataLength;\n\t\tconst isSingleValue = typeof values !== 'object';\n\t\tif(!isSingleValue && values.length > dataLength) {\n\t\t\tthrow new Error(`Can't insert ${values.length} array into shared list of ${dataLength} dataLength`);\n\t\t}\n\n\t\t// Reuse a recycled index if one is available. pop() can come back undefined when another thread drained the last\n\t\t// slot between our two calls, so fall through to a fresh index rather than trusting a length() read\n\t\tlet newIndex = this.recycleStack.length === 0 ? undefined : this.recycleStack.pop();\n\t\tif(newIndex === undefined) {\n\t\t\tnewIndex = Atomics.add(this.firstBlock.data, LENGTH_INDEX, 1);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(newIndex) as NumericArrayIO;\n\t\tlet startIndex = dataLength * (newIndex % this.cachedMaxChunkSize);\n\t\tif(isSingleValue) {\n\t\t\tdataBlock[startIndex] = values;\n\t\t} else {\n\t\t\tfor(let i = 0; i < values.length; i++) {\n\t\t\t\tdataBlock[startIndex + i] = values[i];\n\t\t\t}\n\t\t}\n\n\t\treturn newIndex;\n\t}\n\n\treserveContiguous(count: number): number {\n\t\tif(!Number.isInteger(count) || count < 0) {\n\t\t\tthrow new Error(`Can't reserve ${count} pool entries`);\n\t\t}\n\t\treturn Atomics.add(this.firstBlock.data, LENGTH_INDEX, count);\n\t}\n\n\tdeleteIndex(index: number) {\n\t\tthis.recycleStack.push(index);\n\t}\n\n\tclear() {\n\t\tthis.firstBlock.data[LENGTH_INDEX] = 0;\n\t\tthis.recycleStack.clear();\n\t}\n\n\t// Flags recycled indexes up to the allocated length (the mask's length). Lets a caller walk chunks directly via\n\t// blockFor instead of paying entries()'s per-record generator, tuple and subarray.\n\tgetRecycledMask(): Uint8Array {\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tconst recycled = new Uint8Array(length);\n\t\tfor(let index of this.recycleStack) {\n\t\t\tif(index < length) {\n\t\t\t\trecycled[index] = 1;\n\t\t\t}\n\t\t}\n\t\treturn recycled;\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleStack) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tconst maxChunkSize = this.cachedMaxChunkSize;\n\t\t// Snapshot the length once - iteration over a concurrently mutated pool is a snapshot anyway, and re-loading the\n\t\t// atomic every step is pure overhead\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < length; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield this.getDataBlock(dataBlock, i % maxChunkSize);\n\t\t\t}\n\t\t}\n\t}\n\n\t*entries(): IterableIterator<[number, T]> {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycleStack) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tconst maxChunkSize = this.cachedMaxChunkSize;\n\t\tconst length = Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < length; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield [i, this.getDataBlock(dataBlock, i % maxChunkSize)];\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getFullDataBlock(index: number) {\n\t\tlet pointerIndex = Math.floor(index / this.cachedMaxChunkSize);\n\t\tlet cachedDataBlock = this.cachedFullDataBlock[pointerIndex];\n\t\tif(cachedDataBlock) {\n\t\t\treturn cachedDataBlock;\n\t\t}\n\t\tif(pointerIndex >= this.pointerStack.length) {\n\t\t\t// Only let a single thread append a new chunk at a time - otherwise two concurrent inserts landing in a new\n\t\t\t// chunk would each allocate + push a buffer, orphaning one and leaking memory\n\t\t\tlock(this.growLock);\n\t\t\ttry {\n\t\t\t\t// Re-check under the lock: another thread may have already appended the chunk while we were waiting\n\t\t\t\twhile(pointerIndex >= this.pointerStack.length) {\n\t\t\t\t\tlet newArray = this.memory.allocUI32(this.cachedMaxChunkSize * this.cachedDataLength * this.cachedByteMultipler);\n\t\t\t\t\tthis.pointerStack.push(newArray.pointer);\n\t\t\t\t}\n\t\t\t} finally {\n\t\t\t\tunlock(this.growLock);\n\t\t\t}\n\t\t}\n\n\t\tlet array = new AllocatedMemory(this.memory, getPointer(this.pointerStack.at(pointerIndex), this.memory.positionBits));\n\n\t\tlet blockLength = this.cachedDataLength * this.cachedMaxChunkSize;\n\t\tlet data = makeArrayView(this.cachedType, array.data.buffer, array.bufferByteOffset, blockLength) as T;\n\n\t\tthis.cachedFullDataBlock[pointerIndex] = data;\n\t\treturn data;\n\t}\n\n\tprivate getDataBlock(rawData: T, index: number): T {\n\t\tconst dataLength = this.cachedDataLength;\n\t\tconst start = index * dataLength;\n\t\treturn rawData.subarray(start, start + dataLength) as T;\n\t}\n\n\tfree() {\n\t\tthis.recycleStack.free();\n\n\t\tfor(let pointer of this.pointerStack) {\n\t\t\tlet memory = new AllocatedMemory(this.memory, getPointer(pointer, this.memory.positionBits));\n\t\t\tmemory.free();\n\t\t}\n\t\tthis.pointerStack.free();\n\t\tif(this.ownsFirstBlock) {\n\t\t\tthis.firstBlock.free();\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedPoolMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedPoolConfig<T extends NumericArray> {\n\tmaxChunkSize?: number\n\tmaxLength?: number\n\tmaxRecycledLength?: number\n\ttype?: TypedArrayConstructor<T>\n\tdataLength?: number\n}\ninterface SharedPoolMemory {\n\tfirstBlock: SharedAllocatedMemory | AllocatedMemory\n}\n\nexport type { SharedPoolConfig, SharedPoolMemory };\n"],"mappings":";;;;;;AAQA,IAAME,IAAe,GACfC,IAAa,GACbC,IAAuB,GAEvBC,IAAkB,GAElBC,IAAsB,GACtBC,IAAsB,GAEtBC,IAAyB,KACzBC,IAAqB,KACrBC,IAA8B,KAMfC,IAArB,MAAqBA,EAAwE;CAC5F,OAAgB,iBAAiB;CAIjC,OAAO,iBAAiB,GAAoB,GAAiD;EAC5F,IAAIC,IAAeC,GAAQ,gBAAgBL,GACvCM,IAAYD,GAAQ,aAAaJ,GACjCM,IAAoBF,GAAQ,qBAAqBH,GACjDM,IAAmBf,EAAY,oBAAoBgB,EAAO,mBAAmB,GAC7EC,IAA4BjB,EAAY,iBAAiBa,IAAYF,GAAc,KAAA,GAAWI,CAAgB,GAC9GG,IAA4BlB,EAAY,iBAAiBc,GAAmB,KAAA,GAAWC,CAAgB;EAC3G,OAAOL,EAAW,iBAAiBO,IAA4BC;CAChE;CAEA;CAGA;CACA;CACA;CACA;CACA;CACA;CAGA;CAIA,sBAAoD,CAAC;CAGrD;CACA;CACA;CACA;CAEA,IAAI,SAAiB;EACpB,OAAO,QAAQ,KAAK,KAAK,WAAW,MAAMjB,CAAY,IAAI,KAAK,aAAa;CAC7E;CACA,IAAI,eAAuB;EAC1B,OAAO,KAAK;CACb;CACA,IAAY,aAAa,GAAe;EACvC,QAAQ,MAAM,KAAK,WAAW,MAAME,GAAsBgB,CAAK;CAChE;CAEA,IAAI,OAAe;EAClB,OAAO,KAAK;CACb;CACA,IAAY,KAAK,GAAe;EAC/B,QAAQ,MAAM,KAAK,aAAa,GAAGA,CAAK;CACzC;CACA,IAAI,aAAqB;EACxB,OAAO,KAAK;CACb;CACA,IAAY,WAAW,GAAe;EACrC,QAAQ,MAAM,KAAK,aAAa,GAAGA,CAAK;CACzC;CAEA,IAAI,eAAuB;EAC1B,OAAO,KAAK,qBAAqB,KAAK,aAAa;CACpD;CACA,IAAI,gBAAwB;EAC3B,OAAO,KAAK;CACb;CAIA,IAAI,aAAqB;EACxB,IAAIC,IAAQ,KAAK,iBAAiB,KAAK,WAAW,aAAa;EAC/D,KAAI,IAAIC,KAAW,KAAK,cACvB,KAAS,IAAItB,EAAgB,KAAK,QAAQuB,EAAWD,GAAS,KAAK,OAAO,YAAY,CAAC,CAAC,CAAC;EAE1F,OAAOD,IAAQ,KAAK,aAAa,aAAa,KAAK,aAAa;CACjE;CAEA,YAAY,GAAoB,GAA0F;EAqCzH,AApCA,KAAK,SAASJ,GAEXJ,KAAU,gBAAgBA,KAG5B,KAAK,aAAaA,EAAO,sBAAsBb,IAC5Ca,EAAO,aACP,IAAIb,EAAgBiB,GAAQ;GAAE,QAAQN,EAAW;GAAgB,GAAGE,EAAO;EAAW,CAAC,GAC1F,KAAK,cAAc,IAAI,YAAY,KAAK,WAAW,KAAK,QAAQ,KAAK,WAAW,mBAAmBV,IAAa,YAAY,mBAAmB,CAAC,GAG7I,UAAUU,KAAU,gBAAgBA,KAAU,eAAeA,KAAU,kBAAkBA,KAAU,uBAAuBA,KAC5H,KAAK,WAAWA,CAAM,GACtB,KAAK,iBAAiB,OAEtB,KAAK,eAAe,IAAIZ,EAAYgB,GAAQ,EAC3C,YAAYM,EAAWC,EAAe,KAAK,WAAW,MAAMlB,CAAmB,GAAGW,EAAO,YAAY,EACtG,CAAC,GACD,KAAK,eAAe,IAAIhB,EAAYgB,GAAQ,EAC3C,YAAYM,EAAWC,EAAe,KAAK,WAAW,MAAMjB,CAAmB,GAAGU,EAAO,YAAY,EACtG,CAAC,GACD,KAAK,iBAAiB,QAGvB,KAAK,aAAaA,EAAO,UAAUN,EAAW,iBAAiBM,GAAQJ,CAAM,CAAC,GAC9E,KAAK,cAAc,IAAI,YAAY,KAAK,WAAW,KAAK,QAAQ,KAAK,WAAW,mBAAmBV,IAAa,YAAY,mBAAmB,CAAC,GAChJ,KAAK,WAAWU,CAAM,GACtB,KAAK,iBAAiB,KAGvB,KAAK,aAAa,KAAK,YAAY,IACnC,KAAK,mBAAmB,KAAK,IAAI,GAAG,KAAK,YAAY,EAAE,GACvD,KAAK,qBAAqB,KAAK,WAAW,KAAKT,IAC/C,KAAK,sBAAsBqB,EAAiB,KAAK,UAAU,GAC3D,KAAK,YAAY,KAAK,qBAAqB,KAAK,aAAa,WAE7D,KAAK,WAAW,IAAI,WAAW,KAAK,WAAW,KAAK,QAAQ,KAAK,WAAW,mBAAmBpB,IAAkB,YAAY,mBAAmB,CAAC;CAClJ;CAIA,WAAmB,GAA8B;EAChD,IAAIqB,IAAab,GAAQ,cAAc,GACnCD,IAAeC,GAAQ,gBAAgBL,GACvCM,IAAYD,GAAQ,aAAaJ,GACjCM,IAAoBF,GAAQ,qBAAqBH,GAIjDM,IAAmBf,EAAY,oBAAoB,KAAK,OAAO,mBAAmB,GAClF0B,IAAwBb,IAAYF,GACpCM,IAA4BjB,EAAY,iBAAiB0B,GAAuB,KAAA,GAAWX,CAAgB,GAC3GG,IAA4BlB,EAAY,iBAAiBc,GAAmB,KAAA,GAAWC,CAAgB;EAc3G,AAXA,KAAK,eAAe,IAAIf,EAAY,KAAK,QAAQ;GAChD,YAAY,KAAK,WAAW,iBAAiBU,EAAW,gBAAgBO,CAAyB;GACjG,MAAM;GACN,WAAWS;EACZ,CAAC,GACDC,EAAgB,KAAK,WAAW,MAAMtB,GAAqB,KAAK,aAAa,OAAO,GACpF,KAAK,eAAe,IAAIL,EAAY,KAAK,QAAQ;GAChD,YAAY,KAAK,WAAW,iBAAiBU,EAAW,iBAAiBO,GAA2BC,CAAyB;GAC7H,MAAM;GACN,WAAWJ;EACZ,CAAC,GACDa,EAAgB,KAAK,WAAW,MAAMrB,GAAqB,KAAK,aAAa,OAAO;EAEpF,IAAIsB,IAAWC,EAAiBjB,GAAQ,QAAQ,WAAW;EAG3D,AAFA,KAAK,OAAOgB,GACZ,KAAK,aAAaH,GAClB,KAAK,eAAed;EAEpB,IAAImB,IAAgBN,EAAiBI,CAAQ,GACzCG,IAAa,KAAK,OAAO,UAAUpB,IAAec,IAAaK,CAAa;EAChF,KAAK,aAAa,KAAKC,EAAW,OAAO;CAC1C;CAEA,GAAG,GAAkB;EACpB,IAAIC,IAAY,KAAK,iBAAiBC,CAAK;EAC3C,OAAO,KAAK,aAAaD,GAAWC,IAAQ,KAAK,kBAAkB;CACpE;CACA,IAAI,GAAe,IAAY,GAAc;EAC5C,IAAMR,IAAa,KAAK;EACxB,IAAGS,KAAaT,GACf,MAAU,MAAM,GAAGS,EAAU,+BAA+BT,GAAY;EAIzE,OADgB,KAAK,iBAAiBQ,CAC/B,CAAA,CAAWA,IAAQ,KAAK,qBAAsBR,IAAaS;CACnE;CACA,IAAI,GAAe,GAAmB,GAAkB;EACvD,IAAMT,IAAa,KAAK;EACxB,IAAGS,KAAaT,GACf,MAAU,MAAM,GAAGS,EAAU,+BAA+BT,GAAY;EAGzE,IAAIO,IAAY,KAAK,iBAAiBC,CAAK;EAC3C,EAAWA,IAAQ,KAAK,qBAAsBR,IAAaS,KAAaf;CACzE;CAIA,SAAS,GAAkB;EAC1B,OAAO,KAAK,iBAAiBc,CAAK;CACnC;CAEA,YAAY,GAAuB;EAClC,OAAQA,IAAQ,KAAK,qBAAsB,KAAK;CACjD;CAEA,KAAK,GAA8C;EAClD,IAAIR,IAAa,KAAK,kBAChBU,IAAgB,OAAOC,KAAW;EACxC,IAAG,CAACD,KAAiBC,EAAO,SAASX,GACpC,MAAU,MAAM,gBAAgBW,EAAO,OAAO,6BAA6BX,EAAW,YAAY;EAKnG,IAAIY,IAAW,KAAK,aAAa,WAAW,IAAI,KAAA,IAAY,KAAK,aAAa,IAAI;EAClF,AAAGA,MAAa,KAAA,MACf,IAAW,QAAQ,IAAI,KAAK,WAAW,MAAMpC,GAAc,CAAC;EAG7D,IAAI+B,IAAY,KAAK,iBAAiBK,CAAQ,GAC1CC,IAAab,KAAcY,IAAW,KAAK;EAC/C,IAAGF,GACF,EAAUG,KAAcF;OAExB,KAAI,IAAIG,IAAI,GAAGA,IAAIH,EAAO,QAAQ,KACjC,EAAUE,IAAaC,KAAKH,EAAOG;EAIrC,OAAOF;CACR;CAEA,kBAAkB,GAAuB;EACxC,IAAG,CAAC,OAAO,UAAUG,CAAK,KAAKA,IAAQ,GACtC,MAAU,MAAM,iBAAiBA,EAAM,cAAc;EAEtD,OAAO,QAAQ,IAAI,KAAK,WAAW,MAAMvC,GAAcuC,CAAK;CAC7D;CAEA,YAAY,GAAe;EAC1B,KAAK,aAAa,KAAKP,CAAK;CAC7B;CAEA,QAAQ;EAEP,AADA,KAAK,WAAW,KAAKhC,KAAgB,GACrC,KAAK,aAAa,MAAM;CACzB;CAIA,kBAA8B;EAC7B,IAAMwC,IAAS,QAAQ,KAAK,KAAK,WAAW,MAAMxC,CAAY,GACxDyC,IAAW,IAAI,WAAWD,CAAM;EACtC,KAAI,IAAIR,KAAS,KAAK,cACrB,AAAGA,IAAQQ,MACV,EAASR,KAAS;EAGpB,OAAOS;CACR;CAEA,EAAE,OAAO,YAAY;EACpB,IAAMC,IAA0C,CAAC;EACjD,KAAI,IAAIxB,KAAS,KAAK,cACrB,EAAeA,KAAS;EAGzB,IAAMR,IAAe,KAAK,oBAGpB8B,IAAS,QAAQ,KAAK,KAAK,WAAW,MAAMxC,CAAY,GAC1D+B,IAAY,KAAK,iBAAiB,CAAC,GACnCY,IAAiB;EACrB,KAAI,IAAIL,IAAI,GAAGA,IAAIE,GAAQ,KAC1B,IAAG,CAACE,EAAeJ,IAAI;GACtB,IAAIM,IAAoB,KAAK,MAAMN,IAAI5B,CAAY;GAKnD,AAJGkC,MAAsBD,MACxB,IAAY,KAAK,iBAAiBL,CAAC,GACnC,IAAiBM,IAElB,MAAM,KAAK,aAAab,GAAWO,IAAI5B,CAAY;EACpD;CAEF;CAEA,CAAC,UAAyC;EACzC,IAAMgC,IAA0C,CAAC;EACjD,KAAI,IAAIxB,KAAS,KAAK,cACrB,EAAeA,KAAS;EAGzB,IAAMR,IAAe,KAAK,oBACpB8B,IAAS,QAAQ,KAAK,KAAK,WAAW,MAAMxC,CAAY,GAC1D+B,IAAY,KAAK,iBAAiB,CAAC,GACnCY,IAAiB;EACrB,KAAI,IAAIL,IAAI,GAAGA,IAAIE,GAAQ,KAC1B,IAAG,CAACE,EAAeJ,IAAI;GACtB,IAAIM,IAAoB,KAAK,MAAMN,IAAI5B,CAAY;GAKnD,AAJGkC,MAAsBD,MACxB,IAAY,KAAK,iBAAiBL,CAAC,GACnC,IAAiBM,IAElB,MAAM,CAACN,GAAG,KAAK,aAAaP,GAAWO,IAAI5B,CAAY,CAAC;EACzD;CAEF;CAEA,iBAAyB,GAAe;EACvC,IAAImC,IAAe,KAAK,MAAMb,IAAQ,KAAK,kBAAkB,GACzDc,IAAkB,KAAK,oBAAoBD;EAC/C,IAAGC,GACF,OAAOA;EAER,IAAGD,KAAgB,KAAK,aAAa,QAAQ;GAG5C,EAAK,KAAK,QAAQ;GAClB,IAAI;IAEH,OAAMA,KAAgB,KAAK,aAAa,SAAQ;KAC/C,IAAIE,IAAW,KAAK,OAAO,UAAU,KAAK,qBAAqB,KAAK,mBAAmB,KAAK,mBAAmB;KAC/G,KAAK,aAAa,KAAKA,EAAS,OAAO;IACxC;GACD,UAAU;IACT,EAAO,KAAK,QAAQ;GACrB;EACD;EAEA,IAAIC,IAAQ,IAAIlD,EAAgB,KAAK,QAAQuB,EAAW,KAAK,aAAa,GAAGwB,CAAY,GAAG,KAAK,OAAO,YAAY,CAAC,GAEjHI,IAAc,KAAK,mBAAmB,KAAK,oBAC3CC,IAAOC,EAAc,KAAK,YAAYH,EAAM,KAAK,QAAQA,EAAM,kBAAkBC,CAAW;EAGhG,OADA,KAAK,oBAAoBJ,KAAgBK,GAClCA;CACR;CAEA,aAAqB,GAAY,GAAkB;EAClD,IAAM1B,IAAa,KAAK,kBAClB4B,IAAQpB,IAAQR;EACtB,OAAO6B,EAAQ,SAASD,GAAOA,IAAQ5B,CAAU;CAClD;CAEA,OAAO;EACN,KAAK,aAAa,KAAK;EAEvB,KAAI,IAAIJ,KAAW,KAAK,cAEvB,IADiBtB,EAAgB,KAAK,QAAQuB,EAAWD,GAAS,KAAK,OAAO,YAAY,CAC1F,CAAA,CAAO,KAAK;EAGb,AADA,KAAK,aAAa,KAAK,GACpB,KAAK,kBACP,KAAK,WAAW,KAAK;CAEvB;CAEA,kBAAoC;EACnC,OAAO,EACN,YAAY,KAAK,WAAW,gBAAgB,EAC7C;CACD;AACD"}