@daneren2005/shared-memory-objects 1.6.2 → 1.6.3

package/dist/shared-stack.js

@@ -1,8 +1,8 @@
-import { getPointer as e, storePointer 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";
-//#region src/shared-stack.ts
+import e from "./allocated-memory.js";
+import { lock as t, unlock as n } from "./lock/simple-lock.js";
+import { getPointer as r, storePointer as i } from "./utils/pointer.js";
+import { getArrayTypeCode as a, getByteMultipler as o, makeArrayView as s } from "./utils/array-type.js";
+// src/shared-stack.ts
 var c = 0, l = 1, u = 2, d = 3, f = 4, p = 5, m = 6, h = 7, g = 4, _ = 20, v = 22, y = (1 << v) - 1, b = 4194302, x = 1 << v, S = class v {
 	static BASE_ALLOCATE_COUNT = 8;
 	static DEFAULT_ALLOCATE_COUNT = this.BASE_ALLOCATE_COUNT + _;
@@ -75,28 +75,28 @@ var c = 0, l = 1, u = 2, d = 3, f = 4, p = 5, m = 6, h = 7, g = 4, _ = 20, v = 2
 	}
 	get usedMemory() {
 		let t = this.ownsFirstBlock ? this.firstBlock.usedMemory : 0;
-		for (let r = 0; r < this.segmentCount; r++) {
-			let i = e(Atomics.load(this.firstBlock.data, h + r), this.memory.positionBits);
-			t += new n(this.memory, i).usedMemory;
+		for (let n = 0; n < this.segmentCount; n++) {
+			let i = r(Atomics.load(this.firstBlock.data, h + n), this.memory.positionBits);
+			t += new e(this.memory, i).usedMemory;
 		}
 		return t;
 	}
-	constructor(e, t) {
-		if (this.memory = e, t && "firstBlock" in t) {
-			if (t.firstBlock instanceof n) this.firstBlock = t.firstBlock;
+	constructor(t, n) {
+		if (this.memory = t, n && "firstBlock" in n) {
+			if (n.firstBlock instanceof e) this.firstBlock = n.firstBlock;
 			else {
-				let r = new Uint32Array(e.buffers[t.firstBlock.bufferPosition].buf, t.firstBlock.bufferByteOffset + d * Uint32Array.BYTES_PER_ELEMENT, 1)[0];
-				this.firstBlock = new n(e, {
+				let r = new Uint32Array(t.buffers[n.firstBlock.bufferPosition].buf, n.firstBlock.bufferByteOffset + d * Uint32Array.BYTES_PER_ELEMENT, 1)[0];
+				this.firstBlock = new e(t, {
 					length: v.BASE_ALLOCATE_COUNT + r,
-					...t.firstBlock
+					...n.firstBlock
 				});
 			}
-			this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + l * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in t || "baseSegmentLength" in t || "maxLength" in t ? (this.initialize(t), this.ownsFirstBlock = !1) : this.ownsFirstBlock = !0;
+			this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + l * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in n || "baseSegmentLength" in n || "maxLength" in n ? (this.initialize(n), this.ownsFirstBlock = !1) : this.ownsFirstBlock = !0;
 		} else {
-			let n = i(r(t?.type ?? Uint32Array)), a = t?.baseSegmentLength ?? g, o = this.resolveMaxSegmentLength(a, t?.maxSegmentLength, n), s = this.resolveMaxSegments(t?.maxLength, a, o);
-			this.firstBlock = e.allocUI32(v.BASE_ALLOCATE_COUNT + s), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + l * Uint32Array.BYTES_PER_ELEMENT, 2), this.ownsFirstBlock = !0, this.initialize(t);
+			let e = o(a(n?.type ?? Uint32Array)), r = n?.baseSegmentLength ?? g, i = this.resolveMaxSegmentLength(r, n?.maxSegmentLength, e), s = this.resolveMaxSegments(n?.maxLength, r, i);
+			this.firstBlock = t.allocUI32(v.BASE_ALLOCATE_COUNT + s), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + l * Uint32Array.BYTES_PER_ELEMENT, 2), this.ownsFirstBlock = !0, this.initialize(n);
 		}
-		if (this.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + m * Uint32Array.BYTES_PER_ELEMENT, 1), this.cachedByteMultipler = i(this.type), this.cachedBaseSegmentLength = this.baseSegmentLength, this.cachedMaxSegmentLength = this.maxSegmentLength, this.cachedCapSegmentCount = 32 - Math.clz32(this.cachedMaxSegmentLength / this.cachedBaseSegmentLength | 0), this.cachedGeometricCapacity = this.cachedBaseSegmentLength * ((1 << this.cachedCapSegmentCount) - 1), this.maxLength = v.getCapacity(this.maxSegments, this.cachedBaseSegmentLength, this.cachedMaxSegmentLength), this.maxLength > b) throw Error(`SharedStack maxLength ${this.maxLength} exceeds the ${b} the versioned length counter can address`);
+		if (this.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + m * Uint32Array.BYTES_PER_ELEMENT, 1), this.cachedByteMultipler = o(this.type), this.cachedBaseSegmentLength = this.baseSegmentLength, this.cachedMaxSegmentLength = this.maxSegmentLength, this.cachedCapSegmentCount = 32 - Math.clz32(this.cachedMaxSegmentLength / this.cachedBaseSegmentLength | 0), this.cachedGeometricCapacity = this.cachedBaseSegmentLength * ((1 << this.cachedCapSegmentCount) - 1), this.maxLength = v.getCapacity(this.maxSegments, this.cachedBaseSegmentLength, this.cachedMaxSegmentLength), this.maxLength > b) throw Error(`SharedStack maxLength ${this.maxLength} exceeds the ${b} the versioned length counter can address`);
 	}
 	resolveMaxSegmentLength(e, t, n = 1) {
 		let r = v.getMaxSegmentLength(this.memory.maxAllocationLength, e, n);
@@ -112,8 +112,8 @@ var c = 0, l = 1, u = 2, d = 3, f = 4, p = 5, m = 6, h = 7, g = 4, _ = 20, v = 2
 		return Math.min(r, i);
 	}
 	initialize(e) {
-		let n = r(e?.type ?? Uint32Array), a = i(n), o = e?.baseSegmentLength ?? g, s = this.resolveMaxSegmentLength(o, e?.maxSegmentLength, a), c = this.memory.allocUI32(o * (a + 1));
-		t(this.firstBlock.data, h, c.bufferPosition, c.bufferByteOffset, this.memory.positionBits), this.baseSegmentLength = o, this.maxSegmentLength = s, this.maxSegments = this.resolveMaxSegments(e?.maxLength, o, s), this.segmentCount = 1, this.type = n;
+		let t = a(e?.type ?? Uint32Array), n = o(t), r = e?.baseSegmentLength ?? g, s = this.resolveMaxSegmentLength(r, e?.maxSegmentLength, n), c = this.memory.allocUI32(r * (n + 1));
+		i(this.firstBlock.data, h, c.bufferPosition, c.bufferByteOffset, this.memory.positionBits), this.baseSegmentLength = r, this.maxSegmentLength = s, this.maxSegments = this.resolveMaxSegments(e?.maxLength, r, s), this.segmentCount = 1, this.type = t;
 	}
 	at(e) {
 		let t = this.length;
@@ -184,28 +184,28 @@ var c = 0, l = 1, u = 2, d = 3, f = 4, p = 5, m = 6, h = 7, g = 4, _ = 20, v = 2
 		let e = this.length, t = this.cachedMaxSegmentLength, n = this.baseSegmentLength, r = 0, i = this.getSegment(r), a = 0;
 		for (let o = 0; o < e; o++) yield i[a], a++, a >= n && (r++, i = this.getSegment(r), a = 0, n = Math.min(n * 2, t));
 	}
-	getSegment(r) {
-		if (this.cachedSegments[r]) return this.cachedSegments[r];
-		let i = r < this.cachedCapSegmentCount ? this.cachedBaseSegmentLength << r : this.cachedMaxSegmentLength, c;
-		if (r >= this.segmentCount) {
-			o(this.growLock);
+	getSegment(a) {
+		if (this.cachedSegments[a]) return this.cachedSegments[a];
+		let o = a < this.cachedCapSegmentCount ? this.cachedBaseSegmentLength << a : this.cachedMaxSegmentLength, c;
+		if (a >= this.segmentCount) {
+			t(this.growLock);
 			try {
-				r >= this.segmentCount && (c = this.memory.allocUI32(i * (this.cachedByteMultipler + 1)), t(this.firstBlock.data, h + r, c.bufferPosition, c.bufferByteOffset, this.memory.positionBits), Atomics.add(this.firstBlock.data, p, 1));
+				a >= this.segmentCount && (c = this.memory.allocUI32(o * (this.cachedByteMultipler + 1)), i(this.firstBlock.data, h + a, c.bufferPosition, c.bufferByteOffset, this.memory.positionBits), Atomics.add(this.firstBlock.data, p, 1));
 			} finally {
-				s(this.growLock);
+				n(this.growLock);
 			}
 		}
 		if (!c) {
-			let t = Atomics.load(this.firstBlock.data, h + r), i = e(t, this.memory.positionBits);
-			c = new n(this.memory, i);
+			let t = Atomics.load(this.firstBlock.data, h + a), n = r(t, this.memory.positionBits);
+			c = new e(this.memory, n);
 		}
-		let l = a(this.type, c.data.buffer, c.bufferByteOffset, i), u = c.bufferByteOffset + i * this.cachedByteMultipler * Uint32Array.BYTES_PER_ELEMENT;
-		return this.cachedSequences[r] = new Int32Array(c.data.buffer, u, i), this.cachedSegments[r] = l, l;
+		let l = s(this.type, c.data.buffer, c.bufferByteOffset, o), u = c.bufferByteOffset + o * this.cachedByteMultipler * Uint32Array.BYTES_PER_ELEMENT;
+		return this.cachedSequences[a] = new Int32Array(c.data.buffer, u, o), this.cachedSegments[a] = l, l;
 	}
 	free() {
 		for (let t = 0; t < this.segmentCount; t++) {
-			let r = Atomics.load(this.firstBlock.data, h + t), i = e(r, this.memory.positionBits);
-			new n(this.memory, i).free();
+			let n = Atomics.load(this.firstBlock.data, h + t), i = r(n, this.memory.positionBits);
+			new e(this.memory, i).free();
 		}
 		this.ownsFirstBlock && this.firstBlock.free();
 	}
@@ -213,7 +213,6 @@ var c = 0, l = 1, u = 2, d = 3, f = 4, p = 5, m = 6, h = 7, g = 4, _ = 20, v = 2
 		return { firstBlock: this.firstBlock.getSharedMemory() };
 	}
 };
-//#endregion
 export { S as default };
 
 //# sourceMappingURL=shared-stack.js.map

package/dist/shared-string.js

@@ -1,7 +1,7 @@
-import { getPointer as e, loadPointer as t, loadRawPointer as n, storeRawPointer as r } from "./utils/pointer.js";
-import i from "./allocated-memory.js";
-import { lock as a, unlock as o } from "./lock/simple-lock.js";
-//#region src/shared-string.ts
+import e from "./allocated-memory.js";
+import { lock as t, unlock as n } from "./lock/simple-lock.js";
+import { getPointer as r, loadPointer as i, loadRawPointer as a, storeRawPointer as o } from "./utils/pointer.js";
+// src/shared-string.ts
 var s = {
 	1: Uint8Array,
 	2: Uint16Array
@@ -12,12 +12,12 @@ var s = {
 	lock;
 	cachedPointer;
 	cachedString;
-	constructor(e, t) {
-		this.memory = e, typeof t == "string" ? (this.allocatedMemory = this.memory.allocUI32(f.ALLOCATE_COUNT), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + d * this.allocatedMemory.data.BYTES_PER_ELEMENT), this.updateString(t)) : (this.allocatedMemory = new i(e, t), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + d * this.allocatedMemory.data.BYTES_PER_ELEMENT), "value" in t && this.updateString(t.value));
+	constructor(t, n) {
+		this.memory = t, typeof n == "string" ? (this.allocatedMemory = this.memory.allocUI32(f.ALLOCATE_COUNT), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + d * this.allocatedMemory.data.BYTES_PER_ELEMENT), this.updateString(n)) : (this.allocatedMemory = new e(t, n), this.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + d * this.allocatedMemory.data.BYTES_PER_ELEMENT), "value" in n && this.updateString(n.value));
 	}
 	updateString(e) {
-		let t = this.createString(e);
-		a(this.lock), r(this.allocatedMemory.data, c, t.pointer), Atomics.store(this.allocatedMemory.data, l, e.length), Atomics.store(this.allocatedMemory.data, u, t.charType), o(this.lock), this.cachedPointer = t.pointer, this.cachedString = e;
+		let r = this.createString(e);
+		t(this.lock), o(this.allocatedMemory.data, c, r.pointer), Atomics.store(this.allocatedMemory.data, l, e.length), Atomics.store(this.allocatedMemory.data, u, r.charType), n(this.lock), this.cachedPointer = r.pointer, this.cachedString = e;
 	}
 	createString(e) {
 		if (e === "") return {
@@ -37,17 +37,17 @@ var s = {
 		};
 	}
 	get value() {
-		let t = n(this.allocatedMemory.data, c);
-		if (this.cachedPointer === t && this.cachedString !== void 0) return this.cachedString;
-		if (t === 0) return "";
-		let { bufferPosition: r, bufferByteOffset: i } = e(t, this.memory.positionBits);
-		a(this.lock);
-		let d = s[Atomics.load(this.allocatedMemory.data, u)], f = Atomics.load(this.allocatedMemory.data, l), m = p(new d(this.memory.buffers[r].buf, i, f));
-		return o(this.lock), this.cachedPointer = t, this.cachedString = m, m;
+		let e = a(this.allocatedMemory.data, c);
+		if (this.cachedPointer === e && this.cachedString !== void 0) return this.cachedString;
+		if (e === 0) return "";
+		let { bufferPosition: i, bufferByteOffset: o } = r(e, this.memory.positionBits);
+		t(this.lock);
+		let d = s[Atomics.load(this.allocatedMemory.data, u)], f = Atomics.load(this.allocatedMemory.data, l), m = p(new d(this.memory.buffers[i].buf, o, f));
+		return n(this.lock), this.cachedPointer = e, this.cachedString = m, m;
 	}
 	set value(e) {
-		let { bufferPosition: n, bufferByteOffset: r } = t(this.allocatedMemory.data, c, this.memory.positionBits);
-		this.updateString(e), r && this.memory.buffers[n].free(r);
+		let { bufferPosition: t, bufferByteOffset: n } = i(this.allocatedMemory.data, c, this.memory.positionBits);
+		this.updateString(e), n && this.memory.buffers[t].free(n);
 	}
 	getSharedMemory() {
 		return this.allocatedMemory.getSharedMemory();
@@ -56,8 +56,8 @@ var s = {
 		return this.allocatedMemory.pointer;
 	}
 	free() {
-		let { bufferPosition: e, bufferByteOffset: n } = t(this.allocatedMemory.data, c, this.memory.positionBits);
-		n && this.memory.buffers[e].free(n), this.allocatedMemory.free();
+		let { bufferPosition: e, bufferByteOffset: t } = i(this.allocatedMemory.data, c, this.memory.positionBits);
+		t && this.memory.buffers[e].free(t), this.allocatedMemory.free();
 	}
 };
 function p(e) {
@@ -67,7 +67,6 @@ function p(e) {
 	for (let r = 0; r < e.length; r += t) n += String.fromCharCode.apply(null, e.subarray(r, r + t));
 	return n;
 }
-//#endregion
 export { f as default };
 
 //# sourceMappingURL=shared-string.js.map

package/dist/shared-vector.js

@@ -1,7 +1,7 @@
-import { getPointer as e, loadPointer as t, storePointer as n, storeRawPointer as r } from "./utils/pointer.js";
-import i from "./allocated-memory.js";
+import e from "./allocated-memory.js";
+import { getPointer as t, loadPointer as n, storePointer as r, storeRawPointer as i } from "./utils/pointer.js";
 import { getArrayTypeCode as a, getByteMultipler as o, makeArrayView as s } from "./utils/array-type.js";
-//#region src/shared-vector.ts
+// src/shared-vector.ts
 var c = 0, l = 1, u = 2, d = 3, f = 4, p = class p {
 	static ALLOCATE_COUNT = 4;
 	memory;
@@ -36,24 +36,24 @@ var c = 0, l = 1, u = 2, d = 3, f = 4, p = class p {
 		return this.firstBlock.pointer;
 	}
 	get usedMemory() {
-		let e = new i(this.memory, t(this.firstBlock.data, c, this.memory.positionBits));
-		return this.firstBlock.usedMemory + e.usedMemory;
+		let t = new e(this.memory, n(this.firstBlock.data, c, this.memory.positionBits));
+		return this.firstBlock.usedMemory + t.usedMemory;
 	}
 	cachedFullDataBlock;
 	cachedPointer;
-	constructor(e, t) {
-		if (this.memory = e, t && "firstBlock" in t) {
-			if (this.firstBlock = new i(e, {
+	constructor(t, n) {
+		if (this.memory = t, n && "firstBlock" in n) {
+			if (this.firstBlock = new e(t, {
 				length: p.ALLOCATE_COUNT,
-				...t.firstBlock
-			}), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + d * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in t || "dataLength" in t) {
-				let r = a(t.type ?? Uint32Array), i = o(r), s = t.bufferLength ?? f, l = e.allocUI32(s * (t.dataLength ?? 1) * i);
-				n(this.firstBlock.data, c, l.bufferPosition, l.bufferByteOffset, e.positionBits), this.bufferLength = s, this.dataLength = t.dataLength ?? 1, this.type = r;
+				...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) {
+				let e = a(n.type ?? Uint32Array), i = o(e), s = n.bufferLength ?? f, l = t.allocUI32(s * (n.dataLength ?? 1) * i);
+				r(this.firstBlock.data, c, l.bufferPosition, l.bufferByteOffset, t.positionBits), this.bufferLength = s, this.dataLength = n.dataLength ?? 1, this.type = e;
 			}
 		} else {
-			this.firstBlock = e.allocUI32(p.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + d * Uint32Array.BYTES_PER_ELEMENT, 2);
-			let r = t?.dataLength ?? 1, i = t?.bufferLength ?? f, s = a(t?.type ?? Uint32Array), l = e.allocUI32(i * r * o(s));
-			n(this.firstBlock.data, c, l.bufferPosition, l.bufferByteOffset, e.positionBits), this.bufferLength = i, this.type = s, this.dataLength = r;
+			this.firstBlock = t.allocUI32(p.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + d * Uint32Array.BYTES_PER_ELEMENT, 2);
+			let e = n?.dataLength ?? 1, i = n?.bufferLength ?? f, s = a(n?.type ?? Uint32Array), l = t.allocUI32(i * e * o(s));
+			r(this.firstBlock.data, c, l.bufferPosition, l.bufferByteOffset, t.positionBits), this.bufferLength = i, this.type = s, this.dataLength = e;
 		}
 		this.cachedByteMultipler = o(this.type), this.cachedPointer = this.firstBlock.data[0], this.cachedFullDataBlock = this.getFullDataBlock();
 	}
@@ -102,30 +102,29 @@ var c = 0, l = 1, u = 2, d = 3, f = 4, p = class p {
 		return this.getFullDataBlock().subarray(0, this.length * this.dataLength);
 	}
 	getFullDataBlock() {
-		let t = Atomics.load(this.firstBlock.data, c);
-		if (this.cachedPointer === t && this.cachedFullDataBlock) return this.cachedFullDataBlock;
-		let n = e(t, this.memory.positionBits), r = new i(this.memory, n), a = s(this.type, r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
-		return this.cachedPointer = t, this.cachedFullDataBlock = a, a;
+		let n = Atomics.load(this.firstBlock.data, c);
+		if (this.cachedPointer === n && this.cachedFullDataBlock) return this.cachedFullDataBlock;
+		let r = t(n, this.memory.positionBits), i = new e(this.memory, r), a = s(this.type, i.data.buffer, i.bufferByteOffset, this.dataLength * this.bufferLength);
+		return this.cachedPointer = n, this.cachedFullDataBlock = a, a;
 	}
 	getDataBlock(e, t) {
 		let n = t * this.dataLength;
 		return e.subarray(n, n + this.dataLength);
 	}
 	growBuffer() {
-		let e = this.bufferLength * 2, n = this.dataLength, a = t(this.firstBlock.data, c, this.memory.positionBits), o = new i(this.memory, a), l = this.getFullDataBlock(), u = this.memory.allocUI32(e * n * this.cachedByteMultipler), d = s(this.type, u.data.buffer, u.bufferByteOffset, n * e);
+		let t = this.bufferLength * 2, r = this.dataLength, a = n(this.firstBlock.data, c, this.memory.positionBits), o = new e(this.memory, a), l = this.getFullDataBlock(), u = this.memory.allocUI32(t * r * this.cachedByteMultipler), d = s(this.type, u.data.buffer, u.bufferByteOffset, r * t);
 		d.set(l);
 		let f = u.pointer;
-		r(this.firstBlock.data, c, f), this.bufferLength = e, o.free(), this.cachedPointer = f, this.cachedFullDataBlock = d;
+		i(this.firstBlock.data, c, f), this.bufferLength = t, o.free(), this.cachedPointer = f, this.cachedFullDataBlock = d;
 	}
 	free() {
-		let e = t(this.firstBlock.data, c, this.memory.positionBits);
-		new i(this.memory, e).free(), this.firstBlock.free();
+		let t = n(this.firstBlock.data, c, this.memory.positionBits);
+		new e(this.memory, t).free(), this.firstBlock.free();
 	}
 	getSharedMemory() {
 		return { firstBlock: this.firstBlock.getSharedMemory() };
 	}
 };
-//#endregion
 export { p as default };
 
 //# sourceMappingURL=shared-vector.js.map

package/dist/spatial/shared-quadtree.js

@@ -1,13 +1,13 @@
-import { getPointer as e, loadRawPointer as t, storeRawPointer as n } from "../utils/pointer.js";
-import r from "../allocated-memory.js";
-import { ARRAY_TYPE as i, getArrayTypeCode as a, getByteMultipler as o, makeArrayView as s } from "../utils/array-type.js";
-import { lock as c, unlock as l } from "../lock/simple-lock.js";
-import u from "../shared-map.js";
-import d from "../shared-pool.js";
+import e from "../allocated-memory.js";
+import t from "../shared-pool.js";
+import n from "../shared-map.js";
+import { lock as r, unlock as i } from "../lock/simple-lock.js";
+import { getPointer as a, loadRawPointer as o, storeRawPointer as s } from "../utils/pointer.js";
+import { ARRAY_TYPE as c, getArrayTypeCode as l, getByteMultipler as u, makeArrayView as d } from "../utils/array-type.js";
 import { MinPriorityQueue as f, addCandidate as p, candidateLimit as m, distanceSquaredToRect as h } from "./spatial-neighbors.js";
 import { getSpatialMapCapacity as g, getSpatialPoolChunkSize as _ } from "./spatial-entity.js";
-//#region src/spatial/shared-quadtree.ts
-var v = 0, y = 1, b = 2, x = 3, S = 4, C = 5, w = 6, T = 0, E = 1, D = 2, O = 0, k = 1, A = 2, j = 3, M = 4, N = 5, P = 6, F = 7, I = 16777216, L = I, R = 4294967295, z = 4, B = 1e6, V = Float32Array, H = class a {
+// src/spatial/shared-quadtree.ts
+var v = 0, y = 1, b = 2, x = 3, S = 4, C = 5, w = 6, T = 0, E = 1, D = 2, O = 0, k = 1, A = 2, j = 3, M = 4, N = 5, P = 6, F = 7, I = 16777216, L = I, R = 4294967295, z = 4, B = 1e6, V = Float32Array, H = class l {
 	static ALLOCATE_COUNT = 14;
 	memory;
 	firstBlock;
@@ -46,42 +46,42 @@ var v = 0, y = 1, b = 2, x = 3, S = 4, C = 5, w = 6, T = 0, E = 1, D = 2, O = 0,
 	get type() {
 		return this.coordType;
 	}
-	constructor(s, c) {
-		if (this.memory = s, c && "firstBlock" in c) this.firstBlock = new r(s, c.firstBlock), this.coordType = this.firstBlock.data[C], this.pool = new d(s, { firstBlock: e(t(this.firstBlock.data, y), s.positionBits) }), this.idMap = new u(s, { firstBlock: e(t(this.firstBlock.data, b), s.positionBits) }), this.maxLevels = this.firstBlock.data[x], this.nodeCount = this.firstBlock.data[S], this.nullIndex = G(this.coordType);
+	constructor(r, i) {
+		if (this.memory = r, i && "firstBlock" in i) this.firstBlock = new e(r, i.firstBlock), this.coordType = this.firstBlock.data[C], this.pool = new t(r, { firstBlock: a(o(this.firstBlock.data, y), r.positionBits) }), this.idMap = new n(r, { firstBlock: a(o(this.firstBlock.data, b), r.positionBits) }), this.maxLevels = this.firstBlock.data[x], this.nodeCount = this.firstBlock.data[S], this.nullIndex = G(this.coordType);
 		else {
-			let e = c?.bounds ?? {
+			let e = i?.bounds ?? {
 				x: 0,
 				y: 0,
 				width: 0,
 				height: 0
-			}, t = c?.maxEntities ?? B;
-			if (this.maxLevels = c?.maxLevels ?? z, this.nodeCount = a.getNodeCount(this.maxLevels), this.coordType = U(c?.type), this.nullIndex = G(this.coordType), this.coordType === i.float32 && t > I) throw Error(`Float32 SharedQuadtree supports at most ${I} entities; pass type: Float64Array for more`);
-			let r = {
+			}, a = i?.maxEntities ?? B;
+			if (this.maxLevels = i?.maxLevels ?? z, this.nodeCount = l.getNodeCount(this.maxLevels), this.coordType = U(i?.type), this.nullIndex = G(this.coordType), this.coordType === c.float32 && a > I) throw Error(`Float32 SharedQuadtree supports at most ${I} entities; pass type: Float64Array for more`);
+			let o = {
 				type: W(this.coordType),
 				dataLength: F,
-				maxLength: t,
-				maxChunkSize: _(t, F, o(this.coordType), s.maxAllocationLength)
-			}, l = d.getAllocateCount(s, r), f = u.ALLOCATE_COUNT;
-			this.firstBlock = s.allocUI32(a.ALLOCATE_COUNT + l + f), this.firstBlock.data[x] = this.maxLevels, this.firstBlock.data[S] = this.nodeCount, this.firstBlock.data[C] = this.coordType;
+				maxLength: a,
+				maxChunkSize: _(a, F, u(this.coordType), r.maxAllocationLength)
+			}, d = t.getAllocateCount(r, o), f = n.ALLOCATE_COUNT;
+			this.firstBlock = r.allocUI32(l.ALLOCATE_COUNT + d + f), this.firstBlock.data[x] = this.maxLevels, this.firstBlock.data[S] = this.nodeCount, this.firstBlock.data[C] = this.coordType;
 			let p = this.getBoundsView();
 			p[0] = e.x, p[1] = e.y, p[2] = e.width, p[3] = e.height;
-			let m = s.allocUI32(this.nodeCount * D), h = new Uint32Array(m.data.buffer, m.bufferByteOffset, this.nodeCount * D);
+			let m = r.allocUI32(this.nodeCount * D), h = new Uint32Array(m.data.buffer, m.bufferByteOffset, this.nodeCount * D);
 			for (let e = 0; e < this.nodeCount; e++) h[e * D + E] = this.nullIndex;
-			n(this.firstBlock.data, v, m.pointer);
-			let w = this.firstBlock.getSubAllocation(a.ALLOCATE_COUNT, l);
-			this.pool = new d(s, {
+			s(this.firstBlock.data, v, m.pointer);
+			let w = this.firstBlock.getSubAllocation(l.ALLOCATE_COUNT, d);
+			this.pool = new t(r, {
 				firstBlock: w,
-				...r
-			}), n(this.firstBlock.data, y, w.pointer);
-			let T = this.firstBlock.getSubAllocation(a.ALLOCATE_COUNT + l, f);
-			this.idMap = new u(s, {
+				...o
+			}), s(this.firstBlock.data, y, w.pointer);
+			let T = this.firstBlock.getSubAllocation(l.ALLOCATE_COUNT + d, f);
+			this.idMap = new n(r, {
 				firstBlock: T,
-				capacity: g(t, s.maxAllocationLength)
-			}), n(this.firstBlock.data, b, T.pointer);
+				capacity: g(a, r.maxAllocationLength)
+			}), s(this.firstBlock.data, b, T.pointer);
 		}
-		let l = this.getBoundsView();
-		this.rootX = l[0], this.rootY = l[1], this.rootWidth = l[2], this.rootHeight = l[3];
-		let f = new r(s, e(t(this.firstBlock.data, v), s.positionBits));
+		let d = this.getBoundsView();
+		this.rootX = d[0], this.rootY = d[1], this.rootWidth = d[2], this.rootHeight = d[3];
+		let f = new e(r, a(o(this.firstBlock.data, v), r.positionBits));
 		this.nodeInts = new Int32Array(f.data.buffer, f.bufferByteOffset, this.nodeCount * D), this.nodeHeads = new Uint32Array(f.data.buffer, f.bufferByteOffset, this.nodeCount * D);
 	}
 	static getNodeCount(e) {
@@ -91,8 +91,8 @@ var v = 0, y = 1, b = 2, x = 3, S = 4, C = 5, w = 6, T = 0, E = 1, D = 2, O = 0,
 		return this.firstBlock.pointer;
 	}
 	get usedMemory() {
-		let n = new r(this.memory, e(t(this.firstBlock.data, v), this.memory.positionBits));
-		return this.firstBlock.usedMemory + n.usedMemory + this.pool.usedMemory + this.idMap.usedMemory;
+		let t = new e(this.memory, a(o(this.firstBlock.data, v), this.memory.positionBits));
+		return this.firstBlock.usedMemory + t.usedMemory + this.pool.usedMemory + this.idMap.usedMemory;
 	}
 	insert(e, t, n, r = 0, i = 0) {
 		if (this.idMap.get(e) !== void 0) {
@@ -119,19 +119,19 @@ var v = 0, y = 1, b = 2, x = 3, S = 4, C = 5, w = 6, T = 0, E = 1, D = 2, O = 0,
 		}
 		this.idMap.setAll(i);
 	}
-	update(e, t, n, r = 0, i = 0) {
-		let a = this.idMap.get(e);
-		if (a === void 0) {
-			this.insert(e, t, n, r, i);
+	update(e, t, n, a = 0, o = 0) {
+		let s = this.idMap.get(e);
+		if (s === void 0) {
+			this.insert(e, t, n, a, o);
 			return;
 		}
-		let o = this.pool.blockFor(a), s = this.pool.blockOffset(a), u = o[s + N], d = this.locate(t, n, r, i);
+		let c = this.pool.blockFor(s), l = this.pool.blockOffset(s), u = c[l + N], d = this.locate(t, n, a, o);
 		if (u === d) {
-			c(this.nodeInts, u * D + T), o[s + k] = t, o[s + A] = n, o[s + j] = r, o[s + M] = i, l(this.nodeInts, u * D + T);
+			r(this.nodeInts, u * D + T), c[l + k] = t, c[l + A] = n, c[l + j] = a, c[l + M] = o, i(this.nodeInts, u * D + T);
 			return;
 		}
 		let f = Math.min(u, d), p = Math.max(u, d);
-		c(this.nodeInts, f * D + T), c(this.nodeInts, p * D + T), this.unlinkNoLock(u, a), o[s + k] = t, o[s + A] = n, o[s + j] = r, o[s + M] = i, o[s + N] = d, this.linkNoLock(d, a), l(this.nodeInts, p * D + T), l(this.nodeInts, f * D + T);
+		r(this.nodeInts, f * D + T), r(this.nodeInts, p * D + T), this.unlinkNoLock(u, s), c[l + k] = t, c[l + A] = n, c[l + j] = a, c[l + M] = o, c[l + N] = d, this.linkNoLock(d, s), i(this.nodeInts, p * D + T), i(this.nodeInts, f * D + T);
 	}
 	remove(e) {
 		let t = this.idMap.get(e);
@@ -252,13 +252,13 @@ var v = 0, y = 1, b = 2, x = 3, S = 4, C = 5, w = 6, T = 0, E = 1, D = 2, O = 0,
 		for (let t of e) this.idMap.delete(t);
 	}
 	free() {
-		new r(this.memory, e(t(this.firstBlock.data, v), this.memory.positionBits)).free(), this.pool.free(), this.idMap.free(), this.firstBlock.free();
+		new e(this.memory, a(o(this.firstBlock.data, v), this.memory.positionBits)).free(), this.pool.free(), this.idMap.free(), this.firstBlock.free();
 	}
 	getSharedMemory() {
 		return { firstBlock: this.firstBlock.getSharedMemory() };
 	}
 	getBoundsView() {
-		return s(this.coordType, this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + w * Uint32Array.BYTES_PER_ELEMENT, 4);
+		return d(this.coordType, this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + w * Uint32Array.BYTES_PER_ELEMENT, 4);
 	}
 	locate(e, t, n, r) {
 		let i = 0, a = this.rootX, o = this.rootY, s = this.rootWidth, c = this.rootHeight;
@@ -272,52 +272,52 @@ var v = 0, y = 1, b = 2, x = 3, S = 4, C = 5, w = 6, T = 0, E = 1, D = 2, O = 0,
 		}
 		return i;
 	}
-	collect(e, t, n, r, i, a, o, s, u, d, f) {
+	collect(e, t, n, a, o, s, c, l, u, d, f) {
 		let p = t * D + E;
 		if (this.nodeHeads[p] !== this.nullIndex) {
 			let n = t * D + T;
-			c(this.nodeInts, n);
-			let r = this.nodeHeads[p], i = this.pool;
-			for (; r !== this.nullIndex;) {
-				let t = i.blockFor(r), n = i.blockOffset(r);
-				e.push(t[n + O]), r = t[n + P];
+			r(this.nodeInts, n);
+			let a = this.nodeHeads[p], o = this.pool;
+			for (; a !== this.nullIndex;) {
+				let t = o.blockFor(a), n = o.blockOffset(a);
+				e.push(t[n + O]), a = t[n + P];
 			}
-			l(this.nodeInts, n);
+			i(this.nodeInts, n);
 		}
-		if (o >= this.maxLevels) return;
-		let m = n + i / 2, h = r + a / 2, g = i / 2, _ = a / 2, v = s < m, y = s + d > m, b = u < h, x = u + f > h;
-		b && v && this.collect(e, t * 4 + 1, n, r, g, _, o + 1, s, u, d, f), b && y && this.collect(e, t * 4 + 2, m, r, g, _, o + 1, s, u, d, f), x && v && this.collect(e, t * 4 + 3, n, h, g, _, o + 1, s, u, d, f), x && y && this.collect(e, t * 4 + 4, m, h, g, _, o + 1, s, u, d, f);
+		if (c >= this.maxLevels) return;
+		let m = n + o / 2, h = a + s / 2, g = o / 2, _ = s / 2, v = l < m, y = l + d > m, b = u < h, x = u + f > h;
+		b && v && this.collect(e, t * 4 + 1, n, a, g, _, c + 1, l, u, d, f), b && y && this.collect(e, t * 4 + 2, m, a, g, _, c + 1, l, u, d, f), x && v && this.collect(e, t * 4 + 3, n, h, g, _, c + 1, l, u, d, f), x && y && this.collect(e, t * 4 + 4, m, h, g, _, c + 1, l, u, d, f);
 	}
-	collectNeighborNode(e, t, n, r, i) {
-		let a = t * D + E;
-		if (this.nodeHeads[a] === this.nullIndex) return;
-		let o = t * D + T;
-		c(this.nodeInts, o);
-		let s = this.nodeHeads[a];
-		for (; s !== this.nullIndex;) {
-			let t = this.pool.blockFor(s), a = this.pool.blockOffset(s), o = t[a + O], c = h(n, r, t[a + k], t[a + A], t[a + k] + t[a + j], t[a + A] + t[a + M]);
-			c <= i && e.push({
-				id: o,
-				distance: c
-			}), s = t[a + P];
+	collectNeighborNode(e, t, n, a, o) {
+		let s = t * D + E;
+		if (this.nodeHeads[s] === this.nullIndex) return;
+		let c = t * D + T;
+		r(this.nodeInts, c);
+		let l = this.nodeHeads[s];
+		for (; l !== this.nullIndex;) {
+			let t = this.pool.blockFor(l), r = this.pool.blockOffset(l), i = t[r + O], s = h(n, a, t[r + k], t[r + A], t[r + k] + t[r + j], t[r + A] + t[r + M]);
+			s <= o && e.push({
+				id: i,
+				distance: s
+			}), l = t[r + P];
 		}
-		l(this.nodeInts, o);
+		i(this.nodeInts, c);
 	}
-	collectNearestNode(e, t, n, r) {
-		let i = t * D + E;
-		if (this.nodeHeads[i] === this.nullIndex) return;
-		let a = t * D + T;
-		c(this.nodeInts, a);
-		let o = this.nodeHeads[i];
-		for (; o !== this.nullIndex;) {
-			let t = this.pool.blockFor(o), i = this.pool.blockOffset(o), a = t[i + O], s = h(n, r, t[i + k], t[i + A], t[i + k] + t[i + j], t[i + A] + t[i + M]);
-			(s < e.distance || s === e.distance && (e.id === void 0 || a < e.id)) && (e.id = a, e.distance = s), o = t[i + P];
+	collectNearestNode(e, t, n, a) {
+		let o = t * D + E;
+		if (this.nodeHeads[o] === this.nullIndex) return;
+		let s = t * D + T;
+		r(this.nodeInts, s);
+		let c = this.nodeHeads[o];
+		for (; c !== this.nullIndex;) {
+			let t = this.pool.blockFor(c), r = this.pool.blockOffset(c), i = t[r + O], o = h(n, a, t[r + k], t[r + A], t[r + k] + t[r + j], t[r + A] + t[r + M]);
+			(o < e.distance || o === e.distance && (e.id === void 0 || i < e.id)) && (e.id = i, e.distance = o), c = t[r + P];
 		}
-		l(this.nodeInts, a);
+		i(this.nodeInts, s);
 	}
 	linkIntoNode(e, t) {
 		let n = e * D + T;
-		c(this.nodeInts, n), this.linkNoLock(e, t), l(this.nodeInts, n);
+		r(this.nodeInts, n), this.linkNoLock(e, t), i(this.nodeInts, n);
 	}
 	linkNoLock(e, t) {
 		let n = e * D + E;
@@ -325,7 +325,7 @@ var v = 0, y = 1, b = 2, x = 3, S = 4, C = 5, w = 6, T = 0, E = 1, D = 2, O = 0,
 	}
 	unlinkFromNode(e, t) {
 		let n = e * D + T;
-		c(this.nodeInts, n), this.unlinkNoLock(e, t), l(this.nodeInts, n);
+		r(this.nodeInts, n), this.unlinkNoLock(e, t), i(this.nodeInts, n);
 	}
 	unlinkNoLock(e, t) {
 		let n = e * D + E, r = this.nodeHeads[n], i = this.pool.get(t, P);
@@ -345,17 +345,16 @@ var v = 0, y = 1, b = 2, x = 3, S = 4, C = 5, w = 6, T = 0, E = 1, D = 2, O = 0,
 	}
 };
 function U(e) {
-	let t = a(e ?? V);
-	if (t !== i.float32 && t !== i.float64) throw Error("SharedQuadtree must be Float32Array or Float64Array");
+	let t = l(e ?? V);
+	if (t !== c.float32 && t !== c.float64) throw Error("SharedQuadtree must be Float32Array or Float64Array");
 	return t;
 }
 function W(e) {
-	return o(e) === 2 ? Float64Array : Float32Array;
+	return u(e) === 2 ? Float64Array : Float32Array;
 }
 function G(e) {
-	return e === i.float32 ? L : R;
+	return e === c.float32 ? L : R;
 }
-//#endregion
 export { H as default };
 
 //# sourceMappingURL=shared-quadtree.js.map