@daneren2005/shared-memory-objects 1.4.0 → 1.5.1

package/dist/spatial/shared-spatial-map.d.ts

@@ -0,0 +1,87 @@
+import type { SharedAllocatedMemory } from '../allocated-memory';
+import type MemoryHeap from '../memory-heap';
+import { type SpatialEntity } from './spatial-entity';
+type CoordArrayConstructor = Float32ArrayConstructor | Float64ArrayConstructor;
+export default class SharedSpatialMap {
+    static readonly ALLOCATE_COUNT = 11;
+    private memory;
+    private firstBlock;
+    private entityPool;
+    private slotPool;
+    private idMap;
+    private bucketPointers;
+    private entityScratch;
+    private slotScratch;
+    private bucketSegments;
+    private bucketHeadSegments;
+    private tableLock;
+    private readonly coordType;
+    private readonly nullIndex;
+    private bucketCount;
+    private readonly maxBucketCount;
+    private bucketMask;
+    private readonly cellSize;
+    get size(): number;
+    get gridSize(): number;
+    get buckets(): number;
+    get maxBuckets(): number;
+    get type(): number;
+    constructor(memory: MemoryHeap, config?: SharedSpatialMapConfig | SharedSpatialMapMemory);
+    get pointer(): number;
+    get usedMemory(): number;
+    insert(id: number, x: number, y: number, width?: number, height?: number): void;
+    bulkInsert(entities: Iterable<SpatialEntity>): void;
+    private insertLocked;
+    update(id: number, x: number, y: number, width?: number, height?: number): void;
+    private updateLocked;
+    remove(id: number): boolean;
+    private removeLocked;
+    has(id: number): boolean;
+    search(x: number, y: number, width: number, height: number, filter?: (id: number) => boolean): Array<number>;
+    searchInto(out: Array<number>, x: number, y: number, width: number, height: number, filter?: (id: number) => boolean): Array<number>;
+    private searchIntoLocked;
+    neighbors(x: number, y: number, maxResults: number, maxDistance: number, filter?: (id: number) => boolean): Array<number>;
+    private neighborsLocked;
+    clear(): void;
+    free(): void;
+    getSharedMemory(): SharedSpatialMapMemory;
+    private getConfigView;
+    private colOf;
+    private rowOf;
+    private mapRingDistanceSquared;
+    private bucketOf;
+    private bucketOffset;
+    private getBucketSegment;
+    private appendBucketSegments;
+    private syncBucketCount;
+    private growBucketsIfNeeded;
+    private ensureBucketCapacity;
+    private resizeBuckets;
+    private growBucketsForBulk;
+    private linkRange;
+    private linkIntoBucket;
+    private linkReservedBucket;
+    private relinkRange;
+    private refreshAnchorInBucket;
+    private unlinkRange;
+    private collectBucket;
+    private collectNeighborBucket;
+    private collectNearestBucket;
+    private collectNeighborCandidates;
+    private addEntityCandidate;
+    private entityDistanceSquared;
+    private entityBlockDistanceSquared;
+    private unlinkFromBucket;
+}
+interface SharedSpatialMapConfig {
+    gridSize?: number;
+    buckets?: number;
+    maxBuckets?: number;
+    maxEntities?: number;
+    maxSlots?: number;
+    type?: CoordArrayConstructor;
+}
+interface SharedSpatialMapMemory {
+    firstBlock: SharedAllocatedMemory;
+}
+export type { SharedSpatialMapConfig, SharedSpatialMapMemory, SpatialEntity };

package/dist/spatial/shared-spatial-map.js

@@ -0,0 +1,555 @@
+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-stack.js";
+import f from "../shared-pool.js";
+import { readLock as p, readUnlock as m, writeLock as h, writeUnlock as g } from "../lock/read-write-lock.js";
+import { addCandidate as _, candidateLimit as v, distanceSquaredToRect as y } from "./spatial-neighbors.js";
+import { getSpatialMapCapacity as ee, getSpatialPoolChunkSize as te } from "./spatial-entity.js";
+//#region src/spatial/shared-spatial-map.ts
+var b = 0, x = 1, S = 2, C = 3, w = 4, T = 5, E = 6, D = 8, ne = 10, O = 0, k = 1, A = 2, j = 8, M = 256, re = 255, N = 0, P = 1, F = 2, I = 3, L = 4, R = 5, z = 6, B = 7, V = 0, H = 1, U = 2, W = 3, G = 4, K = 5, q = 6, J = 7, Y = 8, X = 16777216, ie = X, ae = 4294967295, oe = 73856093, se = 19349663, ce = 50, le = 256, Z = 1, Q = 2, ue = 1e6, de = 4, fe = Float32Array, pe = class a {
+	static ALLOCATE_COUNT = 11;
+	memory;
+	firstBlock;
+	entityPool;
+	slotPool;
+	idMap;
+	bucketPointers;
+	entityScratch = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	slotScratch = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	bucketSegments = [];
+	bucketHeadSegments = [];
+	tableLock;
+	coordType;
+	nullIndex;
+	bucketCount;
+	maxBucketCount;
+	bucketMask;
+	cellSize;
+	get size() {
+		return this.idMap.length;
+	}
+	get gridSize() {
+		return this.cellSize;
+	}
+	get buckets() {
+		return Atomics.load(this.firstBlock.data, w);
+	}
+	get maxBuckets() {
+		return this.maxBucketCount;
+	}
+	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[T], this.bucketPointers = new d(s, { firstBlock: e(t(this.firstBlock.data, b), s.positionBits) }), this.entityPool = new f(s, { firstBlock: e(t(this.firstBlock.data, x), s.positionBits) }), this.slotPool = new f(s, { firstBlock: e(t(this.firstBlock.data, S), s.positionBits) }), this.idMap = new u(s, { firstBlock: e(t(this.firstBlock.data, C), s.positionBits) }), this.bucketCount = Atomics.load(this.firstBlock.data, w), this.maxBucketCount = this.firstBlock.data[ne], this.nullIndex = ge(this.coordType);
+		else {
+			let e = c?.gridSize ?? ce;
+			this.bucketCount = Math.min(1073741824, Math.max(1, Math.floor(c?.buckets ?? le)));
+			let t = c?.maxEntities ?? ue, r = c?.maxSlots ?? t * de;
+			if (this.maxBucketCount = Math.min(1073741824, Math.max(this.bucketCount, Math.floor(c?.maxBuckets ?? _e(r * 2)))), this.coordType = me(c?.type), this.nullIndex = ge(this.coordType), this.coordType === i.float32 && (t > X || r > X)) throw Error(`Float32 SharedSpatialMap supports at most ${X} entities and slots; pass type: Float64Array for more`);
+			let l = {
+				type: he(this.coordType),
+				dataLength: Y,
+				maxLength: t,
+				maxChunkSize: te(t, Y, o(this.coordType), s.maxAllocationLength)
+			}, p = {
+				type: he(this.coordType),
+				dataLength: B,
+				maxLength: r,
+				maxChunkSize: te(r, B, o(this.coordType), s.maxAllocationLength)
+			}, m = f.getAllocateCount(s, l), h = f.getAllocateCount(s, p), g = u.ALLOCATE_COUNT, _ = a.ALLOCATE_COUNT;
+			this.firstBlock = s.allocUI32(_ + m + h + g), this.firstBlock.data[w] = this.bucketCount, this.firstBlock.data[T] = this.coordType, this.firstBlock.data[ne] = this.maxBucketCount;
+			let v = this.getConfigView();
+			v[0] = e, this.bucketPointers = new d(s), n(this.firstBlock.data, b, this.bucketPointers.pointer), this.appendBucketSegments(this.bucketCount);
+			let y = this.firstBlock.getSubAllocation(_, m);
+			this.entityPool = new f(s, {
+				firstBlock: y,
+				...l
+			}), n(this.firstBlock.data, x, y.pointer);
+			let E = this.firstBlock.getSubAllocation(_ + m, h);
+			this.slotPool = new f(s, {
+				firstBlock: E,
+				...p
+			}), n(this.firstBlock.data, S, E.pointer);
+			let D = this.firstBlock.getSubAllocation(_ + m + h, g);
+			this.idMap = new u(s, {
+				firstBlock: D,
+				capacity: ee(t, s.maxAllocationLength)
+			}), n(this.firstBlock.data, C, D.pointer);
+		}
+		this.bucketMask = $(this.bucketCount), this.tableLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + D * Uint32Array.BYTES_PER_ELEMENT, 2);
+		let l = this.getConfigView();
+		this.cellSize = l[0];
+	}
+	get pointer() {
+		return this.firstBlock.pointer;
+	}
+	get usedMemory() {
+		let t = this.firstBlock.usedMemory + this.bucketPointers.usedMemory + this.entityPool.usedMemory + this.slotPool.usedMemory + this.idMap.usedMemory;
+		for (let n of this.bucketPointers) t += new r(this.memory, e(n, this.memory.positionBits)).usedMemory;
+		return t;
+	}
+	insert(e, t, n, r = 0, i = 0) {
+		p(this.tableLock);
+		try {
+			this.syncBucketCount(), this.insertLocked(e, t, n, r, i);
+		} finally {
+			m(this.tableLock);
+		}
+		this.growBucketsIfNeeded();
+	}
+	bulkInsert(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n of e) t.set(n.id, n);
+		let n = Array.from(t.values()), r = this.idMap.getAll(n.map((e) => e.id)), i = [], a = 0, o = 0;
+		for (let e = 0; e < n.length; e++) if (r[e] === void 0) {
+			let t = n[e];
+			o++, a += (this.colOf(t.x + (t.width ?? 0)) - this.colOf(t.x) + 1) * (this.rowOf(t.y + (t.height ?? 0)) - this.rowOf(t.y) + 1);
+		}
+		this.ensureBucketCapacity(this.slotPool.length + a);
+		let s = this.entityPool.reserveContiguous(o), c = this.slotPool.reserveContiguous(a);
+		p(this.tableLock);
+		try {
+			this.syncBucketCount();
+			for (let e = 0; e < n.length; e++) {
+				let t = n[e], a = t.width ?? 0, o = t.height ?? 0;
+				if (r[e] !== void 0) {
+					this.updateLocked(t.id, t.x, t.y, a, o);
+					continue;
+				}
+				let l = this.colOf(t.x), u = this.rowOf(t.y), d = this.colOf(t.x + a), f = this.rowOf(t.y + o), p = s++, m = this.entityPool.blockFor(p), h = this.entityPool.blockOffset(p);
+				m[h + V] = l, m[h + H] = u, m[h + U] = d, m[h + W] = f, m[h + G] = t.x, m[h + K] = t.y, m[h + q] = a, m[h + J] = o, i.push([t.id, p]);
+				for (let e = u; e <= f; e++) for (let n = l; n <= d; n++) this.linkReservedBucket(n, e, c++, t.id, p, l, u);
+			}
+			this.idMap.setAll(i);
+		} finally {
+			m(this.tableLock);
+		}
+		this.growBucketsForBulk();
+	}
+	insertLocked(e, t, n, r, i) {
+		if (this.idMap.get(e) !== void 0) {
+			this.updateLocked(e, t, n, r, i);
+			return;
+		}
+		let a = this.colOf(t), o = this.rowOf(n), s = this.colOf(t + r), c = this.rowOf(n + i), l = this.entityScratch;
+		l[V] = a, l[H] = o, l[U] = s, l[W] = c, l[G] = t, l[K] = n, l[q] = r, l[J] = i;
+		let u = this.entityPool.push(l);
+		this.idMap.set(e, u), this.linkRange(e, u, a, o, s, c);
+	}
+	update(e, t, n, r = 0, i = 0) {
+		let a = this.idMap.get(e);
+		if (a !== void 0) {
+			let e = this.entityPool.blockFor(a), o = this.entityPool.blockOffset(a), s = this.colOf(t), c = this.rowOf(n), l = this.colOf(t + r), u = this.rowOf(n + i);
+			if (s === e[o + V] && c === e[o + H] && l === e[o + U] && u === e[o + W]) {
+				e[o + G] = t, e[o + K] = n, e[o + q] = r, e[o + J] = i;
+				return;
+			}
+		}
+		p(this.tableLock);
+		try {
+			this.syncBucketCount(), this.updateLocked(e, t, n, r, i);
+		} finally {
+			m(this.tableLock);
+		}
+		this.growBucketsIfNeeded();
+	}
+	updateLocked(e, t, n, r, i) {
+		let a = this.idMap.get(e);
+		if (a === void 0) {
+			this.insertLocked(e, t, n, r, i);
+			return;
+		}
+		let o = this.entityPool.blockFor(a), s = this.entityPool.blockOffset(a), c = o[s + V], l = o[s + H], u = o[s + U], d = o[s + W], f = this.colOf(t), p = this.rowOf(n), m = this.colOf(t + r), h = this.rowOf(n + i);
+		if (f === c && p === l && m === u && h === d) {
+			o[s + G] = t, o[s + K] = n, o[s + q] = r, o[s + J] = i;
+			return;
+		}
+		this.relinkRange(e, a, f, p, m, h, c, l, u, d), o[s + V] = f, o[s + H] = p, o[s + U] = m, o[s + W] = h, o[s + G] = t, o[s + K] = n, o[s + q] = r, o[s + J] = i;
+	}
+	remove(e) {
+		p(this.tableLock);
+		try {
+			return this.syncBucketCount(), this.removeLocked(e);
+		} finally {
+			m(this.tableLock);
+		}
+	}
+	removeLocked(e) {
+		let t = this.idMap.get(e);
+		if (t === void 0) return !1;
+		let n = this.entityPool.blockFor(t), r = this.entityPool.blockOffset(t);
+		return this.unlinkRange(e, n[r + V], n[r + H], n[r + U], n[r + W]), this.entityPool.deleteIndex(t), this.idMap.delete(e), !0;
+	}
+	has(e) {
+		return this.idMap.get(e) !== void 0;
+	}
+	search(e, t, n, r, i) {
+		let a = [];
+		return this.searchInto(a, e, t, n, r, i), a;
+	}
+	searchInto(e, t, n, r, i, a) {
+		p(this.tableLock);
+		try {
+			return this.syncBucketCount(), this.searchIntoLocked(e, t, n, r, i, a);
+		} finally {
+			m(this.tableLock);
+		}
+	}
+	searchIntoLocked(e, t, n, r, i, a) {
+		let o = e.length, s = this.colOf(t), c = this.rowOf(n), l = this.colOf(t + r), u = this.rowOf(n + i), d = this.nullIndex;
+		for (let t = c; t <= u; t++) for (let n = s; n <= l; n++) {
+			let r = this.bucketOf(n, t), i = this.getBucketSegment(r), a = this.bucketOffset(r), o = this.bucketHeadSegments[r >>> j];
+			o[a + k] !== d && this.collectBucket(e, i, o, a, n, t, s, c);
+		}
+		if (a !== void 0) {
+			let t = o;
+			for (let n = o; n < e.length; n++) {
+				let r = e[n];
+				a(r) && (e[t++] = r);
+			}
+			e.length = t;
+		}
+		return e;
+	}
+	neighbors(e, t, n, r, i) {
+		p(this.tableLock);
+		try {
+			return this.syncBucketCount(), this.neighborsLocked(e, t, n, r, i);
+		} finally {
+			m(this.tableLock);
+		}
+	}
+	neighborsLocked(e, t, n, r, i) {
+		if (n <= 0 || r < 0 || Number.isNaN(n) || Number.isNaN(r) || (n = Math.floor(n), n === 0)) return [];
+		let a = r * r, o = [];
+		if (!Number.isFinite(r)) {
+			for (let [r, s] of this.idMap) (i === void 0 || i(r)) && this.addEntityCandidate(o, r, s, e, t, n, a);
+			return o.map((e) => e.id);
+		}
+		let s = [], c = i !== void 0 && n > 1 ? /* @__PURE__ */ new Set() : void 0, l = this.colOf(e), u = this.rowOf(t), d = {
+			id: void 0,
+			distance: a
+		}, f = (r, f) => {
+			if (i === void 0) {
+				n === 1 ? this.collectNearestBucket(d, r, f, e, t) : this.collectNeighborCandidates(o, r, f, l, u, e, t, n, a);
+				return;
+			}
+			s.length = 0, this.collectNeighborBucket(s, r, f);
+			for (let r of s) {
+				if (c?.has(r)) continue;
+				c?.add(r);
+				let s = this.idMap.get(r);
+				if (s !== void 0 && (i === void 0 || i(r))) {
+					if (n === 1) {
+						let n = this.entityDistanceSquared(s, e, t);
+						(n < d.distance || n === d.distance && (d.id === void 0 || r < d.id)) && (d.id = r, d.distance = n);
+					} else this.addEntityCandidate(o, r, s, e, t, n, a);
+				}
+			}
+		};
+		for (let r = 0;; r++) {
+			let i = n === 1 ? d.distance : v(o, n, a);
+			if (this.mapRingDistanceSquared(e, t, l, u, r) > i) break;
+			if (r === 0) {
+				f(l, u);
+				continue;
+			}
+			let s = l - r, c = l + r, p = u - r, m = u + r;
+			for (let e = s; e <= c; e++) f(e, p), f(e, m);
+			for (let e = p + 1; e < m; e++) f(s, e), f(c, e);
+		}
+		return n === 1 ? d.id === void 0 ? [] : [d.id] : o.map((e) => e.id);
+	}
+	clear() {
+		h(this.tableLock);
+		try {
+			this.syncBucketCount();
+			for (let e = 0; e < this.bucketPointers.length; e++) {
+				this.getBucketSegment(e << j);
+				let t = this.bucketHeadSegments[e];
+				for (let e = k; e < t.length; e += A) t[e] = this.nullIndex;
+			}
+			this.entityPool.clear(), this.slotPool.clear();
+			let e = [];
+			for (let [t] of this.idMap) e.push(t);
+			for (let t of e) this.idMap.delete(t);
+		} finally {
+			g(this.tableLock);
+		}
+	}
+	free() {
+		for (let t of this.bucketPointers) new r(this.memory, e(t, this.memory.positionBits)).free();
+		this.bucketPointers.free(), this.entityPool.free(), this.slotPool.free(), this.idMap.free(), this.firstBlock.free();
+	}
+	getSharedMemory() {
+		return { firstBlock: this.firstBlock.getSharedMemory() };
+	}
+	getConfigView() {
+		return s(this.coordType, this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + E * Uint32Array.BYTES_PER_ELEMENT, 1);
+	}
+	colOf(e) {
+		return Math.floor(e / this.cellSize);
+	}
+	rowOf(e) {
+		return Math.floor(e / this.cellSize);
+	}
+	mapRingDistanceSquared(e, t, n, r, i) {
+		if (i === 0) return 0;
+		let a = this.cellSize, o = e - (n - i + 1) * a, s = (n + i) * a - e, c = t - (r - i + 1) * a, l = (r + i) * a - t, u = Math.min(o, s, c, l);
+		return u * u;
+	}
+	bucketOf(e, t) {
+		let n = (Math.imul(e, oe) ^ Math.imul(t, se)) >>> 0, r = this.bucketMask;
+		return r >= 0 ? n & r : n % this.bucketCount;
+	}
+	bucketOffset(e) {
+		return (e & re) * A;
+	}
+	getBucketSegment(t) {
+		let n = t >>> j, i = this.bucketSegments[n];
+		if (i !== void 0) return i;
+		let a = this.bucketPointers.at(n), o = new r(this.memory, e(a, this.memory.positionBits)), s = new Int32Array(o.data.buffer, o.bufferByteOffset, M * A);
+		return this.bucketHeadSegments[n] = new Uint32Array(o.data.buffer, o.bufferByteOffset, M * A), this.bucketSegments[n] = s, s;
+	}
+	appendBucketSegments(e) {
+		let t = Math.ceil(e / M);
+		for (; this.bucketPointers.length < t;) {
+			let e = this.memory.allocUI32(M * A), t = new Uint32Array(e.data.buffer, e.bufferByteOffset, M * A);
+			for (let e = k; e < t.length; e += A) t[e] = this.nullIndex;
+			this.bucketPointers.push(e.pointer);
+		}
+	}
+	syncBucketCount() {
+		let e = Atomics.load(this.firstBlock.data, w);
+		e !== this.bucketCount && (this.bucketCount = e, this.bucketMask = $(e));
+	}
+	growBucketsIfNeeded() {
+		let e = Atomics.load(this.firstBlock.data, w);
+		if (!(e >= this.maxBucketCount || this.slotPool.length * Q <= e * Z)) {
+			h(this.tableLock);
+			try {
+				if (this.syncBucketCount(), this.slotPool.length * Q <= this.bucketCount * Z) return;
+				let e = Math.min(this.bucketCount * 2, this.maxBucketCount);
+				if (e === this.bucketCount) return;
+				this.resizeBuckets(e);
+			} finally {
+				g(this.tableLock);
+			}
+		}
+	}
+	ensureBucketCapacity(e) {
+		let t = Math.ceil(e * Q / Z), n = Math.min(_e(t), this.maxBucketCount);
+		if (!(n <= Atomics.load(this.firstBlock.data, w))) {
+			h(this.tableLock);
+			try {
+				this.syncBucketCount(), n > this.bucketCount && this.resizeBuckets(n);
+			} finally {
+				g(this.tableLock);
+			}
+		}
+	}
+	resizeBuckets(e) {
+		this.appendBucketSegments(e);
+		for (let e = 0; e < this.bucketPointers.length; e++) {
+			this.getBucketSegment(e << j);
+			let t = this.bucketHeadSegments[e];
+			for (let e = k; e < t.length; e += A) t[e] = this.nullIndex;
+		}
+		this.bucketCount = e, this.bucketMask = $(e);
+		for (let [e, t] of this.slotPool.entries()) {
+			let n = this.bucketOf(t[P], t[F]), r = this.bucketHeadSegments[n >>> j], i = this.bucketOffset(n) + k;
+			t[R] = r[i], r[i] = e;
+		}
+		Atomics.store(this.firstBlock.data, w, e);
+	}
+	growBucketsForBulk() {
+		for (;;) {
+			let e = Atomics.load(this.firstBlock.data, w);
+			if (this.growBucketsIfNeeded(), Atomics.load(this.firstBlock.data, w) === e) return;
+		}
+	}
+	linkRange(e, t, n, r, i, a) {
+		let o = this.slotScratch;
+		o[N] = e, o[I] = n, o[L] = r, o[R] = this.nullIndex, o[z] = t;
+		for (let e = r; e <= a; e++) for (let t = n; t <= i; t++) this.linkIntoBucket(t, e, o);
+	}
+	linkIntoBucket(e, t, n) {
+		n[P] = e, n[F] = t;
+		let r = this.slotPool, i = r.push(n), a = this.bucketOf(e, t), o = this.getBucketSegment(a), s = this.bucketHeadSegments[a >>> j], u = this.bucketOffset(a), d = u + O;
+		c(o, d);
+		let f = u + k;
+		r.set(i, R, s[f]), s[f] = i, l(o, d);
+	}
+	linkReservedBucket(e, t, n, r, i, a, o) {
+		let s = this.slotPool, u = s.blockFor(n), d = s.blockOffset(n);
+		u[d + N] = r, u[d + P] = e, u[d + F] = t, u[d + I] = a, u[d + L] = o, u[d + z] = i;
+		let f = this.bucketOf(e, t), p = this.getBucketSegment(f), m = this.bucketHeadSegments[f >>> j], h = this.bucketOffset(f), g = h + O;
+		c(p, g);
+		let _ = h + k;
+		u[d + R] = m[_], m[_] = n, l(p, g);
+	}
+	relinkRange(e, t, n, r, i, a, o, s, c, l) {
+		let u = n > o ? n : o, d = i < c ? i : c, f = r > s ? r : s, p = a < l ? a : l, m = u <= d && f <= p, h = this.slotScratch;
+		h[N] = e, h[I] = n, h[L] = r, h[R] = this.nullIndex, h[z] = t;
+		for (let t = r; t <= a; t++) {
+			let a = m && t >= f && t <= p;
+			for (let o = n; o <= i; o++) a && o >= u && o <= d ? this.refreshAnchorInBucket(this.bucketOf(o, t), e, o, t, n, r) : this.linkIntoBucket(o, t, h);
+		}
+		let g = this.nullIndex, _ = this.slotPool;
+		for (let t = s; t <= l; t++) {
+			let n = m && t >= f && t <= p;
+			for (let r = o; r <= c; r++) {
+				if (n && r >= u && r <= d) continue;
+				let i = this.unlinkFromBucket(this.bucketOf(r, t), e, r, t);
+				i !== g && _.deleteIndex(i);
+			}
+		}
+	}
+	refreshAnchorInBucket(e, t, n, r, i, a) {
+		let o = this.nullIndex, s = this.getBucketSegment(e), u = this.bucketOffset(e), d = u + O;
+		c(s, d);
+		let f = this.slotPool, p = this.bucketHeadSegments[e >>> j][u + k];
+		for (; p !== o;) {
+			let e = f.blockFor(p), o = f.blockOffset(p);
+			if (e[o + N] === t && e[o + P] === n && e[o + F] === r) {
+				e[o + I] = i, e[o + L] = a;
+				break;
+			}
+			p = e[o + R];
+		}
+		l(s, d);
+	}
+	unlinkRange(e, t, n, r, i) {
+		let a = this.nullIndex, o = this.slotPool;
+		for (let s = n; s <= i; s++) for (let n = t; n <= r; n++) {
+			let t = this.unlinkFromBucket(this.bucketOf(n, s), e, n, s);
+			t !== a && o.deleteIndex(t);
+		}
+	}
+	collectBucket(e, t, n, r, i, a, o, s) {
+		let u = this.nullIndex, d = r + k, f = r + O;
+		c(t, f);
+		let p = n[d], m = this.slotPool;
+		for (; p !== u;) {
+			let t = m.blockFor(p), n = m.blockOffset(p);
+			if (t[n + P] === i && t[n + F] === a) {
+				let r = t[n + I], c = t[n + L];
+				i === (r > o ? r : o) && a === (c > s ? c : s) && e.push(t[n + N]);
+			}
+			p = t[n + R];
+		}
+		l(t, f);
+	}
+	collectNeighborBucket(e, t, n) {
+		let r = this.bucketOf(t, n), i = this.getBucketSegment(r), a = this.bucketHeadSegments[r >>> j], o = this.bucketOffset(r), s = o + k;
+		if (a[s] === this.nullIndex) return;
+		let u = o + O;
+		c(i, u);
+		let d = a[s];
+		for (; d !== this.nullIndex;) {
+			let r = this.slotPool.blockFor(d), i = this.slotPool.blockOffset(d);
+			r[i + P] === t && r[i + F] === n && e.push(r[i + N]), d = r[i + R];
+		}
+		l(i, u);
+	}
+	collectNearestBucket(e, t, n, r, i) {
+		let a = this.bucketOf(t, n), o = this.getBucketSegment(a), s = this.bucketHeadSegments[a >>> j], u = this.bucketOffset(a), d = u + k;
+		if (s[d] === this.nullIndex) return;
+		let f = u + O;
+		c(o, f);
+		let p = s[d];
+		for (; p !== this.nullIndex;) {
+			let a = this.slotPool.blockFor(p), o = this.slotPool.blockOffset(p);
+			if (a[o + P] === t && a[o + F] === n) {
+				let t = a[o + z], n = this.entityPool.blockFor(t), s = this.entityPool.blockOffset(t), c = a[o + N], l = this.entityBlockDistanceSquared(n, s, r, i);
+				(l < e.distance || l === e.distance && (e.id === void 0 || c < e.id)) && (e.id = c, e.distance = l);
+			}
+			p = a[o + R];
+		}
+		l(o, f);
+	}
+	collectNeighborCandidates(e, t, n, r, i, a, o, s, u) {
+		let d = this.bucketOf(t, n), f = this.getBucketSegment(d), p = this.bucketHeadSegments[d >>> j], m = this.bucketOffset(d), h = m + k;
+		if (p[h] === this.nullIndex) return;
+		let g = m + O;
+		c(f, g);
+		let v = p[h];
+		for (; v !== this.nullIndex;) {
+			let c = this.slotPool.blockFor(v), l = this.slotPool.blockOffset(v);
+			if (c[l + P] === t && c[l + F] === n) {
+				let d = c[l + z], f = this.entityPool.blockFor(d), p = this.entityPool.blockOffset(d), m = f[p + V], h = f[p + U], g = f[p + H], v = f[p + W];
+				if (t === (r < m ? m : r > h ? h : r) && n === (i < g ? g : i > v ? v : i)) {
+					let t = this.entityBlockDistanceSquared(f, p, a, o);
+					t <= u && _(e, c[l + N], t, s);
+				}
+			}
+			v = c[l + R];
+		}
+		l(f, g);
+	}
+	addEntityCandidate(e, t, n, r, i, a, o) {
+		let s = this.entityDistanceSquared(n, r, i);
+		s <= o && _(e, t, s, a);
+	}
+	entityDistanceSquared(e, t, n) {
+		let r = this.entityPool.blockFor(e), i = this.entityPool.blockOffset(e);
+		return this.entityBlockDistanceSquared(r, i, t, n);
+	}
+	entityBlockDistanceSquared(e, t, n, r) {
+		let i = e[t + G], a = e[t + K];
+		return y(n, r, i, a, i + e[t + q], a + e[t + J]);
+	}
+	unlinkFromBucket(e, t, n, r) {
+		let i = this.nullIndex, a = this.getBucketSegment(e), o = this.bucketHeadSegments[e >>> j], s = this.bucketOffset(e), u = s + O;
+		c(a, u);
+		let d = s + k, f = this.slotPool, p = i, m = o[d];
+		for (; m !== i;) {
+			let e = f.blockFor(m), s = f.blockOffset(m), c = e[s + R];
+			if (e[s + N] === t && e[s + P] === n && e[s + F] === r) return p === i ? o[d] = c : f.set(p, R, c), l(a, u), m;
+			p = m, m = c;
+		}
+		return l(a, u), i;
+	}
+};
+function me(e) {
+	let t = a(e ?? fe);
+	if (t !== i.float32 && t !== i.float64) throw Error("SharedSpatialMap must be Float32Array or Float64Array");
+	return t;
+}
+function he(e) {
+	return o(e) === 2 ? Float64Array : Float32Array;
+}
+function ge(e) {
+	return e === i.float32 ? ie : ae;
+}
+function $(e) {
+	return e & e - 1 ? -1 : e - 1;
+}
+function _e(e) {
+	return 2 ** Math.ceil(Math.log2(Math.max(1, e)));
+}
+//#endregion
+export { pe as default };
+
+//# sourceMappingURL=shared-spatial-map.js.map