@daneren2005/shared-memory-objects 1.0.0 → 1.2.0

package/dist/shared-stack.js

@@ -0,0 +1,144 @@
+import { getPointer as e, storePointer as t } from "./utils/pointer.js";
+import n from "./allocated-memory.js";
+import { lock as r, unlock as i } from "./lock/simple-lock.js";
+//#region src/shared-stack.ts
+var a = 0, o = 1, s = 2, c = 3, l = 4, u = 5, d = 6, f = 4, p = 20, m = 22, h = (1 << m) - 1, g = 4194302, _ = 1 << m, v = class m {
+	static BASE_ALLOCATE_COUNT = 7;
+	static DEFAULT_ALLOCATE_COUNT = this.BASE_ALLOCATE_COUNT + p;
+	memory;
+	firstBlock;
+	uint16Array;
+	growLock;
+	maxLength;
+	ownsFirstBlock;
+	cachedSegments = [];
+	cachedSequences = [];
+	cachedBaseSegmentLength = 0;
+	get length() {
+		return Atomics.load(this.firstBlock.data, a) & h;
+	}
+	get segmentCount() {
+		return Atomics.load(this.firstBlock.data, l);
+	}
+	set segmentCount(e) {
+		this.firstBlock.data[l] = e;
+	}
+	get type() {
+		return this.uint16Array[0];
+	}
+	set type(e) {
+		Atomics.store(this.uint16Array, 0, e);
+	}
+	get baseSegmentLength() {
+		return this.firstBlock.data[s];
+	}
+	set baseSegmentLength(e) {
+		this.firstBlock.data[s] = e;
+	}
+	get maxSegments() {
+		return this.firstBlock.data[c];
+	}
+	set maxSegments(e) {
+		this.firstBlock.data[c] = e;
+	}
+	get pointer() {
+		return this.firstBlock.pointer;
+	}
+	constructor(e, t) {
+		if (this.memory = e, t && "firstBlock" in t) this.firstBlock = t.firstBlock instanceof n ? t.firstBlock : new n(e, t.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + o * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in t || "baseSegmentLength" in t || "segmentCount" in t ? (this.initialize(t), this.ownsFirstBlock = !1) : this.ownsFirstBlock = !0;
+		else {
+			let n = t?.segmentCount ?? p;
+			this.firstBlock = e.allocUI32(m.BASE_ALLOCATE_COUNT + n), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + o * Uint32Array.BYTES_PER_ELEMENT, 2), this.ownsFirstBlock = !0, this.initialize(t);
+		}
+		if (this.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + u * Uint32Array.BYTES_PER_ELEMENT, 1), this.cachedBaseSegmentLength = this.baseSegmentLength, this.maxLength = this.cachedBaseSegmentLength * (2 ** this.maxSegments - 1), this.maxLength > g) throw Error(`SharedStack maxLength ${this.maxLength} exceeds the ${g} the versioned length counter can address`);
+	}
+	initialize(e) {
+		let n = e?.baseSegmentLength ?? f, r = this.memory.allocUI32(n * 2);
+		t(this.firstBlock.data, d, r.bufferPosition, r.bufferByteOffset), this.baseSegmentLength = n, this.maxSegments = e?.segmentCount ?? p, this.segmentCount = 1;
+		let i = e?.type ?? Uint32Array;
+		i === Uint32Array ? this.type = 0 : i === Int32Array ? this.type = 1 : i === Float32Array && (this.type = 2);
+	}
+	at(e) {
+		let t = this.length;
+		if (e >= t || e < 0) throw Error(`${e} is out of bounds ${t}`);
+		let n = this.cachedBaseSegmentLength, r = 31 - Math.clz32((e / n | 0) + 1);
+		return (this.cachedSegments[r] ?? this.getSegment(r))[e - n * ((1 << r) - 1)];
+	}
+	push(e) {
+		let t = this.firstBlock.data, n = this.cachedBaseSegmentLength;
+		for (;;) {
+			let r = t[a], i = r & h;
+			if (i >= this.maxLength) throw Error(`${i + 1} is out of bounds ${this.maxLength}`);
+			let o = 31 - Math.clz32((i / n | 0) + 1), s = i - n * ((1 << o) - 1), c = this.cachedSegments[o] ?? this.getSegment(o), l = this.cachedSequences[o], u = Atomics.load(l, s);
+			if (!(u & 1) && Atomics.compareExchange(t, a, r, r + _ + 1) === r) return c[s] = e, Atomics.store(l, s, u + 1), i;
+		}
+	}
+	pop() {
+		let e = this.firstBlock.data, t = this.cachedBaseSegmentLength;
+		for (;;) {
+			let n = e[a], r = n & h;
+			if (r <= 0) return;
+			let i = r - 1, o = 31 - Math.clz32((i / t | 0) + 1), s = i - t * ((1 << o) - 1), c = this.cachedSegments[o] ?? this.getSegment(o), l = this.cachedSequences[o], u = Atomics.load(l, s);
+			if (!(u & 1) || Atomics.compareExchange(e, a, n, n + _ - 1) !== n) continue;
+			let d = c[s];
+			return Atomics.store(l, s, u + 1), d;
+		}
+	}
+	clear() {
+		let e = this.cachedBaseSegmentLength, t = Atomics.load(this.firstBlock.data, a) & h;
+		for (let n = 0; n < t; n++) {
+			let t = 31 - Math.clz32((n / e | 0) + 1), r = this.cachedSequences[t] ?? (this.getSegment(t), this.cachedSequences[t]), i = n - e * ((1 << t) - 1), a = Atomics.load(r, i);
+			a & 1 && Atomics.store(r, i, a + 1);
+		}
+		Atomics.store(this.firstBlock.data, a, 0);
+	}
+	*[Symbol.iterator]() {
+		let e = this.length, t = this.baseSegmentLength, n = 0, r = this.getSegment(n), i = 0;
+		for (let a = 0; a < e; a++) yield r[i], i++, i >= t && (n++, r = this.getSegment(n), i = 0, t *= 2);
+	}
+	getSegment(a) {
+		if (this.cachedSegments[a]) return this.cachedSegments[a];
+		let o = this.cachedBaseSegmentLength * 2 ** a, s;
+		if (a >= this.segmentCount) {
+			r(this.growLock);
+			try {
+				a >= this.segmentCount && (s = this.memory.allocUI32(o * 2), t(this.firstBlock.data, d + a, s.bufferPosition, s.bufferByteOffset), Atomics.add(this.firstBlock.data, l, 1));
+			} finally {
+				i(this.growLock);
+			}
+		}
+		if (!s) {
+			let t = Atomics.load(this.firstBlock.data, d + a), r = e(t);
+			s = new n(this.memory, r);
+		}
+		let c;
+		switch (this.type) {
+			case 1:
+				c = new Int32Array(s.data.buffer, s.bufferByteOffset, o);
+				break;
+			case 0:
+				c = new Uint32Array(s.data.buffer, s.bufferByteOffset, o);
+				break;
+			case 2:
+				c = new Float32Array(s.data.buffer, s.bufferByteOffset, o);
+				break;
+			default: throw Error(`Unknown data block type ${this.type}`);
+		}
+		let u = s.bufferByteOffset + o * Uint32Array.BYTES_PER_ELEMENT;
+		return this.cachedSequences[a] = new Int32Array(s.data.buffer, u, o), this.cachedSegments[a] = c, c;
+	}
+	free() {
+		for (let t = 0; t < this.segmentCount; t++) {
+			let r = Atomics.load(this.firstBlock.data, d + t), i = e(r);
+			new n(this.memory, i).free();
+		}
+		this.ownsFirstBlock && this.firstBlock.free();
+	}
+	getSharedMemory() {
+		return { firstBlock: this.firstBlock.getSharedMemory() };
+	}
+};
+//#endregion
+export { v as default };
+
+//# sourceMappingURL=shared-stack.js.map

package/dist/shared-stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-stack.js","names":[],"sources":["../src/shared-stack.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport type { TypedArrayConstructor } from './interfaces/typed-array-constructor';\nimport { lock, unlock } from './lock/simple-lock';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer, storePointer } from './utils/pointer';\n\nenum TYPE {\n\tuint32,\n\tint32,\n\tfloat32,\n}\n\nconst LENGTH_INDEX = 0;\nconst TYPE_INDEX = 1;\nconst BASE_SEGMENT_LENGTH_INDEX = 2;\nconst MAX_SEGMENTS_INDEX = 3;\nconst SEGMENT_COUNT_INDEX = 4;\nconst GROW_LOCK_INDEX = 5;\nconst SEGMENT_START_INDEX = 6;\n\nconst DEFAULT_BASE_SEGMENT_LENGTH = 4;\nconst DEFAULT_MAX_SEGMENTS = 20;\n\n// The LENGTH word packs an ABA version counter (high bits) with the live count (low LEN_BITS). Both push and pop bump\n// the version on every successful CAS, so the CAS fails on ANY intervening op - the count can never ABA back to the\n// same value with a slot at a different generation. 22 count bits cover the default max length (4,194,300); the\n// remaining 10 version bits (1024) only need to outlast a single thread's load->CAS window.\nconst LEN_BITS = 22;\nconst LEN_MASK = (1 << LEN_BITS) - 1;\nconst MAX_COUNT = LEN_MASK - 1;\n// Adding this to the packed word bumps the version (high bits) by one. Combined with +1/-1 for the count it repacks the\n// whole word in a single add: the count is guarded from overflowing into the version bits, and a version overflow just\n// wraps harmlessly when the value is coerced back to Uint32 on the atomic store.\nconst VERSION_STEP = 1 << LEN_BITS;\n\n// Per-slot publish handshake. Each data slot has a companion sequence number: even means the slot is empty (free to\n// fill) at some lap, odd means the value is published (safe to read). It only ever increases. push/pop read the slot's\n// sequence and bail out (retry) unless it has the parity they need, then CAS the length; because the versioned CAS\n// rejects any intervening op, the sequence read stays valid all the way through the publish store below.\n\nexport default class SharedStack<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<number> {\n\tstatic readonly BASE_ALLOCATE_COUNT = 7;\n\tstatic readonly DEFAULT_ALLOCATE_COUNT = this.BASE_ALLOCATE_COUNT + DEFAULT_MAX_SEGMENTS;\n\tprivate memory: MemoryHeap;\n\n\t// Length, Type, Base Segment Length, Max Segments, Segment Count, Grow Lock, Segments\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\tprivate growLock: Int32Array;\n\treadonly maxLength: number;\n\n\t// False when firstBlock is a slice of another structure's memory (e.g. inlined in SharedPool); that owner frees it\n\tprivate ownsFirstBlock: boolean;\n\n\tprivate cachedSegments: T[] = [];\n\t// Parallel to cachedSegments: the per-slot publish sequences for each slot of that segment. Populated together with\n\t// the data view in getSegment, so whenever cachedSegments[i] is set cachedSequences[i] is too.\n\tprivate cachedSequences: Int32Array[] = [];\n\tprivate cachedBaseSegmentLength = 0;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX) & LEN_MASK;\n\t}\n\tget segmentCount(): number {\n\t\treturn Atomics.load(this.firstBlock.data, SEGMENT_COUNT_INDEX);\n\t}\n\tprivate set segmentCount(value: number) {\n\t\tthis.firstBlock.data[SEGMENT_COUNT_INDEX] = value;\n\t}\n\t\n\tget type(): number {\n\t\treturn this.uint16Array[0];\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\n\tget baseSegmentLength() {\n\t\treturn this.firstBlock.data[BASE_SEGMENT_LENGTH_INDEX];\n\t}\n\tprivate set baseSegmentLength(value: number) {\n\t\tthis.firstBlock.data[BASE_SEGMENT_LENGTH_INDEX] = value;\n\t}\n\tget maxSegments() {\n\t\treturn this.firstBlock.data[MAX_SEGMENTS_INDEX];\n\t}\n\tprivate set maxSegments(value: number) {\n\t\tthis.firstBlock.data[MAX_SEGMENTS_INDEX] = value;\n\t}\n\n\tget pointer() {\n\t\treturn this.firstBlock.pointer;\n\t}\n\n\tconstructor(memory: MemoryHeap, config?: SharedStackConfig<T> | SharedStackMemory | SharedStackMemory & SharedStackConfig<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 SharedPool); 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 ? config.firstBlock : new AllocatedMemory(memory, 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 || 'baseSegmentLength' in config || 'segmentCount' 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.ownsFirstBlock = true;\n\t\t\t}\n\t\t} else {\n\t\t\tlet maxSegments = config?.segmentCount ?? DEFAULT_MAX_SEGMENTS;\n\n\t\t\tthis.firstBlock = memory.allocUI32(SharedStack.BASE_ALLOCATE_COUNT + maxSegments);\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.ownsFirstBlock = true;\n\n\t\t\tthis.initialize(config);\n\t\t}\n\n\t\tthis.growLock = new Int32Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + GROW_LOCK_INDEX * Uint32Array.BYTES_PER_ELEMENT, 1);\n\t\tthis.cachedBaseSegmentLength = this.baseSegmentLength;\n\t\tthis.maxLength = this.cachedBaseSegmentLength * (2 ** this.maxSegments - 1);\n\t\tif(this.maxLength > MAX_COUNT) {\n\t\t\t// The length word reserves LEN_BITS for the count and the rest for the ABA version tag\n\t\t\tthrow new Error(`SharedStack maxLength ${this.maxLength} exceeds the ${MAX_COUNT} the versioned length counter can address`);\n\t\t}\n\t}\n\n\tprivate initialize(config?: SharedStackConfig<T>) {\n\t\tlet baseSegmentLength = config?.baseSegmentLength ?? DEFAULT_BASE_SEGMENT_LENGTH;\n\t\t// Each segment block holds the data slots followed by an equal-length region of publish sequences\n\t\tlet firstSegmentBlock = this.memory.allocUI32(baseSegmentLength * 2);\n\t\tstorePointer(this.firstBlock.data, SEGMENT_START_INDEX, firstSegmentBlock.bufferPosition, firstSegmentBlock.bufferByteOffset);\n\t\tthis.baseSegmentLength = baseSegmentLength;\n\t\tthis.maxSegments = config?.segmentCount ?? DEFAULT_MAX_SEGMENTS;\n\t\tthis.segmentCount = 1;\n\n\t\tconst type = config?.type ?? Uint32Array;\n\t\tif(type === Uint32Array) {\n\t\t\tthis.type = TYPE.uint32;\n\t\t// @ts-expect-error\n\t\t} else if(type === Int32Array) {\n\t\t\tthis.type = TYPE.int32;\n\t\t// @ts-expect-error\n\t\t} else if(type === Float32Array) {\n\t\t\tthis.type = TYPE.float32;\n\t\t}\n\t}\n\n\tat(index: number): number {\n\t\tlet length = this.length;\n\t\tif(index >= length || index < 0) {\n\t\t\tthrow new Error(`${index} is out of bounds ${length}`);\n\t\t}\n\n\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\tlet segmentIndex = 31 - Math.clz32(((index / baseSegmentLength) | 0) + 1);\n\t\tlet segment = this.cachedSegments[segmentIndex] ?? this.getSegment(segmentIndex);\n\t\treturn segment[index - baseSegmentLength * ((1 << segmentIndex) - 1)];\n\t}\n\n\tpush(value: number): number {\n\t\tlet data = this.firstBlock.data;\n\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\t// eslint-disable-next-line no-constant-condition\n\t\twhile(true) {\n\t\t\t// Plain (relaxed) read is enough: it only seeds the versioned CAS below, which rejects any stale value\n\t\t\tlet packed = data[LENGTH_INDEX];\n\t\t\tlet newIndex = packed & LEN_MASK;\n\t\t\tif(newIndex >= this.maxLength) {\n\t\t\t\tthrow new Error(`${newIndex + 1} is out of bounds ${this.maxLength}`);\n\t\t\t}\n\n\t\t\tlet segmentIndex = 31 - Math.clz32(((newIndex / baseSegmentLength) | 0) + 1);\n\t\t\tlet localIndex = newIndex - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t\tlet segment = this.cachedSegments[segmentIndex] ?? this.getSegment(segmentIndex);\n\t\t\tlet sequences = this.cachedSequences[segmentIndex];\n\n\t\t\t// The slot must be empty (even sequence) to fill. Odd means a popper hasn't finished emptying it yet - retry\n\t\t\tlet sequence = Atomics.load(sequences, localIndex);\n\t\t\tif((sequence & 1) !== 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\t// Take the slot only if the whole versioned length word is unchanged. The version bump makes this fail on any\n\t\t\t// intervening op, so a win guarantees nothing touched the top - and our sequence read above is still valid\n\t\t\tif(Atomics.compareExchange(data, LENGTH_INDEX, packed, packed + VERSION_STEP + 1) !== packed) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tsegment[localIndex] = value;\n\t\t\t// Publish: bump to odd (full). Safe as a plain store - no other op can claim this slot until the length comes\n\t\t\t// back down to it, which can't happen (its popper is gated on an odd sequence) until this store lands\n\t\t\tAtomics.store(sequences, localIndex, sequence + 1);\n\t\t\treturn newIndex;\n\t\t}\n\t}\n\n\tpop(): number | undefined {\n\t\tlet data = this.firstBlock.data;\n\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\t// eslint-disable-next-line no-constant-condition\n\t\twhile(true) {\n\t\t\t// Plain (relaxed) read is enough: it only seeds the versioned CAS below, which rejects any stale value\n\t\t\tlet packed = data[LENGTH_INDEX];\n\t\t\tlet length = packed & LEN_MASK;\n\t\t\tif(length <= 0) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tlet oldIndex = length - 1;\n\n\t\t\tlet segmentIndex = 31 - Math.clz32(((oldIndex / baseSegmentLength) | 0) + 1);\n\t\t\tlet localIndex = oldIndex - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t\tlet segment = this.cachedSegments[segmentIndex] ?? this.getSegment(segmentIndex);\n\t\t\tlet sequences = this.cachedSequences[segmentIndex];\n\n\t\t\t// The slot must be full (odd sequence) to read. Even means a pusher hasn't finished publishing it yet - retry\n\t\t\tlet sequence = Atomics.load(sequences, localIndex);\n\t\t\tif((sequence & 1) === 0) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif(Atomics.compareExchange(data, LENGTH_INDEX, packed, packed + VERSION_STEP - 1) !== packed) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tlet value = segment[localIndex];\n\t\t\t// Release the slot: bump to even (empty) so a later push may reuse it\n\t\t\tAtomics.store(sequences, localIndex, sequence + 1);\n\t\t\treturn value;\n\t\t}\n\t}\n\n\tclear() {\n\t\t// Mark every occupied slot empty (bump its odd sequence to the next even) before dropping the length, otherwise a\n\t\t// later push reusing the slot would spin forever on a stale full sequence. Not safe to call concurrently with push/pop.\n\t\tlet baseSegmentLength = this.cachedBaseSegmentLength;\n\t\tlet oldLength = Atomics.load(this.firstBlock.data, LENGTH_INDEX) & LEN_MASK;\n\t\tfor(let i = 0; i < oldLength; i++) {\n\t\t\tlet segmentIndex = 31 - Math.clz32(((i / baseSegmentLength) | 0) + 1);\n\t\t\tlet sequences = this.cachedSequences[segmentIndex] ?? (this.getSegment(segmentIndex), this.cachedSequences[segmentIndex]);\n\t\t\tlet localIndex = i - baseSegmentLength * ((1 << segmentIndex) - 1);\n\t\t\tlet sequence = Atomics.load(sequences, localIndex);\n\t\t\tif((sequence & 1) !== 0) {\n\t\t\t\tAtomics.store(sequences, localIndex, sequence + 1);\n\t\t\t}\n\t\t}\n\t\tAtomics.store(this.firstBlock.data, LENGTH_INDEX, 0);\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tlet totalDataEntries = this.length;\n\n\t\tlet segmentLength = this.baseSegmentLength;\n\t\tlet segmentIndex = 0;\n\t\tlet segment = this.getSegment(segmentIndex);\n\t\tlet segmentDataIndex = 0;\n\t\tfor(let i = 0; i < totalDataEntries; i++) {\n\t\t\tyield segment[segmentDataIndex];\n\t\t\tsegmentDataIndex++;\n\t\t\tif(segmentDataIndex >= segmentLength) {\n\t\t\t\tsegmentIndex++;\n\t\t\t\tsegment = this.getSegment(segmentIndex);\n\t\t\t\tsegmentDataIndex = 0;\n\t\t\t\tsegmentLength = segmentLength * 2;\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getSegment(segmentIndex: number): T {\n\t\tif(this.cachedSegments[segmentIndex]) {\n\t\t\treturn this.cachedSegments[segmentIndex];\n\t\t}\n\n\t\tlet segmentLength = this.cachedBaseSegmentLength * 2 ** segmentIndex;\n\t\tlet segmentDataBlock: AllocatedMemory | undefined;\n\t\tif(segmentIndex >= this.segmentCount) {\n\t\t\t// Lock when growing so another thread doesn't also setup the same segment\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 segment while we were waiting\n\t\t\t\tif(segmentIndex >= this.segmentCount) {\n\t\t\t\t\t// Double length: the data slots followed by their publish sequences (calloc-zeroed = 0 = empty)\n\t\t\t\t\tsegmentDataBlock = this.memory.allocUI32(segmentLength * 2);\n\t\t\t\t\tstorePointer(this.firstBlock.data, SEGMENT_START_INDEX + segmentIndex, segmentDataBlock.bufferPosition, segmentDataBlock.bufferByteOffset);\n\t\t\t\t\tAtomics.add(this.firstBlock.data, SEGMENT_COUNT_INDEX, 1);\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\tif(!segmentDataBlock) {\n\t\t\tlet pointerNumber = Atomics.load(this.firstBlock.data, SEGMENT_START_INDEX + segmentIndex);\n\t\t\tlet pointer = getPointer(pointerNumber);\n\t\t\tsegmentDataBlock = new AllocatedMemory(this.memory, pointer);\n\t\t}\n\n\t\tlet data: T;\n\t\tswitch(this.type) {\n\t\t\tcase TYPE.int32:\n\t\t\t\tdata = new Int32Array(segmentDataBlock.data.buffer, segmentDataBlock.bufferByteOffset, segmentLength) as T;\n\t\t\t\tbreak;\n\t\t\tcase TYPE.uint32:\n\t\t\t\tdata = new Uint32Array(segmentDataBlock.data.buffer, segmentDataBlock.bufferByteOffset, segmentLength) as T;\n\t\t\t\tbreak;\n\t\t\tcase TYPE.float32:\n\t\t\t\tdata = new Float32Array(segmentDataBlock.data.buffer, segmentDataBlock.bufferByteOffset, segmentLength) as T;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`Unknown data block type ${this.type}`);\n\t\t}\n\t\t// Publish sequences live in the second half of the block, always as Int32 regardless of the data type\n\t\tlet sequenceByteOffset = segmentDataBlock.bufferByteOffset + segmentLength * Uint32Array.BYTES_PER_ELEMENT;\n\t\tthis.cachedSequences[segmentIndex] = new Int32Array(segmentDataBlock.data.buffer, sequenceByteOffset, segmentLength);\n\t\tthis.cachedSegments[segmentIndex] = data;\n\n\t\treturn data;\n\t}\n\n\tfree() {\n\t\tfor(let i = 0; i < this.segmentCount; i++) {\n\t\t\tlet pointerNumber = Atomics.load(this.firstBlock.data, SEGMENT_START_INDEX + i);\n\t\t\tlet pointer = getPointer(pointerNumber);\n\t\t\tlet rawData = new AllocatedMemory(this.memory, pointer);\n\t\t\trawData.free();\n\t\t}\n\t\tif(this.ownsFirstBlock) {\n\t\t\tthis.firstBlock.free();\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedStackMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedStackConfig<T extends Uint32Array | Int32Array | Float32Array> {\n\ttype?: TypedArrayConstructor<T>\n\n\tbaseSegmentLength?: number\n\tsegmentCount?: number\n}\ninterface SharedStackMemory {\n\tfirstBlock: SharedAllocatedMemory | AllocatedMemory\n}\n\nexport type { SharedStackConfig, SharedStackMemory };"],"mappings":"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"}

package/dist/{src/shared-string.d.ts → shared-string.d.ts}

@@ -1,5 +1,5 @@
-import { SharedAllocatedMemory } from './allocated-memory';
-import { default as MemoryHeap } from './memory-heap';
+import type { SharedAllocatedMemory } from './allocated-memory';
+import type MemoryHeap from './memory-heap';
 export default class SharedString {
     static readonly ALLOCATE_COUNT = 4;
     private memory;

package/dist/shared-string.js

@@ -0,0 +1,73 @@
+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
+var s = {
+	1: Uint8Array,
+	2: Uint16Array
+}, c = 0, l = 1, u = 2, d = 3, f = class f {
+	static ALLOCATE_COUNT = 4;
+	memory;
+	allocatedMemory;
+	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));
+	}
+	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;
+	}
+	createString(e) {
+		if (e === "") return {
+			pointer: 0,
+			charType: 1
+		};
+		let t = 0;
+		for (let n = 0; n < e.length; n++) {
+			let r = e.charCodeAt(n);
+			r > t && (t = r);
+		}
+		let n = t > 255 ? 2 : 1, r = s[n], i = this.memory.allocUI32(Math.ceil(e.length / (4 / r.BYTES_PER_ELEMENT))), a = new r(i.data.buffer, i.data.byteOffset, e.length);
+		for (let t = 0; t < e.length; t++) a[t] = e.charCodeAt(t);
+		return {
+			pointer: i.pointer,
+			charType: n
+		};
+	}
+	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);
+		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;
+	}
+	set value(e) {
+		let { bufferPosition: n, bufferByteOffset: r } = t(this.allocatedMemory.data, c);
+		this.updateString(e), r && this.memory.buffers[n].free(r);
+	}
+	getSharedMemory() {
+		return this.allocatedMemory.getSharedMemory();
+	}
+	get pointer() {
+		return this.allocatedMemory.pointer;
+	}
+	free() {
+		let { bufferPosition: e, bufferByteOffset: n } = t(this.allocatedMemory.data, c);
+		n && this.memory.buffers[e].free(n), this.allocatedMemory.free();
+	}
+};
+function p(e) {
+	let t = 8192;
+	if (e.length <= t) return String.fromCharCode.apply(null, e);
+	let n = "";
+	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-string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-string.js","names":[],"sources":["../src/shared-string.ts"],"sourcesContent":["import AllocatedMemory from './allocated-memory';\nimport type { SharedAllocatedMemory } from './allocated-memory';\nimport { lock, unlock } from './lock/simple-lock';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer, loadPointer, loadRawPointer, storeRawPointer } from './utils/pointer';\n\nenum CHAR_TYPE {\n\tUNDEFINED,\n\tASCII,\n\tUTF16,\n}\nconst TYPED_ARRAY_MAP = {\n\t[CHAR_TYPE.ASCII]: Uint8Array,\n\t[CHAR_TYPE.UTF16]: Uint16Array,\n};\n\nconst POINTER_INDEX = 0;\nconst LENGTH_INDEX = 1;\nconst TYPE_INDEX = 2;\nconst LOCK_INDEX = 3;\nexport default class SharedString {\n\tstatic readonly ALLOCATE_COUNT = 4;\n\n\tprivate memory: MemoryHeap;\n\tprivate allocatedMemory: AllocatedMemory;\n\tprivate lock: Int32Array;\n\n\tprivate cachedPointer?: number;\n\tprivate cachedString?: string;\n\t\n\tconstructor(memory: MemoryHeap, value: string | SharedStringConfig | SharedStringMemory) {\n\t\tthis.memory = memory;\n\n\t\tif(typeof value === 'string') {\n\t\t\tthis.allocatedMemory = this.memory.allocUI32(SharedString.ALLOCATE_COUNT);\n\t\t\tthis.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + LOCK_INDEX * this.allocatedMemory.data.BYTES_PER_ELEMENT);\n\t\t\tthis.updateString(value);\n\t\t} else {\n\t\t\tthis.allocatedMemory = new AllocatedMemory(memory, value);\n\t\t\tthis.lock = new Int32Array(this.allocatedMemory.data.buffer, this.allocatedMemory.bufferByteOffset + LOCK_INDEX * this.allocatedMemory.data.BYTES_PER_ELEMENT);\n\n\t\t\t// We only allocated memory but didn't initialize the string yet\n\t\t\tif('value' in value) {\n\t\t\t\tthis.updateString(value.value);\n\t\t\t}\n\t\t}\n\t}\n\t\n\tprivate updateString(value: string) {\n\t\tlet stringMemory = this.createString(value);\n\n\t\tlock(this.lock);\n\t\tstoreRawPointer(this.allocatedMemory.data, POINTER_INDEX, stringMemory.pointer);\n\t\tAtomics.store(this.allocatedMemory.data, LENGTH_INDEX, value.length);\n\t\tAtomics.store(this.allocatedMemory.data, TYPE_INDEX, stringMemory.charType);\n\t\tunlock(this.lock);\n\n\t\tthis.cachedPointer = stringMemory.pointer;\n\t\tthis.cachedString = value;\n\t}\n\tprivate createString(value: string) {\n\t\tif(value === '') {\n\t\t\treturn {\n\t\t\t\tpointer: 0,\n\t\t\t\tcharType: CHAR_TYPE.ASCII,\n\t\t\t};\n\t\t}\n\n\t\t// NOTE: Scan with a loop instead of Math.max(...charCodes) which blows the stack for large strings\n\t\tlet maxCharCode = 0;\n\t\tfor(let i = 0; i < value.length; i++) {\n\t\t\tlet charCode = value.charCodeAt(i);\n\t\t\tif(charCode > maxCharCode) {\n\t\t\t\tmaxCharCode = charCode;\n\t\t\t}\n\t\t}\n\t\tlet charType = maxCharCode > 255 ? CHAR_TYPE.UTF16 : CHAR_TYPE.ASCII;\n\n\t\tlet typedArray = TYPED_ARRAY_MAP[charType];\n\t\tlet allocatedMemory = this.memory.allocUI32(Math.ceil(value.length / (4 / typedArray.BYTES_PER_ELEMENT)));\n\t\tlet data = new typedArray(allocatedMemory.data.buffer as ArrayBuffer, allocatedMemory.data.byteOffset, value.length);\n\t\tfor(let i = 0; i < value.length; i++) {\n\t\t\tdata[i] = value.charCodeAt(i);\n\t\t}\n\n\t\treturn {\n\t\t\tpointer: allocatedMemory.pointer,\n\t\t\tcharType,\n\t\t};\n\t}\n\n\tget value(): string {\n\t\tlet pointer = loadRawPointer(this.allocatedMemory.data, POINTER_INDEX);\n\t\tif(this.cachedPointer === pointer && this.cachedString !== undefined) {\n\t\t\treturn this.cachedString;\n\t\t} else if(pointer === 0) {\n\t\t\treturn '';\n\t\t}\n\t\tlet { bufferPosition, bufferByteOffset } = getPointer(pointer);\n\n\t\tlock(this.lock);\n\t\tlet charType = Atomics.load(this.allocatedMemory.data, TYPE_INDEX);\n\t\t// @ts-expect-error\n\t\tlet typedArray = TYPED_ARRAY_MAP[charType];\n\t\tlet bufferLength = Atomics.load(this.allocatedMemory.data, LENGTH_INDEX);\n\n\t\tlet data = new typedArray(this.memory.buffers[bufferPosition].buf, bufferByteOffset, bufferLength);\n\t\tlet string = fromCharCodes(data);\n\t\t// NOTE: Do not unlock until after transforming the data since the second this is done it can free that memory block\n\t\tunlock(this.lock);\n\n\t\tthis.cachedPointer = pointer;\n\t\tthis.cachedString = string;\n\n\t\treturn string;\n\t}\n\tset value(value: string) {\n\t\tlet { bufferPosition: oldBufferPosition, bufferByteOffset: oldBufferByteOffset } = loadPointer(this.allocatedMemory.data, POINTER_INDEX);\n\t\tthis.updateString(value);\n\n\t\tif(oldBufferByteOffset) {\n\t\t\tthis.memory.buffers[oldBufferPosition].free(oldBufferByteOffset);\n\t\t}\n\t}\n\n\tgetSharedMemory(): SharedStringMemory {\n\t\treturn this.allocatedMemory.getSharedMemory();\n\t}\n\n\tget pointer() {\n\t\treturn this.allocatedMemory.pointer;\n\t}\n\n\tfree() {\n\t\tlet { bufferPosition, bufferByteOffset } = loadPointer(this.allocatedMemory.data, POINTER_INDEX);\n\t\tif(bufferByteOffset) {\n\t\t\tthis.memory.buffers[bufferPosition].free(bufferByteOffset);\n\t\t}\n\t\tthis.allocatedMemory.free();\n\t}\n}\n\n// String.fromCharCode.apply throws a RangeError (Maximum call stack size exceeded) when handed too many\n// arguments at once, so decode large buffers in chunks to support arbitrarily long strings\nfunction fromCharCodes(data: Uint8Array | Uint16Array): string {\n\tconst CHUNK_SIZE = 8192;\n\tif(data.length <= CHUNK_SIZE) {\n\t\treturn String.fromCharCode.apply(null, data as unknown as Array<number>);\n\t}\n\n\tlet string = '';\n\tfor(let i = 0; i < data.length; i += CHUNK_SIZE) {\n\t\tstring += String.fromCharCode.apply(null, data.subarray(i, i + CHUNK_SIZE) as unknown as Array<number>);\n\t}\n\n\treturn string;\n}\n\ninterface SharedStringConfig extends SharedStringMemory {\n\tvalue: string\n}\ntype SharedStringMemory = SharedAllocatedMemory;"],"mappings":"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"}

package/dist/{src/shared-vector.d.ts → shared-vector.d.ts}

@@ -1,6 +1,6 @@
-import { SharedAllocatedMemory } from './allocated-memory';
-import { TypedArrayConstructor } from './interfaces/typed-array-constructor';
-import { default as MemoryHeap } from './memory-heap';
+import type { SharedAllocatedMemory } from './allocated-memory';
+import type { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import type MemoryHeap from './memory-heap';
 export default class SharedVector<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<T> {
     static readonly ALLOCATE_COUNT = 4;
     private memory;
@@ -16,7 +16,7 @@ export default class SharedVector<T extends Uint32Array | Int32Array | Float32Ar
     get pointer(): number;
     private cachedFullDataBlock?;
     private cachedPointer;
-    constructor(memory: MemoryHeap, config?: SharedVectorConfig<T> | SharedVectorMemory | SharedVectorMemory & SharedVectorConfig<T>);
+    constructor(memory: MemoryHeap, config?: SharedVectorConfig<T> | SharedVectorMemory | (SharedVectorMemory & SharedVectorConfig<T>));
     at(index: number): T;
     get(index: number, dataIndex?: number): number;
     push(values: number | Array<number>): number;

package/dist/shared-vector.js

@@ -0,0 +1,147 @@
+import { getPointer as e, loadPointer as t, storePointer as n, storeRawPointer as r } from "./utils/pointer.js";
+import i from "./allocated-memory.js";
+//#region src/shared-vector.ts
+var a = 0, o = 1, s = 2, c = 3, l = 4, u = class u {
+	static ALLOCATE_COUNT = 4;
+	memory;
+	firstBlock;
+	uint16Array;
+	get length() {
+		return Atomics.load(this.firstBlock.data, o);
+	}
+	get type() {
+		return this.uint16Array[0];
+	}
+	set type(e) {
+		Atomics.store(this.uint16Array, 0, e);
+	}
+	get dataLength() {
+		return this.uint16Array[1] || 1;
+	}
+	set dataLength(e) {
+		Atomics.store(this.uint16Array, 1, e);
+	}
+	get bufferLength() {
+		return Atomics.load(this.firstBlock.data, s);
+	}
+	set bufferLength(e) {
+		Atomics.store(this.firstBlock.data, s, e);
+	}
+	get pointer() {
+		return this.firstBlock.pointer;
+	}
+	cachedFullDataBlock;
+	cachedPointer;
+	constructor(e, t) {
+		if (this.memory = e, t && "firstBlock" in t) {
+			if (this.firstBlock = new i(e, t.firstBlock), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + c * Uint32Array.BYTES_PER_ELEMENT, 2), "type" in t || "dataLength" in t) {
+				let r = t.bufferLength ?? l, i = e.allocUI32(r * (t.dataLength ?? 1));
+				n(this.firstBlock.data, a, i.bufferPosition, i.bufferByteOffset), this.bufferLength = r, this.dataLength = t.dataLength ?? 1;
+			}
+			if ("type" in t) {
+				let e = t?.type ?? Uint32Array;
+				e === Uint32Array ? this.type = 0 : e === Int32Array ? this.type = 1 : e === Float32Array && (this.type = 2);
+			}
+		} else {
+			this.firstBlock = e.allocUI32(u.ALLOCATE_COUNT), this.uint16Array = new Uint16Array(this.firstBlock.data.buffer, this.firstBlock.bufferByteOffset + c * Uint32Array.BYTES_PER_ELEMENT, 2);
+			let r = t?.dataLength ?? 1, i = t?.bufferLength ?? l, o = e.allocUI32(i * r);
+			n(this.firstBlock.data, a, o.bufferPosition, o.bufferByteOffset), this.bufferLength = i;
+			let s = t?.type ?? Uint32Array;
+			s === Uint32Array ? this.type = 0 : s === Int32Array ? this.type = 1 : s === Float32Array && (this.type = 2), this.dataLength = r;
+		}
+		this.cachedPointer = this.firstBlock.data[0], this.cachedFullDataBlock = this.getFullDataBlock();
+	}
+	at(e) {
+		let t = this.length;
+		if (e >= t || e < 0) throw Error(`${e} is out of bounds ${t}`);
+		let n = this.getFullDataBlock();
+		return this.getDataBlock(n, e);
+	}
+	get(e, t = 0) {
+		if (t >= this.dataLength) throw Error(`${t} is out of dataLength bounds ${this.dataLength}`);
+		if (e >= this.length || e < 0) throw Error(`${e} is out of bounds ${this.length}`);
+		return this.getFullDataBlock()[e * this.dataLength + t];
+	}
+	push(e) {
+		let t = this.dataLength, n = typeof e == "number";
+		if (!n && e.length > t) throw Error(`Can't insert ${e.length} array into shared list of ${t} dataLength`);
+		let r = this.getFullDataBlock(), i = this.length, a = t * i;
+		return n ? r[a] = e : r.set(e, a), Atomics.add(this.firstBlock.data, o, 1) + 1 >= this.bufferLength && this.growBuffer(), i;
+	}
+	pop() {
+		let e = Atomics.sub(this.firstBlock.data, o, 1), t = this.getFullDataBlock();
+		return this.getDataBlock(t, e - 1);
+	}
+	popNumber() {
+		let e = Atomics.sub(this.firstBlock.data, o, 1);
+		return this.getFullDataBlock()[(e - 1) * this.dataLength];
+	}
+	deleteIndex(e) {
+		let t = this.length;
+		if (e >= t || e < 0) throw Error(`${e} is out of bounds ${t}`);
+		let n = this.dataLength, r = this.getFullDataBlock();
+		for (let i = e; i < t; i++) for (let e = 0; e < n; e++) r[i * n + e] = r[(i + 1) * n + e];
+		Atomics.sub(this.firstBlock.data, o, 1);
+	}
+	clear() {
+		this.firstBlock.data[o] = 0;
+	}
+	*[Symbol.iterator]() {
+		let e = this.getFullDataBlock(), t = this.dataLength, n = this.length * t;
+		for (let r = 0; r < n; r += t) yield e.subarray(r, r + t);
+	}
+	getCurrentArray() {
+		return this.getFullDataBlock().subarray(0, this.length * this.dataLength);
+	}
+	getFullDataBlock() {
+		let t = Atomics.load(this.firstBlock.data, a);
+		if (this.cachedPointer === t && this.cachedFullDataBlock) return this.cachedFullDataBlock;
+		let n = e(t), r = new i(this.memory, n), o;
+		switch (this.type) {
+			case 1:
+				o = new Int32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
+				break;
+			case 0:
+				o = new Uint32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
+				break;
+			case 2:
+				o = new Float32Array(r.data.buffer, r.bufferByteOffset, this.dataLength * this.bufferLength);
+				break;
+			default: throw Error(`Unknown data block type ${this.type}`);
+		}
+		return this.cachedPointer = t, this.cachedFullDataBlock = o, o;
+	}
+	getDataBlock(e, t) {
+		let n = t * this.dataLength;
+		return e.subarray(n, n + this.dataLength);
+	}
+	growBuffer() {
+		let e = this.bufferLength * 2, n = this.dataLength, o = t(this.firstBlock.data, a), s = new i(this.memory, o), c = this.getFullDataBlock(), l = this.memory.allocUI32(e * n), u;
+		switch (this.type) {
+			case 1:
+				u = new Int32Array(l.data.buffer, l.bufferByteOffset, n * e);
+				break;
+			case 0:
+				u = new Uint32Array(l.data.buffer, l.bufferByteOffset, n * e);
+				break;
+			case 2:
+				u = new Float32Array(l.data.buffer, l.bufferByteOffset, n * e);
+				break;
+			default: throw Error(`Unknown data block type ${this.type}`);
+		}
+		u.set(c);
+		let d = l.pointer;
+		r(this.firstBlock.data, a, d), this.bufferLength = e, s.free(), this.cachedPointer = d, this.cachedFullDataBlock = u;
+	}
+	free() {
+		let e = t(this.firstBlock.data, a);
+		new i(this.memory, e).free(), this.firstBlock.free();
+	}
+	getSharedMemory() {
+		return { firstBlock: this.firstBlock.getSharedMemory() };
+	}
+};
+//#endregion
+export { u as default };
+
+//# sourceMappingURL=shared-vector.js.map

package/dist/shared-vector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-vector.js","names":[],"sources":["../src/shared-vector.ts"],"sourcesContent":["import type { SharedAllocatedMemory } from './allocated-memory';\nimport AllocatedMemory from './allocated-memory';\nimport type { TypedArrayConstructor } from './interfaces/typed-array-constructor';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer, loadPointer, storePointer, storeRawPointer } from './utils/pointer';\n\nenum TYPE {\n\tuint32,\n\tint32,\n\tfloat32,\n}\n\nconst VECTOR_INDEX = 0;\nconst LENGTH_INDEX = 1;\nconst BUFFER_LENGTH_INDEX = 2;\nconst TYPE_INDEX = 3;\nconst DEFAULT_SIZE = 4;\nexport default class SharedVector<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<T> {\n\tstatic readonly ALLOCATE_COUNT = 4;\n\tprivate memory: MemoryHeap;\n\n\t// Pointer, List Length, Buffer Length, Type/DataLength\n\tprivate firstBlock: AllocatedMemory;\n\tprivate uint16Array: Uint16Array;\n\n\tget length(): number {\n\t\treturn Atomics.load(this.firstBlock.data, LENGTH_INDEX);\n\t}\n\t\n\tget type(): number {\n\t\treturn this.uint16Array[0];\n\t}\n\tprivate set type(value: number) {\n\t\tAtomics.store(this.uint16Array, 0, value);\n\t}\n\tget dataLength(): number {\n\t\t// Can technically be initialized by passing memory without actually every being called - need to make sure dataLength is always at least one\n\t\treturn this.uint16Array[1] || 1;\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 Atomics.load(this.firstBlock.data, BUFFER_LENGTH_INDEX);\n\t}\n\tprivate set bufferLength(value: number) {\n\t\tAtomics.store(this.firstBlock.data, BUFFER_LENGTH_INDEX, value);\n\t}\n\n\tget pointer() {\n\t\treturn this.firstBlock.pointer;\n\t}\n\n\tprivate cachedFullDataBlock?: T;\n\tprivate cachedPointer: number;\n\n\tconstructor(memory: MemoryHeap, config?: SharedVectorConfig<T> | SharedVectorMemory | SharedVectorMemory & SharedVectorConfig<T>) {\n\t\tthis.memory = memory;\n\n\t\tif(config && 'firstBlock' in config) {\n\t\t\tthis.firstBlock = new AllocatedMemory(memory, 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// Pre-allocating memory and setting up in specific memory location\n\t\t\tif('type' in config || 'dataLength' in config) {\n\t\t\t\tconst bufferLength = config.bufferLength ?? DEFAULT_SIZE;\n\t\t\t\tlet dataBlock = memory.allocUI32(bufferLength * (config.dataLength ?? 1));\n\t\t\t\tstorePointer(this.firstBlock.data, VECTOR_INDEX, dataBlock.bufferPosition, dataBlock.bufferByteOffset);\n\t\t\t\tthis.bufferLength = bufferLength;\n\t\t\t\tthis.dataLength = (config.dataLength ?? 1);\n\t\t\t}\n\t\t\tif('type' in config) {\n\t\t\t\tconst type = config?.type ?? Uint32Array;\n\t\t\t\tif(type === Uint32Array) {\n\t\t\t\t\tthis.type = TYPE.uint32;\n\t\t\t\t// @ts-expect-error\n\t\t\t\t} else if(type === Int32Array) {\n\t\t\t\t\tthis.type = TYPE.int32;\n\t\t\t\t// @ts-expect-error\n\t\t\t\t} else if(type === Float32Array) {\n\t\t\t\t\tthis.type = TYPE.float32;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthis.firstBlock = memory.allocUI32(SharedVector.ALLOCATE_COUNT);\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\tlet dataLength = config?.dataLength ?? 1;\n\t\t\tlet bufferLength = config?.bufferLength ?? DEFAULT_SIZE;\n\t\t\tlet dataBlock = memory.allocUI32(bufferLength * dataLength);\n\t\t\tstorePointer(this.firstBlock.data, VECTOR_INDEX, dataBlock.bufferPosition, dataBlock.bufferByteOffset);\n\t\t\tthis.bufferLength = bufferLength;\n\n\t\t\tconst type = config?.type ?? Uint32Array;\n\t\t\tif(type === Uint32Array) {\n\t\t\t\tthis.type = TYPE.uint32;\n\t\t\t// @ts-expect-error\n\t\t\t} else if(type === Int32Array) {\n\t\t\t\tthis.type = TYPE.int32;\n\t\t\t// @ts-expect-error\n\t\t\t} else if(type === Float32Array) {\n\t\t\t\tthis.type = TYPE.float32;\n\t\t\t}\n\t\t\tthis.dataLength = dataLength;\n\t\t}\n\n\t\tthis.cachedPointer = this.firstBlock.data[0];\n\t\tthis.cachedFullDataBlock = this.getFullDataBlock();\n\t}\n\n\tat(index: number): T {\n\t\tlet length = this.length;\n\t\tif(index >= length || index < 0) {\n\t\t\tthrow new Error(`${index} is out of bounds ${length}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock();\n\t\treturn this.getDataBlock(dataBlock, index);\n\t}\n\tget(index: number, dataIndex = 0): number {\n\t\tif(dataIndex >= this.dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${this.dataLength}`);\n\t\t} else if(index >= this.length || index < 0) {\n\t\t\tthrow new Error(`${index} is out of bounds ${this.length}`);\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock();\n\t\treturn dataBlock[index * this.dataLength + dataIndex];\n\t}\n\n\tpush(values: number | Array<number>): number {\n\t\tlet dataLength = this.dataLength;\n\t\tconst isSingleNumber = typeof values === 'number';\n\t\tif(!isSingleNumber && 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\tlet dataBlock = this.getFullDataBlock();\n\t\tlet currentLength = this.length;\n\t\tlet startIndex = dataLength * currentLength;\n\t\tif(isSingleNumber) {\n\t\t\tdataBlock[startIndex] = values;\n\t\t} else {\n\t\t\tdataBlock.set(values, startIndex);\n\t\t}\n\n\t\tlet newLength = Atomics.add(this.firstBlock.data, LENGTH_INDEX, 1) + 1;\n\t\tif(newLength >= this.bufferLength) {\n\t\t\tthis.growBuffer();\n\t\t}\n\n\t\treturn currentLength;\n\t}\n\n\tpop(): T {\n\t\tlet oldLength = Atomics.sub(this.firstBlock.data, LENGTH_INDEX, 1);\n\n\t\tlet dataBlock = this.getFullDataBlock();\n\t\treturn this.getDataBlock(dataBlock, oldLength - 1);\n\t}\n\n\t// Returns the first number irregardless of dataLength - faster way to pop if you don't care about the rest of the data block\n\tpopNumber(): number {\n\t\tconst oldLength = Atomics.sub(this.firstBlock.data, LENGTH_INDEX, 1);\n\t\tconst dataBlock = this.getFullDataBlock();\n\t\treturn dataBlock[(oldLength - 1) * this.dataLength];\n\t}\n\n\tdeleteIndex(index: number) {\n\t\tlet length = this.length;\n\t\tif(index >= length || index < 0) {\n\t\t\tthrow new Error(`${index} is out of bounds ${length}`);\n\t\t}\n\n\t\tlet dataLength = this.dataLength;\n\t\tlet dataBlock = this.getFullDataBlock();\n\t\tfor(let i = index; i < length; i++) {\n\t\t\tfor(let j = 0; j < dataLength; j++) {\n\t\t\t\tdataBlock[i * dataLength + j] = dataBlock[(i + 1) * dataLength + j];\n\t\t\t}\n\t\t}\n\n\t\tAtomics.sub(this.firstBlock.data, LENGTH_INDEX, 1);\n\t}\n\n\tclear() {\n\t\tthis.firstBlock.data[LENGTH_INDEX] = 0;\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tlet dataBlock = this.getFullDataBlock();\n\t\tlet dataLength = this.dataLength;\n\t\tlet totalDataEntries = this.length * dataLength;\n\n\t\tfor(let i = 0; i < totalDataEntries; i += dataLength) {\n\t\t\tyield dataBlock.subarray(i, i + dataLength) as T;\n\t\t}\n\t}\n\n\t// Significantly faster but won't be thread safe if anything is removing/adding to it during iteration\n\tgetCurrentArray(): T {\n\t\tlet dataBlock = this.getFullDataBlock();\n\t\treturn dataBlock.subarray(0, this.length * this.dataLength) as T;\n\t}\n\n\tprivate getFullDataBlock(): T {\n\t\tlet pointerNumber = Atomics.load(this.firstBlock.data, VECTOR_INDEX);\n\t\tif(this.cachedPointer === pointerNumber && this.cachedFullDataBlock) {\n\t\t\treturn this.cachedFullDataBlock;\n\t\t}\n\n\t\tlet pointer = getPointer(pointerNumber);\n\t\tlet rawData = new AllocatedMemory(this.memory, pointer);\n\n\t\tlet data: T;\n\t\tswitch(this.type) {\n\t\t\tcase TYPE.int32:\n\t\t\t\tdata = new Int32Array(rawData.data.buffer, rawData.bufferByteOffset, this.dataLength * this.bufferLength) as T;\n\t\t\t\tbreak;\n\t\t\tcase TYPE.uint32:\n\t\t\t\tdata = new Uint32Array(rawData.data.buffer, rawData.bufferByteOffset, this.dataLength * this.bufferLength) as T;\n\t\t\t\tbreak;\n\t\t\tcase TYPE.float32:\n\t\t\t\tdata = new Float32Array(rawData.data.buffer, rawData.bufferByteOffset, this.dataLength * this.bufferLength) as T;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`Unknown data block type ${this.type}`);\n\t\t}\n\n\t\tthis.cachedPointer = pointerNumber;\n\t\tthis.cachedFullDataBlock = data;\n\n\t\treturn data;\n\t}\n\tprivate getDataBlock(rawData: T, index: number): T {\n\t\tconst start = index * this.dataLength;\n\t\treturn rawData.subarray(start, start + this.dataLength) as T;\n\t}\n\n\tprivate growBuffer() {\n\t\tlet oldBufferLength = this.bufferLength;\n\t\tlet newBufferLength = oldBufferLength * 2;\n\t\tlet dataLength = this.dataLength;\n\n\t\tlet oldPointer = loadPointer(this.firstBlock.data, VECTOR_INDEX);\n\t\tlet oldDataMemory = new AllocatedMemory(this.memory, oldPointer);\n\t\tlet oldDataBlock = this.getFullDataBlock();\n\t\tlet newDataBlock = this.memory.allocUI32(newBufferLength * dataLength);\n\n\t\tlet newData: T;\n\t\tswitch(this.type) {\n\t\t\tcase TYPE.int32:\n\t\t\t\tnewData = new Int32Array(newDataBlock.data.buffer, newDataBlock.bufferByteOffset, dataLength * newBufferLength) as T;\n\t\t\t\tbreak;\n\t\t\tcase TYPE.uint32:\n\t\t\t\tnewData = new Uint32Array(newDataBlock.data.buffer, newDataBlock.bufferByteOffset, dataLength * newBufferLength) as T;\n\t\t\t\tbreak;\n\t\t\tcase TYPE.float32:\n\t\t\t\tnewData = new Float32Array(newDataBlock.data.buffer, newDataBlock.bufferByteOffset, dataLength * newBufferLength) as T;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow new Error(`Unknown data block type ${this.type}`);\n\t\t}\n\n\t\t// Copy old buffer into new buffer\n\t\tnewData.set(oldDataBlock);\n\n\t\tconst newPointer = newDataBlock.pointer;\n\t\tstoreRawPointer(this.firstBlock.data, VECTOR_INDEX, newPointer);\n\t\tthis.bufferLength = newBufferLength;\n\t\toldDataMemory.free();\n\n\t\tthis.cachedPointer = newPointer;\n\t\tthis.cachedFullDataBlock = newData;\n\t}\n\n\tfree() {\n\t\tlet pointer = loadPointer(this.firstBlock.data, VECTOR_INDEX);\n\t\tlet dataMemory = new AllocatedMemory(this.memory, pointer);\n\n\t\tdataMemory.free();\n\t\tthis.firstBlock.free();\n\t}\n\n\tgetSharedMemory(): SharedVectorMemory {\n\t\treturn {\n\t\t\tfirstBlock: this.firstBlock.getSharedMemory(),\n\t\t};\n\t}\n}\n\ninterface SharedVectorConfig<T extends Uint32Array | Int32Array | Float32Array> {\n\ttype?: TypedArrayConstructor<T>\n\tdataLength?: number\n\n\tbufferLength?: number\n}\ninterface SharedVectorMemory {\n\tfirstBlock: SharedAllocatedMemory\n}\n\nexport type { SharedVectorConfig, SharedVectorMemory };"],"mappings":"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"}

package/dist/utils/16-from-32-array.js

@@ -0,0 +1,18 @@
+//#region src/utils/16-from-32-array.ts
+var e = /* @__PURE__ */ new ArrayBuffer(4), t = new Uint32Array(e), n = new Uint16Array(e);
+function r(e, t) {
+	return a(Atomics.load(e, t));
+}
+function i(e, t, n, r) {
+	Atomics.store(e, t, o(n, r));
+}
+function a(e) {
+	return t[0] = e, [n[0], n[1]];
+}
+function o(e, r) {
+	return n[0] = e, n[1] = r, t[0];
+}
+//#endregion
+export { o as convert16To32, a as convert32To16, r as load16From32, i as store16In32 };
+
+//# sourceMappingURL=16-from-32-array.js.map

package/dist/utils/16-from-32-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"16-from-32-array.js","names":[],"sources":["../../src/utils/16-from-32-array.ts"],"sourcesContent":["const buffer = new ArrayBuffer(4);\nconst uint32Array = new Uint32Array(buffer);\nconst uint16Array = new Uint16Array(buffer);\n\nexport function load16From32(data: Uint32Array, index: number): [number, number] {\n\treturn convert32To16(Atomics.load(data, index));\n}\n\nexport function store16In32(data: Uint32Array, index: number, value1: number, value2: number) {\n\tAtomics.store(data, index, convert16To32(value1, value2));\n}\n\nexport function convert32To16(value: number): [number, number] {\n\tuint32Array[0] = value;\n\n\treturn [uint16Array[0], uint16Array[1]];\n}\nexport function convert16To32(value1: number, value2: number): number {\n\tuint16Array[0] = value1;\n\tuint16Array[1] = value2;\n\n\treturn uint32Array[0];\n}"],"mappings":";AAAA,IAAM,oBAAS,IAAI,YAAY,CAAC,GAC1B,IAAc,IAAI,YAAY,CAAM,GACpC,IAAc,IAAI,YAAY,CAAM;AAE1C,SAAgB,EAAa,GAAmB,GAAiC;CAChF,OAAO,EAAc,QAAQ,KAAK,GAAM,CAAK,CAAC;AAC/C;AAEA,SAAgB,EAAY,GAAmB,GAAe,GAAgB,GAAgB;CAC7F,QAAQ,MAAM,GAAM,GAAO,EAAc,GAAQ,CAAM,CAAC;AACzD;AAEA,SAAgB,EAAc,GAAiC;CAG9D,OAFA,EAAY,KAAK,GAEV,CAAC,EAAY,IAAI,EAAY,EAAE;AACvC;AACA,SAAgB,EAAc,GAAgB,GAAwB;CAIrE,OAHA,EAAY,KAAK,GACjB,EAAY,KAAK,GAEV,EAAY;AACpB"}

package/dist/utils/16-from-64-array.js

@@ -0,0 +1,17 @@
+//#region src/utils/16-from-64-array.ts
+var e = /* @__PURE__ */ new ArrayBuffer(8), t = new BigUint64Array(e), n = new Uint16Array(e);
+function r(e, r) {
+	return t[0] = Atomics.load(e, r), [
+		n[0],
+		n[1],
+		n[2],
+		n[3]
+	];
+}
+function i(e, r, i, a, o, s = 0) {
+	n[0] = i, n[1] = a, n[2] = o, n[3] = s, Atomics.store(e, r, t[0]);
+}
+//#endregion
+export { r as load16From64, i as store16In64 };
+
+//# sourceMappingURL=16-from-64-array.js.map

package/dist/utils/16-from-64-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"16-from-64-array.js","names":[],"sources":["../../src/utils/16-from-64-array.ts"],"sourcesContent":["const buffer = new ArrayBuffer(8);\nconst uint64Array = new BigUint64Array(buffer);\nconst uint16Array = new Uint16Array(buffer);\n\nexport function load16From64(data: BigUint64Array, index: number): [number, number, number, number] {\n\tuint64Array[0] = Atomics.load(data, index);\n\t\n\treturn [uint16Array[0], uint16Array[1], uint16Array[2], uint16Array[3]];\n}\n\nexport function store16In64(data: BigUint64Array, index: number, value1: number, value2: number, value3: number, value4: number = 0) {\n\tuint16Array[0] = value1;\n\tuint16Array[1] = value2;\n\tuint16Array[2] = value3;\n\tuint16Array[3] = value4;\n\n\tAtomics.store(data, index, uint64Array[0]);\n}"],"mappings":";AAAA,IAAM,oBAAS,IAAI,YAAY,CAAC,GAC1B,IAAc,IAAI,eAAe,CAAM,GACvC,IAAc,IAAI,YAAY,CAAM;AAE1C,SAAgB,EAAa,GAAsB,GAAiD;CAGnG,OAFA,EAAY,KAAK,QAAQ,KAAK,GAAM,CAAK,GAElC;EAAC,EAAY;EAAI,EAAY;EAAI,EAAY;EAAI,EAAY;CAAE;AACvE;AAEA,SAAgB,EAAY,GAAsB,GAAe,GAAgB,GAAgB,GAAgB,IAAiB,GAAG;CAMpI,AALA,EAAY,KAAK,GACjB,EAAY,KAAK,GACjB,EAAY,KAAK,GACjB,EAAY,KAAK,GAEjB,QAAQ,MAAM,GAAM,GAAO,EAAY,EAAE;AAC1C"}

package/dist/utils/atomic-math.js

@@ -0,0 +1,34 @@
+import { compareExchangeFloat32 as e, loadFloat32 as t } from "./float32-atomics.js";
+//#region src/utils/atomic-math.ts
+function n(e, t, n, r) {
+	let i, a;
+	do
+		i = Atomics.load(e, t), a = Math.min(i + n, r);
+	while (Atomics.compareExchange(e, t, i, a) !== i);
+	return a;
+}
+function r(e, t, n, r) {
+	let i, a;
+	do
+		i = Atomics.load(e, t), a = Math.max(i - n, r);
+	while (Atomics.compareExchange(e, t, i, a) !== i);
+	return a;
+}
+function i(n, r, i, a) {
+	let o, s;
+	do
+		o = t(n, r), s = Math.min(o + i, a);
+	while (e(n, r, o, s) !== o);
+	return s;
+}
+function a(n, r, i, a) {
+	let o, s;
+	do
+		o = t(n, r), s = Math.max(o - i, a);
+	while (e(n, r, o, s) !== o);
+	return s;
+}
+//#endregion
+export { i as addAtomicFloat32, n as addAtomicInt, a as subtractAtomicFloat, r as subtractAtomicInt };
+
+//# sourceMappingURL=atomic-math.js.map

package/dist/utils/atomic-math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-math.js","names":[],"sources":["../../src/utils/atomic-math.ts"],"sourcesContent":["import { compareExchangeFloat32, loadFloat32 } from './float32-atomics';\n\nexport function addAtomicInt(array: Uint32Array | Int32Array, index: number, amount: number, max: number) {\n\tlet oldValue;\n\tlet newValue;\n\tdo {\n\t\toldValue = Atomics.load(array, index);\n\t\tnewValue = Math.min(oldValue + amount, max);\n\t} while(Atomics.compareExchange(array, index, oldValue, newValue) !== oldValue);\n\n\treturn newValue;\n}\n\nexport function subtractAtomicInt(array: Uint32Array | Int32Array, index: number, amount: number, min: number) {\n\tlet oldValue;\n\tlet newValue;\n\tdo {\n\t\toldValue = Atomics.load(array, index);\n\t\tnewValue = Math.max(oldValue - amount, min);\n\t} while(Atomics.compareExchange(array, index, oldValue, newValue) !== oldValue);\n\n\treturn newValue;\n}\n\nexport function addAtomicFloat32(array: Float32Array, index: number, amount: number, max: number) {\n\tlet oldValue;\n\tlet newValue;\n\tdo {\n\t\toldValue = loadFloat32(array, index);\n\t\tnewValue = Math.min(oldValue + amount, max);\n\t} while(compareExchangeFloat32(array, index, oldValue, newValue) !== oldValue);\n\n\treturn newValue;\n}\n\nexport function subtractAtomicFloat(array: Float32Array, index: number, amount: number, min: number) {\n\tlet oldValue;\n\tlet newValue;\n\tdo {\n\t\toldValue = loadFloat32(array, index);\n\t\tnewValue = Math.max(oldValue - amount, min);\n\t} while(compareExchangeFloat32(array, index, oldValue, newValue) !== oldValue);\n\n\treturn newValue;\n}"],"mappings":";;AAEA,SAAgB,EAAa,GAAiC,GAAe,GAAgB,GAAa;CACzG,IAAI,GACA;CACJ;EAEC,AADA,IAAW,QAAQ,KAAK,GAAO,CAAK,GACpC,IAAW,KAAK,IAAI,IAAW,GAAQ,CAAG;QACnC,QAAQ,gBAAgB,GAAO,GAAO,GAAU,CAAQ,MAAM;CAEtE,OAAO;AACR;AAEA,SAAgB,EAAkB,GAAiC,GAAe,GAAgB,GAAa;CAC9G,IAAI,GACA;CACJ;EAEC,AADA,IAAW,QAAQ,KAAK,GAAO,CAAK,GACpC,IAAW,KAAK,IAAI,IAAW,GAAQ,CAAG;QACnC,QAAQ,gBAAgB,GAAO,GAAO,GAAU,CAAQ,MAAM;CAEtE,OAAO;AACR;AAEA,SAAgB,EAAiB,GAAqB,GAAe,GAAgB,GAAa;CACjG,IAAI,GACA;CACJ;EAEC,AADA,IAAW,EAAY,GAAO,CAAK,GACnC,IAAW,KAAK,IAAI,IAAW,GAAQ,CAAG;QACnC,EAAuB,GAAO,GAAO,GAAU,CAAQ,MAAM;CAErE,OAAO;AACR;AAEA,SAAgB,EAAoB,GAAqB,GAAe,GAAgB,GAAa;CACpG,IAAI,GACA;CACJ;EAEC,AADA,IAAW,EAAY,GAAO,CAAK,GACnC,IAAW,KAAK,IAAI,IAAW,GAAQ,CAAG;QACnC,EAAuB,GAAO,GAAO,GAAU,CAAQ,MAAM;CAErE,OAAO;AACR"}

package/dist/utils/float32-atomics.js

@@ -0,0 +1,24 @@
+//#region src/utils/float32-atomics.ts
+var e = /* @__PURE__ */ new ArrayBuffer(4), t = new Float32Array(e), n = new Int32Array(e);
+function r(e, t) {
+	return e instanceof Float32Array && (e = new Int32Array(e.buffer, e.byteOffset, e.length)), a(Atomics.load(e, t));
+}
+function i(e, t, n) {
+	e instanceof Float32Array && (e = new Int32Array(e.buffer, e.byteOffset, e.length)), Atomics.store(e, t, o(n));
+}
+function a(e) {
+	return n[0] = e, t[0];
+}
+function o(e) {
+	return t[0] = e, n[0];
+}
+function s(e, t, n) {
+	return e instanceof Float32Array && (e = new Int32Array(e.buffer, e.byteOffset, e.length)), a(Atomics.exchange(e, t, o(n)));
+}
+function c(e, t, n, r) {
+	return e instanceof Float32Array && (e = new Int32Array(e.buffer, e.byteOffset, e.length)), a(Atomics.compareExchange(e, t, o(n), o(r)));
+}
+//#endregion
+export { c as compareExchangeFloat32, o as convertFloat32ToInt32, a as convertInt32ToFloat32, s as exchangeFloat32, r as loadFloat32, i as storeFloat32 };
+
+//# sourceMappingURL=float32-atomics.js.map

package/dist/utils/float32-atomics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"float32-atomics.js","names":[],"sources":["../../src/utils/float32-atomics.ts"],"sourcesContent":["// For doing Atomic operations on floats in SharedArrayBuffers\nconst buffer = new ArrayBuffer(4);\nconst float32 = new Float32Array(buffer);\nconst int32 = new Int32Array(buffer);\n\nexport function loadFloat32(data: Int32Array | Uint32Array | Float32Array, index: number) {\n\tif(data instanceof Float32Array) {\n\t\tdata = new Int32Array(data.buffer, data.byteOffset, data.length);\n\t}\n\n\treturn convertInt32ToFloat32(Atomics.load(data, index));\n}\nexport function storeFloat32(data: Int32Array | Uint32Array | Float32Array, index: number, value: number) {\n\tif(data instanceof Float32Array) {\n\t\tdata = new Int32Array(data.buffer, data.byteOffset, data.length);\n\t}\n\n\tAtomics.store(data, index, convertFloat32ToInt32(value));\n}\n\nexport function convertInt32ToFloat32(value: number) {\n\tint32[0] = value;\n\n\treturn float32[0];\n}\nexport function convertFloat32ToInt32(value: number) {\n\tfloat32[0] = value;\n\n\treturn int32[0];\n}\n\nexport function exchangeFloat32(data: Int32Array | Uint32Array | Float32Array, index: number, value: number) {\n\tif(data instanceof Float32Array) {\n\t\tdata = new Int32Array(data.buffer, data.byteOffset, data.length);\n\t}\n\n\treturn convertInt32ToFloat32(Atomics.exchange(data, index, convertFloat32ToInt32(value)));\n}\n\nexport function compareExchangeFloat32(data: Int32Array | Uint32Array | Float32Array, index: number, expectedValue: number, replacementValue: number) {\n\tif(data instanceof Float32Array) {\n\t\tdata = new Int32Array(data.buffer, data.byteOffset, data.length);\n\t}\n\n\treturn convertInt32ToFloat32(Atomics.compareExchange(data, index, convertFloat32ToInt32(expectedValue), convertFloat32ToInt32(replacementValue)));\n}"],"mappings":";AACA,IAAM,oBAAS,IAAI,YAAY,CAAC,GAC1B,IAAU,IAAI,aAAa,CAAM,GACjC,IAAQ,IAAI,WAAW,CAAM;AAEnC,SAAgB,EAAY,GAA+C,GAAe;CAKzF,OAJG,aAAgB,iBAClB,IAAO,IAAI,WAAW,EAAK,QAAQ,EAAK,YAAY,EAAK,MAAM,IAGzD,EAAsB,QAAQ,KAAK,GAAM,CAAK,CAAC;AACvD;AACA,SAAgB,EAAa,GAA+C,GAAe,GAAe;CAKzG,AAJG,aAAgB,iBAClB,IAAO,IAAI,WAAW,EAAK,QAAQ,EAAK,YAAY,EAAK,MAAM,IAGhE,QAAQ,MAAM,GAAM,GAAO,EAAsB,CAAK,CAAC;AACxD;AAEA,SAAgB,EAAsB,GAAe;CAGpD,OAFA,EAAM,KAAK,GAEJ,EAAQ;AAChB;AACA,SAAgB,EAAsB,GAAe;CAGpD,OAFA,EAAQ,KAAK,GAEN,EAAM;AACd;AAEA,SAAgB,EAAgB,GAA+C,GAAe,GAAe;CAK5G,OAJG,aAAgB,iBAClB,IAAO,IAAI,WAAW,EAAK,QAAQ,EAAK,YAAY,EAAK,MAAM,IAGzD,EAAsB,QAAQ,SAAS,GAAM,GAAO,EAAsB,CAAK,CAAC,CAAC;AACzF;AAEA,SAAgB,EAAuB,GAA+C,GAAe,GAAuB,GAA0B;CAKrJ,OAJG,aAAgB,iBAClB,IAAO,IAAI,WAAW,EAAK,QAAQ,EAAK,YAAY,EAAK,MAAM,IAGzD,EAAsB,QAAQ,gBAAgB,GAAM,GAAO,EAAsB,CAAa,GAAG,EAAsB,CAAgB,CAAC,CAAC;AACjJ"}