@daneren2005/shared-memory-objects 1.1.0 → 1.3.0

package/dist/constant-string.js

@@ -0,0 +1,67 @@
+import { getPointer as e, loadRawPointer as t, storeRawPointer as n } from "./utils/pointer.js";
+import r from "./allocated-memory.js";
+//#region src/constant-string.ts
+var i = {
+	1: Uint8Array,
+	2: Uint16Array
+}, a = 0, o = 1, s = 2, c = class c {
+	static ALLOCATE_COUNT = 3;
+	memory;
+	allocatedMemory;
+	value;
+	constructor(e, t) {
+		this.memory = e, typeof t == "string" ? (this.allocatedMemory = this.memory.allocUI32(c.ALLOCATE_COUNT), this.writeString(t), this.value = t) : (this.allocatedMemory = new r(e, t), this.value = this.readString());
+	}
+	writeString(e) {
+		let t = this.createString(e);
+		n(this.allocatedMemory.data, a, t.pointer), Atomics.store(this.allocatedMemory.data, o, e.length), Atomics.store(this.allocatedMemory.data, s, t.charType);
+	}
+	readString() {
+		let n = t(this.allocatedMemory.data, a);
+		if (n === 0) return "";
+		let { bufferPosition: r, bufferByteOffset: c } = e(n), u = i[Atomics.load(this.allocatedMemory.data, s)], d = Atomics.load(this.allocatedMemory.data, o);
+		return l(new u(this.memory.buffers[r].buf, c, d));
+	}
+	createString(e) {
+		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 = i[n], a = this.memory.allocUI32(Math.ceil(e.length / (4 / r.BYTES_PER_ELEMENT))), o = new r(a.data.buffer, a.data.byteOffset, e.length);
+		for (let t = 0; t < e.length; t++) o[t] = e.charCodeAt(t);
+		return {
+			pointer: a.pointer,
+			charType: n
+		};
+	}
+	getSharedMemory() {
+		return this.allocatedMemory.getSharedMemory();
+	}
+	get pointer() {
+		return this.allocatedMemory.pointer;
+	}
+	free() {
+		let n = t(this.allocatedMemory.data, a);
+		if (n) {
+			let { bufferPosition: t, bufferByteOffset: r } = e(n);
+			this.memory.buffers[t].free(r);
+		}
+		this.allocatedMemory.free();
+	}
+};
+function l(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 { c as default };
+
+//# sourceMappingURL=constant-string.js.map

package/dist/constant-string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant-string.js","names":[],"sources":["../src/constant-string.ts"],"sourcesContent":["import AllocatedMemory from './allocated-memory';\nimport type { SharedAllocatedMemory } from './allocated-memory';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer, 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;\n\n// An immutable SharedString: the value is written once at construction and never changes\nexport default class ConstantString {\n\tstatic readonly ALLOCATE_COUNT = 3;\n\n\tprivate memory: MemoryHeap;\n\tprivate allocatedMemory: AllocatedMemory;\n\n\treadonly value: string;\n\n\tconstructor(memory: MemoryHeap, value: string | SharedAllocatedMemory) {\n\t\tthis.memory = memory;\n\n\t\tif(typeof value === 'string') {\n\t\t\tthis.allocatedMemory = this.memory.allocUI32(ConstantString.ALLOCATE_COUNT);\n\t\t\tthis.writeString(value);\n\t\t\tthis.value = value;\n\t\t} else {\n\t\t\t// A read-only view over a header another thread already wrote.\n\t\t\tthis.allocatedMemory = new AllocatedMemory(memory, value);\n\t\t\tthis.value = this.readString();\n\t\t}\n\t}\n\n\tprivate writeString(value: string) {\n\t\tconst stringMemory = this.createString(value);\n\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}\n\n\tprivate readString(): string {\n\t\tlet pointer = loadRawPointer(this.allocatedMemory.data, POINTER_INDEX);\n\t\tif(pointer === 0) {\n\t\t\treturn '';\n\t\t}\n\t\tlet { bufferPosition, bufferByteOffset } = getPointer(pointer);\n\n\t\t// No lock: the value never changes after it is written once, so the memory it points at is never freed or\n\t\t// rewritten underneath us.\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\treturn fromCharCodes(data);\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\tgetSharedMemory(): SharedAllocatedMemory {\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 pointer = loadRawPointer(this.allocatedMemory.data, POINTER_INDEX);\n\t\tif(pointer) {\n\t\t\tlet { bufferPosition, bufferByteOffset } = getPointer(pointer);\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"],"mappings":";;;AAUA,IAAM,IAAkB;CACJ,GAAA;CACA,GAAA;AACpB,GAEM,IAAgB,GAChB,IAAe,GACf,IAAa,GAGE,IAArB,MAAqB,EAAe;CACnC,OAAgB,iBAAiB;CAEjC;CACA;CAEA;CAEA,YAAY,GAAoB,GAAuC;EAGtE,AAFA,KAAK,SAAS,GAEX,OAAO,KAAU,YACnB,KAAK,kBAAkB,KAAK,OAAO,UAAU,EAAe,cAAc,GAC1E,KAAK,YAAY,CAAK,GACtB,KAAK,QAAQ,MAGb,KAAK,kBAAkB,IAAI,EAAgB,GAAQ,CAAK,GACxD,KAAK,QAAQ,KAAK,WAAW;CAE/B;CAEA,YAAoB,GAAe;EAClC,IAAM,IAAe,KAAK,aAAa,CAAK;EAI5C,AAFA,EAAgB,KAAK,gBAAgB,MAAM,GAAe,EAAa,OAAO,GAC9E,QAAQ,MAAM,KAAK,gBAAgB,MAAM,GAAc,EAAM,MAAM,GACnE,QAAQ,MAAM,KAAK,gBAAgB,MAAM,GAAY,EAAa,QAAQ;CAC3E;CAEA,aAA6B;EAC5B,IAAI,IAAU,EAAe,KAAK,gBAAgB,MAAM,CAAa;EACrE,IAAG,MAAY,GACd,OAAO;EAER,IAAI,EAAE,mBAAgB,wBAAqB,EAAW,CAAO,GAMzD,IAAa,EAFF,QAAQ,KAAK,KAAK,gBAAgB,MAAM,CAEtB,IAC7B,IAAe,QAAQ,KAAK,KAAK,gBAAgB,MAAM,CAAY;EAGvE,OAAO,EAAc,IADN,EAAW,KAAK,OAAO,QAAQ,EAAe,CAAC,KAAK,GAAkB,CAChE,CAAI;CAC1B;CACA,aAAqB,GAAe;EACnC,IAAG,MAAU,IACZ,OAAO;GACN,SAAS;GACT,UAAA;EACD;EAID,IAAI,IAAc;EAClB,KAAI,IAAI,IAAI,GAAG,IAAI,EAAM,QAAQ,KAAK;GACrC,IAAI,IAAW,EAAM,WAAW,CAAC;GACjC,AAAG,IAAW,MACb,IAAc;EAEhB;EACA,IAAI,IAAW,IAAc,MAAA,IAAA,GAEzB,IAAa,EAAgB,IAC7B,IAAkB,KAAK,OAAO,UAAU,KAAK,KAAK,EAAM,UAAU,IAAI,EAAW,kBAAkB,CAAC,GACpG,IAAO,IAAI,EAAW,EAAgB,KAAK,QAAuB,EAAgB,KAAK,YAAY,EAAM,MAAM;EACnH,KAAI,IAAI,IAAI,GAAG,IAAI,EAAM,QAAQ,KAChC,EAAK,KAAK,EAAM,WAAW,CAAC;EAG7B,OAAO;GACN,SAAS,EAAgB;GACzB;EACD;CACD;CAEA,kBAAyC;EACxC,OAAO,KAAK,gBAAgB,gBAAgB;CAC7C;CAEA,IAAI,UAAU;EACb,OAAO,KAAK,gBAAgB;CAC7B;CAEA,OAAO;EACN,IAAI,IAAU,EAAe,KAAK,gBAAgB,MAAM,CAAa;EACrE,IAAG,GAAS;GACX,IAAI,EAAE,mBAAgB,wBAAqB,EAAW,CAAO;GAC7D,KAAK,OAAO,QAAQ,EAAe,CAAC,KAAK,CAAgB;EAC1D;EACA,KAAK,gBAAgB,KAAK;CAC3B;AACD;AAIA,SAAS,EAAc,GAAwC;CAC9D,IAAM,IAAa;CACnB,IAAG,EAAK,UAAU,GACjB,OAAO,OAAO,aAAa,MAAM,MAAM,CAAgC;CAGxE,IAAI,IAAS;CACb,KAAI,IAAI,IAAI,GAAG,IAAI,EAAK,QAAQ,KAAK,GACpC,KAAU,OAAO,aAAa,MAAM,MAAM,EAAK,SAAS,GAAG,IAAI,CAAU,CAA6B;CAGvG,OAAO;AACR"}

package/dist/interfaces/pow2.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=pow2.js.map

package/dist/interfaces/typed-array-constructor.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=typed-array-constructor.js.map

package/dist/interfaces/typed-array.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=typed-array.js.map

package/dist/{src/local-pool.d.ts → local-pool.d.ts}

@@ -1,5 +1,5 @@
-import { TypedArrayConstructor } from './interfaces/typed-array-constructor';
-import { default as MemoryHeap } from './memory-heap';
+import type { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import type MemoryHeap from './memory-heap';
 export default class LocalPool<T extends Uint32Array | Int32Array | Float32Array | Float64Array = Uint32Array> implements Iterable<T> {
     private memory;
     private pointers;

package/dist/local-pool.js

@@ -1,95 +1,90 @@
-import n from "./allocated-memory.js";
-import { getPointer as o } from "./utils/pointer.js";
-class g {
-  memory;
-  pointers = [];
-  recycledIndexes = [];
-  totalLength = 0;
-  maxChunkSize = 100;
-  dataLength = 1;
-  byteMultipler = 1;
-  typeConstructor;
-  fullDataBlocks = {};
-  get length() {
-    return this.totalLength - this.recycledIndexes.length;
-  }
-  get bufferLength() {
-    return this.maxChunkSize * this.pointers.length;
-  }
-  constructor(t, e) {
-    this.memory = t;
-    const a = e?.dataLength ?? 1, h = e?.maxChunkSize ?? 100;
-    this.dataLength = a, this.maxChunkSize = h, this.typeConstructor = e.type, this.typeConstructor === Float64Array && (this.byteMultipler = 2);
-    let i = t.allocUI32(h * a * this.byteMultipler);
-    this.pointers.push(i.pointer);
-    let s = new this.typeConstructor(i.data.buffer, i.bufferByteOffset, this.dataLength * this.maxChunkSize);
-    this.fullDataBlocks[0] = s;
-  }
-  at(t) {
-    let e = this.fullDataBlocks[Math.floor(t / this.maxChunkSize)];
-    return this.getDataBlock(e, t % this.maxChunkSize);
-  }
-  get(t, e = 0) {
-    const a = this.dataLength;
-    if (e >= a)
-      throw new Error(`${e} is out of dataLength bounds ${a}`);
-    return this.fullDataBlocks[Math.floor(t / this.maxChunkSize)][t % this.maxChunkSize * a + e];
-  }
-  push(t) {
-    const e = typeof t == "number";
-    if (!e && t.length > this.dataLength)
-      throw new Error(`Can't insert ${t.length} array into shared list of ${this.dataLength} dataLength`);
-    let a = this.recycledIndexes.pop();
-    a === void 0 && (a = this.totalLength++);
-    let h = Math.floor(a / this.maxChunkSize);
-    if (h >= this.pointers.length) {
-      let l = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
-      this.pointers.push(l.pointer);
-      let u = new this.typeConstructor(l.data.buffer, l.bufferByteOffset, this.dataLength * this.maxChunkSize);
-      this.fullDataBlocks[h] = u;
-    }
-    let i = this.fullDataBlocks[h], s = a % this.maxChunkSize, r = this.dataLength * s;
-    return e ? i[r] = t : i.set(t, r), a;
-  }
-  deleteIndex(t) {
-    this.recycledIndexes.push(t);
-  }
-  clear() {
-    this.totalLength = 0, this.recycledIndexes = [];
-  }
-  *[Symbol.iterator]() {
-    const t = {};
-    for (let h of this.recycledIndexes)
-      t[h] = !0;
-    let e = this.getFullDataBlock(0), a = 0;
-    for (let h = 0; h < this.totalLength; h++)
-      if (!t[h]) {
-        let i = Math.floor(h / this.maxChunkSize);
-        i !== a && (e = this.getFullDataBlock(h), a = i), yield this.getDataBlock(e, h % this.maxChunkSize);
-      }
-  }
-  getFullDataBlock(t) {
-    let e = Math.floor(t / this.maxChunkSize), a = this.fullDataBlocks[e];
-    if (a)
-      return a;
-    if (e >= this.pointers.length) {
-      let s = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
-      this.pointers.push(s.pointer);
-    }
-    let h = new n(this.memory, o(this.pointers[e])), i = new this.typeConstructor(h.data.buffer, h.bufferByteOffset, this.dataLength * this.maxChunkSize);
-    return this.fullDataBlocks[e] = i, i;
-  }
-  getDataBlock(t, e) {
-    const a = e * this.dataLength;
-    return t.subarray(a, a + this.dataLength);
-  }
-  free() {
-    for (let t of this.pointers)
-      new n(this.memory, o(t)).free();
-    this.pointers = [], this.recycledIndexes = [], this.totalLength = 0, this.fullDataBlocks = {};
-  }
-}
-export {
-  g as default
+import { getPointer as e } from "./utils/pointer.js";
+import t from "./allocated-memory.js";
+//#region src/local-pool.ts
+var n = class {
+	memory;
+	pointers = [];
+	recycledIndexes = [];
+	totalLength = 0;
+	maxChunkSize = 100;
+	dataLength = 1;
+	byteMultipler = 1;
+	typeConstructor;
+	fullDataBlocks = {};
+	get length() {
+		return this.totalLength - this.recycledIndexes.length;
+	}
+	get bufferLength() {
+		return this.maxChunkSize * this.pointers.length;
+	}
+	constructor(e, t) {
+		this.memory = e;
+		let n = t?.dataLength ?? 1, r = t?.maxChunkSize ?? 100;
+		this.dataLength = n, this.maxChunkSize = r, this.typeConstructor = t.type, this.typeConstructor === Float64Array && (this.byteMultipler = 2);
+		let i = e.allocUI32(r * n * this.byteMultipler);
+		this.pointers.push(i.pointer);
+		let a = new this.typeConstructor(i.data.buffer, i.bufferByteOffset, this.dataLength * this.maxChunkSize);
+		this.fullDataBlocks[0] = a;
+	}
+	at(e) {
+		let t = this.fullDataBlocks[Math.floor(e / this.maxChunkSize)];
+		return this.getDataBlock(t, e % this.maxChunkSize);
+	}
+	get(e, t = 0) {
+		let n = this.dataLength;
+		if (t >= n) throw Error(`${t} is out of dataLength bounds ${n}`);
+		return this.fullDataBlocks[Math.floor(e / this.maxChunkSize)][e % this.maxChunkSize * n + t];
+	}
+	push(e) {
+		let t = typeof e == "number";
+		if (!t && e.length > this.dataLength) throw Error(`Can't insert ${e.length} array into shared list of ${this.dataLength} dataLength`);
+		let n = this.recycledIndexes.pop();
+		n === void 0 && (n = this.totalLength++);
+		let r = Math.floor(n / this.maxChunkSize);
+		if (r >= this.pointers.length) {
+			let e = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
+			this.pointers.push(e.pointer);
+			let t = new this.typeConstructor(e.data.buffer, e.bufferByteOffset, this.dataLength * this.maxChunkSize);
+			this.fullDataBlocks[r] = t;
+		}
+		let i = this.fullDataBlocks[r], a = n % this.maxChunkSize, o = this.dataLength * a;
+		return t ? i[o] = e : i.set(e, o), n;
+	}
+	deleteIndex(e) {
+		this.recycledIndexes.push(e);
+	}
+	clear() {
+		this.totalLength = 0, this.recycledIndexes = [];
+	}
+	*[Symbol.iterator]() {
+		let e = {};
+		for (let t of this.recycledIndexes) e[t] = !0;
+		let t = this.getFullDataBlock(0), n = 0;
+		for (let r = 0; r < this.totalLength; r++) if (!e[r]) {
+			let e = Math.floor(r / this.maxChunkSize);
+			e !== n && (t = this.getFullDataBlock(r), n = e), yield this.getDataBlock(t, r % this.maxChunkSize);
+		}
+	}
+	getFullDataBlock(n) {
+		let r = Math.floor(n / this.maxChunkSize), i = this.fullDataBlocks[r];
+		if (i) return i;
+		if (r >= this.pointers.length) {
+			let e = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);
+			this.pointers.push(e.pointer);
+		}
+		let a = new t(this.memory, e(this.pointers[r])), o = new this.typeConstructor(a.data.buffer, a.bufferByteOffset, this.dataLength * this.maxChunkSize);
+		return this.fullDataBlocks[r] = o, o;
+	}
+	getDataBlock(e, t) {
+		let n = t * this.dataLength;
+		return e.subarray(n, n + this.dataLength);
+	}
+	free() {
+		for (let n of this.pointers) new t(this.memory, e(n)).free();
+		this.pointers = [], this.recycledIndexes = [], this.totalLength = 0, this.fullDataBlocks = {};
+	}
 };
-//# sourceMappingURL=local-pool.js.map
+//#endregion
+export { n as default };
+
+//# sourceMappingURL=local-pool.js.map

package/dist/local-pool.js.map

@@ -1 +1 @@
-{"version":3,"file":"local-pool.js","sources":["../src/local-pool.ts"],"sourcesContent":["import AllocatedMemory from './allocated-memory';\nimport type { TypedArrayConstructor } from './interfaces/typed-array-constructor';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer } from './utils/pointer';\n\n// Array with stable indexes and maximum contiguous memory sizes (necessary to fit large data sets into max 1MB buffers)\n// Can only do insert/deletions from a single thread - useful if other threads are known to be read-only\nexport default class LocalPool<T extends Uint32Array | Int32Array | Float32Array | Float64Array = Uint32Array> implements Iterable<T> {\n\tprivate memory: MemoryHeap;\n\tprivate pointers: Array<number> = [];\n\tprivate recycledIndexes: Array<number> = [];\n\tprivate totalLength = 0;\n\treadonly maxChunkSize: number = 100;\n\treadonly dataLength: number = 1;\n\treadonly byteMultipler: number = 1;\n\tprivate typeConstructor: TypedArrayConstructor<T>;\n\tprivate fullDataBlocks: { [key: number]: T } = {};\n\n\tget length(): number {\n\t\treturn this.totalLength - this.recycledIndexes.length;\n\t}\n\tget bufferLength(): number {\n\t\treturn this.maxChunkSize * this.pointers.length;\n\t}\n\n\tconstructor(memory: MemoryHeap, config: LocalPoolConfig<T>) {\n\t\tthis.memory = memory;\n\n\t\tconst dataLength = config?.dataLength ?? 1;\n\t\tconst maxLength = config?.maxChunkSize ?? 100;\n\t\tthis.dataLength = dataLength;\n\t\tthis.maxChunkSize = maxLength;\n\n\t\tthis.typeConstructor = config.type;\n\t\t// @ts-expect-error\n\t\tif(this.typeConstructor === Float64Array) {\n\t\t\tthis.byteMultipler = 2;\n\t\t}\n\n\t\tlet firstArray = memory.allocUI32(maxLength * dataLength * this.byteMultipler);\n\t\tthis.pointers.push(firstArray.pointer);\n\t\tlet data: T = new this.typeConstructor(firstArray.data.buffer, firstArray.bufferByteOffset, this.dataLength * this.maxChunkSize) as T;\n\t\tthis.fullDataBlocks[0] = data;\n\t}\n\n\tat(index: number): T {\n\t\tlet dataBlock = this.fullDataBlocks[Math.floor(index / this.maxChunkSize)];\n\t\treturn this.getDataBlock(dataBlock, index % this.maxChunkSize);\n\t}\n\tget(index: number, dataIndex = 0): number {\n\t\tconst dataLength = this.dataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.fullDataBlocks[Math.floor(index / this.maxChunkSize)];\n\t\treturn dataBlock[(index % this.maxChunkSize) * dataLength + dataIndex];\n\t}\n\n\tpush(values: number | Array<number>): number {\n\t\tconst isSingleNumber = typeof values === 'number';\n\t\tif(!isSingleNumber && values.length > this.dataLength) {\n\t\t\tthrow new Error(`Can't insert ${values.length} array into shared list of ${this.dataLength} dataLength`);\n\t\t}\n\n\t\tlet newIndex = this.recycledIndexes.pop();\n\t\tif(newIndex === undefined) {\n\t\t\tnewIndex = this.totalLength++;\n\t\t}\n\t\t\n\t\t\n\t\tlet pointerIndex = Math.floor(newIndex / this.maxChunkSize);\n\t\tif(pointerIndex >= this.pointers.length) {\n\t\t\tlet newArray = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);\n\t\t\tthis.pointers.push(newArray.pointer);\n\t\t\tlet data: T = new this.typeConstructor(newArray.data.buffer, newArray.bufferByteOffset, this.dataLength * this.maxChunkSize) as T;\n\t\t\tthis.fullDataBlocks[pointerIndex] = data;\n\t\t}\n\n\t\tlet dataBlock = this.fullDataBlocks[pointerIndex];\n\t\tlet blockIndex = newIndex % this.maxChunkSize;\n\t\tlet startIndex = this.dataLength * blockIndex;\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\treturn newIndex;\n\t}\n\n\tdeleteIndex(index: number) {\n\t\tthis.recycledIndexes.push(index);\n\t}\n\n\tclear() {\n\t\tthis.totalLength = 0;\n\t\tthis.recycledIndexes = [];\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycledIndexes) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < this.totalLength; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / this.maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield this.getDataBlock(dataBlock, i % this.maxChunkSize);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getFullDataBlock(index: number) {\n\t\tlet pointerIndex = Math.floor(index / this.maxChunkSize);\n\t\tlet cachedDataBlock = this.fullDataBlocks[pointerIndex];\n\t\tif(cachedDataBlock) {\n\t\t\treturn cachedDataBlock;\n\t\t}\n\t\tif(pointerIndex >= this.pointers.length) {\n\t\t\tlet newArray = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);\n\t\t\tthis.pointers.push(newArray.pointer);\n\t\t}\n\n\t\tlet array = new AllocatedMemory(this.memory, getPointer(this.pointers[pointerIndex]));\n\t\tlet data: T = new this.typeConstructor(array.data.buffer, array.bufferByteOffset, this.dataLength * this.maxChunkSize) as T;\n\t\tthis.fullDataBlocks[pointerIndex] = data;\n\t\treturn data;\n\t}\n\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\tfree() {\n\t\tfor(let pointer of this.pointers) {\n\t\t\tlet memory = new AllocatedMemory(this.memory, getPointer(pointer));\n\t\t\tmemory.free();\n\t\t}\n\t\tthis.pointers = [];\n\t\tthis.recycledIndexes = [];\n\t\tthis.totalLength = 0;\n\t\tthis.fullDataBlocks = {};\n\t}\n}\n\ninterface LocalPoolConfig<T extends Uint32Array | Int32Array | Float32Array | Float64Array> {\n\tmaxChunkSize?: number\n\ttype: TypedArrayConstructor<T>\n\tdataLength?: number\n}\nexport type { LocalPoolConfig };"],"names":["LocalPool","memory","config","dataLength","maxLength","firstArray","data","index","dataBlock","dataIndex","values","isSingleNumber","newIndex","pointerIndex","newArray","blockIndex","startIndex","recycledValues","value","dataBlockIndex","i","newDataBlockIndex","cachedDataBlock","array","AllocatedMemory","getPointer","rawData","start","pointer"],"mappings":"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"}
+{"version":3,"file":"local-pool.js","names":[],"sources":["../src/local-pool.ts"],"sourcesContent":["import AllocatedMemory from './allocated-memory';\nimport type { TypedArrayConstructor } from './interfaces/typed-array-constructor';\nimport type MemoryHeap from './memory-heap';\nimport { getPointer } from './utils/pointer';\n\n// Array with stable indexes and maximum contiguous memory sizes (necessary to fit large data sets into max 1MB buffers)\n// Can only do insert/deletions from a single thread - useful if other threads are known to be read-only\nexport default class LocalPool<T extends Uint32Array | Int32Array | Float32Array | Float64Array = Uint32Array> implements Iterable<T> {\n\tprivate memory: MemoryHeap;\n\tprivate pointers: Array<number> = [];\n\tprivate recycledIndexes: Array<number> = [];\n\tprivate totalLength = 0;\n\treadonly maxChunkSize: number = 100;\n\treadonly dataLength: number = 1;\n\treadonly byteMultipler: number = 1;\n\tprivate typeConstructor: TypedArrayConstructor<T>;\n\tprivate fullDataBlocks: { [key: number]: T } = {};\n\n\tget length(): number {\n\t\treturn this.totalLength - this.recycledIndexes.length;\n\t}\n\tget bufferLength(): number {\n\t\treturn this.maxChunkSize * this.pointers.length;\n\t}\n\n\tconstructor(memory: MemoryHeap, config: LocalPoolConfig<T>) {\n\t\tthis.memory = memory;\n\n\t\tconst dataLength = config?.dataLength ?? 1;\n\t\tconst maxLength = config?.maxChunkSize ?? 100;\n\t\tthis.dataLength = dataLength;\n\t\tthis.maxChunkSize = maxLength;\n\n\t\tthis.typeConstructor = config.type;\n\t\t// @ts-expect-error\n\t\tif(this.typeConstructor === Float64Array) {\n\t\t\tthis.byteMultipler = 2;\n\t\t}\n\n\t\tlet firstArray = memory.allocUI32(maxLength * dataLength * this.byteMultipler);\n\t\tthis.pointers.push(firstArray.pointer);\n\t\tlet data: T = new this.typeConstructor(firstArray.data.buffer, firstArray.bufferByteOffset, this.dataLength * this.maxChunkSize);\n\t\tthis.fullDataBlocks[0] = data;\n\t}\n\n\tat(index: number): T {\n\t\tlet dataBlock = this.fullDataBlocks[Math.floor(index / this.maxChunkSize)];\n\t\treturn this.getDataBlock(dataBlock, index % this.maxChunkSize);\n\t}\n\tget(index: number, dataIndex = 0): number {\n\t\tconst dataLength = this.dataLength;\n\t\tif(dataIndex >= dataLength) {\n\t\t\tthrow new Error(`${dataIndex} is out of dataLength bounds ${dataLength}`);\n\t\t}\n\n\t\tlet dataBlock = this.fullDataBlocks[Math.floor(index / this.maxChunkSize)];\n\t\treturn dataBlock[(index % this.maxChunkSize) * dataLength + dataIndex];\n\t}\n\n\tpush(values: number | Array<number>): number {\n\t\tconst isSingleNumber = typeof values === 'number';\n\t\tif(!isSingleNumber && values.length > this.dataLength) {\n\t\t\tthrow new Error(`Can't insert ${values.length} array into shared list of ${this.dataLength} dataLength`);\n\t\t}\n\n\t\tlet newIndex = this.recycledIndexes.pop();\n\t\tif(newIndex === undefined) {\n\t\t\tnewIndex = this.totalLength++;\n\t\t}\n\t\t\n\t\t\n\t\tlet pointerIndex = Math.floor(newIndex / this.maxChunkSize);\n\t\tif(pointerIndex >= this.pointers.length) {\n\t\t\tlet newArray = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);\n\t\t\tthis.pointers.push(newArray.pointer);\n\t\t\tlet data: T = new this.typeConstructor(newArray.data.buffer, newArray.bufferByteOffset, this.dataLength * this.maxChunkSize);\n\t\t\tthis.fullDataBlocks[pointerIndex] = data;\n\t\t}\n\n\t\tlet dataBlock = this.fullDataBlocks[pointerIndex];\n\t\tlet blockIndex = newIndex % this.maxChunkSize;\n\t\tlet startIndex = this.dataLength * blockIndex;\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\treturn newIndex;\n\t}\n\n\tdeleteIndex(index: number) {\n\t\tthis.recycledIndexes.push(index);\n\t}\n\n\tclear() {\n\t\tthis.totalLength = 0;\n\t\tthis.recycledIndexes = [];\n\t}\n\n\t*[Symbol.iterator]() {\n\t\tconst recycledValues: { [key: number]: true } = {};\n\t\tfor(let value of this.recycledIndexes) {\n\t\t\trecycledValues[value] = true;\n\t\t}\n\n\t\tlet dataBlock = this.getFullDataBlock(0);\n\t\tlet dataBlockIndex = 0;\n\t\tfor(let i = 0; i < this.totalLength; i++) {\n\t\t\tif(!recycledValues[i]) {\n\t\t\t\tlet newDataBlockIndex = Math.floor(i / this.maxChunkSize);\n\t\t\t\tif(newDataBlockIndex !== dataBlockIndex) {\n\t\t\t\t\tdataBlock = this.getFullDataBlock(i);\n\t\t\t\t\tdataBlockIndex = newDataBlockIndex;\n\t\t\t\t}\n\t\t\t\tyield this.getDataBlock(dataBlock, i % this.maxChunkSize);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate getFullDataBlock(index: number) {\n\t\tlet pointerIndex = Math.floor(index / this.maxChunkSize);\n\t\tlet cachedDataBlock = this.fullDataBlocks[pointerIndex];\n\t\tif(cachedDataBlock) {\n\t\t\treturn cachedDataBlock;\n\t\t}\n\t\tif(pointerIndex >= this.pointers.length) {\n\t\t\tlet newArray = this.memory.allocUI32(this.maxChunkSize * this.dataLength * this.byteMultipler);\n\t\t\tthis.pointers.push(newArray.pointer);\n\t\t}\n\n\t\tlet array = new AllocatedMemory(this.memory, getPointer(this.pointers[pointerIndex]));\n\t\tlet data: T = new this.typeConstructor(array.data.buffer, array.bufferByteOffset, this.dataLength * this.maxChunkSize);\n\t\tthis.fullDataBlocks[pointerIndex] = data;\n\t\treturn data;\n\t}\n\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\tfree() {\n\t\tfor(let pointer of this.pointers) {\n\t\t\tlet memory = new AllocatedMemory(this.memory, getPointer(pointer));\n\t\t\tmemory.free();\n\t\t}\n\t\tthis.pointers = [];\n\t\tthis.recycledIndexes = [];\n\t\tthis.totalLength = 0;\n\t\tthis.fullDataBlocks = {};\n\t}\n}\n\ninterface LocalPoolConfig<T extends Uint32Array | Int32Array | Float32Array | Float64Array> {\n\tmaxChunkSize?: number\n\ttype: TypedArrayConstructor<T>\n\tdataLength?: number\n}\nexport type { LocalPoolConfig };"],"mappings":"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"}

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

@@ -1,25 +1,19 @@
-function n(o, c = 0) {
-  for (; Atomics.compareExchange(o, c, 0, 1) === 2; )
-    Atomics.wait(o, c, 2);
-  Atomics.add(o, c + 1, 1);
+function e(e, t = 0) {
+	for (; Atomics.compareExchange(e, t, 0, 1) === 2;) Atomics.wait(e, t, 2);
+	Atomics.add(e, t + 1, 1);
 }
-function t(o, c = 0) {
-  let E = Atomics.compareExchange(o, c, 0, 2);
-  for (; E !== 0; )
-    Atomics.wait(o, c, E), E = Atomics.compareExchange(o, c, 0, 2);
+function t(e, t = 0) {
+	let n = Atomics.compareExchange(e, t, 0, 2);
+	for (; n !== 0;) Atomics.wait(e, t, n), n = Atomics.compareExchange(e, t, 0, 2);
 }
-function e(o, c = 0) {
-  Atomics.sub(o, c + 1, 1) - 1 <= 0 && (Atomics.compareExchange(o, c, 1, 0) !== 1 && console.warn("We are unlocking when it was not read locked!"), Atomics.notify(o, c));
+function n(e, t = 0) {
+	Atomics.sub(e, t + 1, 1) - 1 <= 0 && (Atomics.compareExchange(e, t, 1, 0) !== 1 && console.warn("We are unlocking when it was not read locked!"), Atomics.notify(e, t));
 }
-function i(o, c = 0) {
-  Atomics.compareExchange(o, c, 2, 0) !== 2 && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(o, c);
+function r(e, t = 0) {
+	Atomics.compareExchange(e, t, 2, 0) !== 2 && console.warn("We are unlocking when it was not write locked!"), Atomics.notify(e, t);
 }
-const C = 2;
-export {
-  C as READ_WRITE_LOCK_ALLOCATE_COUNT,
-  n as readLock,
-  e as readUnlock,
-  t as writeLock,
-  i as writeUnlock
-};
-//# sourceMappingURL=read-write-lock.js.map
+var i = 2;
+//#endregion
+export { i as READ_WRITE_LOCK_ALLOCATE_COUNT, e as readLock, n as readUnlock, t as writeLock, r as writeUnlock };
+
+//# sourceMappingURL=read-write-lock.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"read-write-lock.js","sources":["../../src/lock/read-write-lock.ts"],"sourcesContent":["const UNLOCKED = 0;\nconst READ_LOCKED = 1;\nconst WRITE_LOCKED = 2;\n\nexport function readLock(data: Int32Array, index: number = 0) {\n\t// Wait over and over again until we get that it was unlocked or read locked\n\twhile(Atomics.compareExchange(data, index, UNLOCKED, READ_LOCKED) === WRITE_LOCKED) {\n\t\tAtomics.wait(data, index, WRITE_LOCKED);\n\t}\n\n\tAtomics.add(data, index + 1, 1);\n}\nexport function writeLock(data: Int32Array, index: number = 0) {\n\t// Write lock needs to be exclusive - wait until we were in UNLOCKED to proceed\n\tlet oldValue = Atomics.compareExchange(data, index, UNLOCKED, WRITE_LOCKED);\n\twhile(oldValue !== UNLOCKED) {\n\t\tAtomics.wait(data, index, oldValue);\n\t\toldValue = Atomics.compareExchange(data, index, UNLOCKED, WRITE_LOCKED);\n\t}\n}\n\nexport function readUnlock(data: Int32Array, index: number = 0) {\n\tlet readCount = Atomics.sub(data, index + 1, 1) - 1;\n\n\tif(readCount <= 0) {\n\t\tif(Atomics.compareExchange(data, index, READ_LOCKED, UNLOCKED) !== READ_LOCKED) {\n\t\t\tconsole.warn('We are unlocking when it was not read locked!');\n\t\t}\n\n\t\tAtomics.notify(data, index);\n\t}\n}\nexport function writeUnlock(data: Int32Array, index: number = 0) {\n\tif(Atomics.compareExchange(data, index, WRITE_LOCKED, UNLOCKED) !== WRITE_LOCKED) {\n\t\tconsole.warn('We are unlocking when it was not write locked!');\n\t}\n\n\tAtomics.notify(data, index);\n}\n\nexport const READ_WRITE_LOCK_ALLOCATE_COUNT = 2;"],"names":["readLock","data","index","writeLock","oldValue","readUnlock","writeUnlock","READ_WRITE_LOCK_ALLOCATE_COUNT"],"mappings":"AAIO,SAASA,EAASC,GAAkBC,IAAgB,GAAG;AAE7D,SAAM,QAAQ,gBAAgBD,GAAMC,GAAO,GAAU,CAAW,MAAM;AACrE,YAAQ,KAAKD,GAAMC,GAAO,CAAY;AAGvC,UAAQ,IAAID,GAAMC,IAAQ,GAAG,CAAC;AAC/B;AACO,SAASC,EAAUF,GAAkBC,IAAgB,GAAG;AAE9D,MAAIE,IAAW,QAAQ,gBAAgBH,GAAMC,GAAO,GAAU,CAAY;AAC1E,SAAME,MAAa;AAClB,YAAQ,KAAKH,GAAMC,GAAOE,CAAQ,GAClCA,IAAW,QAAQ,gBAAgBH,GAAMC,GAAO,GAAU,CAAY;AAExE;AAEO,SAASG,EAAWJ,GAAkBC,IAAgB,GAAG;AAG/D,EAFgB,QAAQ,IAAID,GAAMC,IAAQ,GAAG,CAAC,IAAI,KAElC,MACZ,QAAQ,gBAAgBD,GAAMC,GAAO,GAAa,CAAQ,MAAM,KAClE,QAAQ,KAAK,+CAA+C,GAG7D,QAAQ,OAAOD,GAAMC,CAAK;AAE5B;AACO,SAASI,EAAYL,GAAkBC,IAAgB,GAAG;AAChE,EAAG,QAAQ,gBAAgBD,GAAMC,GAAO,GAAc,CAAQ,MAAM,KACnE,QAAQ,KAAK,gDAAgD,GAG9D,QAAQ,OAAOD,GAAMC,CAAK;AAC3B;AAEO,MAAMK,IAAiC;"}
+{"version":3,"file":"read-write-lock.js","names":[],"sources":["../../src/lock/read-write-lock.ts"],"sourcesContent":["const UNLOCKED = 0;\nconst READ_LOCKED = 1;\nconst WRITE_LOCKED = 2;\n\nexport function readLock(data: Int32Array, index: number = 0) {\n\t// Wait over and over again until we get that it was unlocked or read locked\n\twhile(Atomics.compareExchange(data, index, UNLOCKED, READ_LOCKED) === WRITE_LOCKED) {\n\t\tAtomics.wait(data, index, WRITE_LOCKED);\n\t}\n\n\tAtomics.add(data, index + 1, 1);\n}\nexport function writeLock(data: Int32Array, index: number = 0) {\n\t// Write lock needs to be exclusive - wait until we were in UNLOCKED to proceed\n\tlet oldValue = Atomics.compareExchange(data, index, UNLOCKED, WRITE_LOCKED);\n\twhile(oldValue !== UNLOCKED) {\n\t\tAtomics.wait(data, index, oldValue);\n\t\toldValue = Atomics.compareExchange(data, index, UNLOCKED, WRITE_LOCKED);\n\t}\n}\n\nexport function readUnlock(data: Int32Array, index: number = 0) {\n\tlet readCount = Atomics.sub(data, index + 1, 1) - 1;\n\n\tif(readCount <= 0) {\n\t\tif(Atomics.compareExchange(data, index, READ_LOCKED, UNLOCKED) !== READ_LOCKED) {\n\t\t\tconsole.warn('We are unlocking when it was not read locked!');\n\t\t}\n\n\t\tAtomics.notify(data, index);\n\t}\n}\nexport function writeUnlock(data: Int32Array, index: number = 0) {\n\tif(Atomics.compareExchange(data, index, WRITE_LOCKED, UNLOCKED) !== WRITE_LOCKED) {\n\t\tconsole.warn('We are unlocking when it was not write locked!');\n\t}\n\n\tAtomics.notify(data, index);\n}\n\nexport const READ_WRITE_LOCK_ALLOCATE_COUNT = 2;"],"mappings":"AAIA,SAAgB,EAAS,GAAkB,IAAgB,GAAG;CAE7D,OAAM,QAAQ,gBAAgB,GAAM,GAAO,GAAU,CAAW,MAAM,IACrE,QAAQ,KAAK,GAAM,GAAO,CAAY;CAGvC,QAAQ,IAAI,GAAM,IAAQ,GAAG,CAAC;AAC/B;AACA,SAAgB,EAAU,GAAkB,IAAgB,GAAG;CAE9D,IAAI,IAAW,QAAQ,gBAAgB,GAAM,GAAO,GAAU,CAAY;CAC1E,OAAM,MAAa,IAElB,AADA,QAAQ,KAAK,GAAM,GAAO,CAAQ,GAClC,IAAW,QAAQ,gBAAgB,GAAM,GAAO,GAAU,CAAY;AAExE;AAEA,SAAgB,EAAW,GAAkB,IAAgB,GAAG;CAG/D,AAFgB,QAAQ,IAAI,GAAM,IAAQ,GAAG,CAAC,IAAI,KAElC,MACZ,QAAQ,gBAAgB,GAAM,GAAO,GAAa,CAAQ,MAAM,KAClE,QAAQ,KAAK,+CAA+C,GAG7D,QAAQ,OAAO,GAAM,CAAK;AAE5B;AACA,SAAgB,EAAY,GAAkB,IAAgB,GAAG;CAKhE,AAJG,QAAQ,gBAAgB,GAAM,GAAO,GAAc,CAAQ,MAAM,KACnE,QAAQ,KAAK,gDAAgD,GAG9D,QAAQ,OAAO,GAAM,CAAK;AAC3B;AAEA,IAAa,IAAiC"}

package/dist/lock/simple-lock.js

@@ -1,14 +1,11 @@
-function n(o, c = 0) {
-  for (; Atomics.compareExchange(o, c, 0, 1) !== 0; )
-    "WorkerGlobalScope" in self && Atomics.wait(o, c, 1);
+function e(e, t = 0) {
+	for (; Atomics.compareExchange(e, t, 0, 1) !== 0;) "WorkerGlobalScope" in self && Atomics.wait(e, t, 1);
 }
-function E(o, c = 0) {
-  Atomics.compareExchange(o, c, 1, 0) !== 1 && console.warn("We are unlocking when it was not locked!"), Atomics.notify(o, c);
+function t(e, t = 0) {
+	Atomics.compareExchange(e, t, 1, 0) !== 1 && console.warn("We are unlocking when it was not locked!"), Atomics.notify(e, t);
 }
-const L = 1;
-export {
-  L as SIMPLE_LOCK_ALLOCATE_COUNT,
-  n as lock,
-  E as unlock
-};
-//# sourceMappingURL=simple-lock.js.map
+var n = 1;
+//#endregion
+export { n as SIMPLE_LOCK_ALLOCATE_COUNT, e as lock, t as unlock };
+
+//# sourceMappingURL=simple-lock.js.map

package/dist/lock/simple-lock.js.map

@@ -1 +1 @@
-{"version":3,"file":"simple-lock.js","sources":["../../src/lock/simple-lock.ts"],"sourcesContent":["const UNLOCKED = 0;\nconst LOCKED = 1;\nexport function lock(data: Int32Array, index: number = 0) {\n\t// Wait over and over again until we are one who set this from UNLOCKED to LOCKED\n\twhile(Atomics.compareExchange(data, index, UNLOCKED, LOCKED) !== UNLOCKED) {\n\t\tif('WorkerGlobalScope' in self) {\n\t\t\tAtomics.wait(data, index, LOCKED);\n\t\t} else {\n\t\t\t// TODO: Spin-locks suck....\n\t\t}\n\t}\n}\nexport function unlock(data: Int32Array, index: number = 0) {\n\tif(Atomics.compareExchange(data, index, LOCKED, UNLOCKED) !== LOCKED) {\n\t\tconsole.warn('We are unlocking when it was not locked!');\n\t}\n\n\tAtomics.notify(data, index);\n}\n\nexport const SIMPLE_LOCK_ALLOCATE_COUNT = 1;"],"names":["lock","data","index","unlock","SIMPLE_LOCK_ALLOCATE_COUNT"],"mappings":"AAEO,SAASA,EAAKC,GAAkBC,IAAgB,GAAG;AAEzD,SAAM,QAAQ,gBAAgBD,GAAMC,GAAO,GAAU,CAAM,MAAM;AAChE,IAAG,uBAAuB,QACzB,QAAQ,KAAKD,GAAMC,GAAO,CAAM;AAKnC;AACO,SAASC,EAAOF,GAAkBC,IAAgB,GAAG;AAC3D,EAAG,QAAQ,gBAAgBD,GAAMC,GAAO,GAAQ,CAAQ,MAAM,KAC7D,QAAQ,KAAK,0CAA0C,GAGxD,QAAQ,OAAOD,GAAMC,CAAK;AAC3B;AAEO,MAAME,IAA6B;"}
+{"version":3,"file":"simple-lock.js","names":[],"sources":["../../src/lock/simple-lock.ts"],"sourcesContent":["const UNLOCKED = 0;\nconst LOCKED = 1;\nexport function lock(data: Int32Array, index: number = 0) {\n\t// Wait over and over again until we are one who set this from UNLOCKED to LOCKED\n\twhile(Atomics.compareExchange(data, index, UNLOCKED, LOCKED) !== UNLOCKED) {\n\t\tif('WorkerGlobalScope' in self) {\n\t\t\tAtomics.wait(data, index, LOCKED);\n\t\t} else {\n\t\t\t// TODO: Spin-locks suck....\n\t\t}\n\t}\n}\nexport function unlock(data: Int32Array, index: number = 0) {\n\tif(Atomics.compareExchange(data, index, LOCKED, UNLOCKED) !== LOCKED) {\n\t\tconsole.warn('We are unlocking when it was not locked!');\n\t}\n\n\tAtomics.notify(data, index);\n}\n\nexport const SIMPLE_LOCK_ALLOCATE_COUNT = 1;"],"mappings":"AAEA,SAAgB,EAAK,GAAkB,IAAgB,GAAG;CAEzD,OAAM,QAAQ,gBAAgB,GAAM,GAAO,GAAU,CAAM,MAAM,IAChE,AAAG,uBAAuB,QACzB,QAAQ,KAAK,GAAM,GAAO,CAAM;AAKnC;AACA,SAAgB,EAAO,GAAkB,IAAgB,GAAG;CAK3D,AAJG,QAAQ,gBAAgB,GAAM,GAAO,GAAQ,CAAQ,MAAM,KAC7D,QAAQ,KAAK,0CAA0C,GAGxD,QAAQ,OAAO,GAAM,CAAK;AAC3B;AAEA,IAAa,IAA6B"}

package/dist/{src/memory-buffer.d.ts → memory-buffer.d.ts}

@@ -1,5 +1,7 @@
-import { Pow2 } from './interfaces/pow2';
-import { TypedArray } from './interfaces/typed-array';
+import type { Pow2 } from './interfaces/pow2';
+import type { TypedArray } from './interfaces/typed-array';
+declare const SIZEOF_STATE: number;
+declare const SIZEOF_MEM_BLOCK: number;
 export default class MemoryBuffer {
     buf: ArrayBufferLike;
     protected readonly start: number;
@@ -9,8 +11,8 @@ export default class MemoryBuffer {
     protected lock: Int32Array;
     constructor(opts?: Partial<MemoryBufferConfig>);
     stats(): Readonly<MemoryBufferStats>;
-    callocAs<T extends Type>(type: T, num: number, fill?: number): import('./utils/typedarray').TypedArrayTypeMap[T] | undefined;
-    mallocAs<T extends Type>(type: T, num: number): import('./utils/typedarray').TypedArrayTypeMap[T] | undefined;
+    callocAs<T extends Type>(type: T, num: number, fill?: number): import("./utils/typedarray").TypedArrayTypeMap[T] | undefined;
+    mallocAs<T extends Type>(type: T, num: number): import("./utils/typedarray").TypedArrayTypeMap[T] | undefined;
     calloc(bytes: number, fill?: number): number;
     malloc(bytes: number): number;
     private mallocTop;
@@ -28,6 +30,7 @@ export default class MemoryBuffer {
     protected set end(x: number);
     get top(): number;
     protected set top(x: number);
+    get isEmpty(): boolean;
     protected get _free(): number;
     protected set _free(block: number);
     protected get _used(): number;
@@ -77,6 +80,7 @@ export default class MemoryBuffer {
      */
     protected insert(block: number): void;
 }
+export { SIZEOF_STATE, SIZEOF_MEM_BLOCK };
 type Type = 'u8' | 'u8c' | 'i8' | 'u16' | 'i16' | 'u32' | 'i32' | 'f32' | 'f64';
 interface MemoryBufferConfig {
     /**
@@ -182,4 +186,3 @@ interface MemoryBufferStats {
      */
     total: number;
 }
-export {};