bumparena 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bumparena",
-  "version":"0.0.5",
+  "version":"0.0.6",
   "private": false,
   "type": "module",
   "main": "dist/arena.js",
@@ -9,7 +9,8 @@
   "license":"MIT",
   "scripts": {
     "build": "tsc",
-    "test": "node ./dist/arena.js"
+    "test": "node ./dist/test/test.test.js",
+    "pub": "tsc; npm publish"
   },
  "repository": {
     "type": "git",

package/arena.ts

@@ -1,277 +0,0 @@
-export type ArenaLocation = bigint & { readonly __data_pointer: unique symbol };
-export interface ArenaOptions {
-	initalSize?: number
-	littleEndian?: boolean
-	allignment?: 8 | 16 | 32 | 64
-	bucketOffsets?: number[];
-	bucketCapacities?: number[];
-}
-export interface ArenaCustomHeaders {
-	header0: number,
-	header1: number,
-	header2: number
-}
-export interface ArenaHeaders {
-	totalLength: number
-	payloadlength: number
-	deleted: boolean
-	header0: number
-	header1: number
-	header2: number
-}
-const enum HEADERS {
-	TOTAL_LENGTH_0_32 = 0,
-	PAYLOAD_LENGTH_0_32 = 1,
-	GENERATION_BYTE_0_32 = 2,
-	DELETED_8 = 12,
-	USER_STATUS_0_8 = 13,
-	USER_STATUS_1_8 = 14,
-	USER_STATUS_2_8 = 15,
-}
-
-export class Arena {
-	private HEADER_SIZE_BYTES = 16
-	private _buffer: ArrayBuffer
-	private _view8: Uint8Array
-	private _view32: Uint32Array
-	private _offset: number
-	private _emptySpots: Uint32Array
-	private _allignMask: 7 | 15 | 31 | 63
-	private _allignShift: number
-	private _bucketOffsets: number[];
-	private _bucketCapacities: number[];
-	private _bucketcount: number;
-
-	constructor(options?: ArenaOptions) {
-		this._buffer = new ArrayBuffer(options?.initalSize || 64 * 1024)
-		this._view8 = new Uint8Array(this._buffer);
-		this._view32 = new Uint32Array(this._buffer)
-		this._offset = 0;
-		//@ts-ignore
-		this._allignMask = ((options?.allignment || 8) - 1!) as number
-		this._allignShift = Math.log2(this._allignMask + 1);
-		this._bucketCapacities = options?.bucketCapacities || [1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024]
-		this._bucketOffsets = [];
-		this._bucketcount = this._bucketCapacities.length;
-		let currentOffset = 0;
-		for (const cap of this._bucketCapacities) {
-			this._bucketOffsets.push(currentOffset)
-			currentOffset += (cap + 1)
-		}
-		this._emptySpots = new Uint32Array(currentOffset)
-	}
-
-	private _u(n: number): number {
-		return n >>> 0;
-	}
-
-	private _idx32(byteOffset: number): number {
-		return (byteOffset >>> 0) >> 2;
-	}
-
-	private _makePtr(offset: number, gen: number | bigint): ArenaLocation {
-		const bOffset = BigInt(offset >>> 0);
-		const bGen = BigInt(gen ?? 0);
-		return ((bOffset << 32n) | (bGen & 0xFFFFFFFFn)) as ArenaLocation;
-	}
-
-	private _getOffset(ptr: ArenaLocation): number {
-		return Number(BigInt(ptr) >> 32n) >>> 0;
-	}
-
-	private _getBucketCount(bucketIdx: number): number {
-		return this._emptySpots[this._bucketOffsets[bucketIdx]!]!;
-	}
-
-	private _setBucketCount(bucketIdx: number, count: number): void {
-		this._emptySpots[this._bucketOffsets[bucketIdx]!] = count;
-	}
-
-	private _getBucketOffset(bucketIdx: number, slotIdx: number): number {
-		return this._emptySpots[this._bucketOffsets[bucketIdx]! + slotIdx + 1]!;
-	}
-
-	private _setBucketOffset(bucketIdx: number, slotIdx: number, offset: number): void {
-		this._emptySpots[this._bucketOffsets[bucketIdx]! + slotIdx + 1] = offset;
-	}
-
-	private _initBlock(start: number, dataLength: number, headers: { header0: number, header1: number, header2: number }) {
-		const idx = this._idx32(start)
-		const { header0: h0, header1: h1, header2: h2 } = headers;
-
-		this._view32[idx + HEADERS.TOTAL_LENGTH_0_32] = this._u((dataLength + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask);
-		this._view32[idx + HEADERS.PAYLOAD_LENGTH_0_32] = dataLength;
-
-		this._view32[idx + (HEADERS.DELETED_8 >> 2)] = ((h2 || 0) << 24) | ((h1 || 0) << 16) | ((h0 || 0) << 8);
-		this._view8[start + HEADERS.DELETED_8] = 0;
-	}
-
-	public alloc(data: Uint8Array, headers?: ArenaCustomHeaders): ArenaLocation {
-		headers ||= { header0: 0, header1: 0, header2: 0 };
-
-		const needed = (data.byteLength + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask;
-		const bucketIdx = (needed >> this._allignShift) - 1;
-		if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
-			const count = this._getBucketCount(bucketIdx);
-			if (count > 0) {
-				const recycledOffset = this._u(this._getBucketOffset(bucketIdx, count - 1));
-				this._setBucketCount(bucketIdx, count - 1);
-				this._initBlock(recycledOffset, data.length, headers);
-
-				const gen = this._view32[this._idx32(recycledOffset) + HEADERS.GENERATION_BYTE_0_32]!;
-				return this._makePtr(recycledOffset, gen)
-			}
-		}
-		const start = this._u(this._offset)
-		if (this._checkForSpace(needed)) this._resize()
-		this._initBlock(start, data.byteLength, headers)
-
-		this._view8.set(data, start + this.HEADER_SIZE_BYTES)
-		this._offset = this._u((start + needed) & ~this._allignMask);
-
-		const gen = this._view32[this._idx32(start) + HEADERS.GENERATION_BYTE_0_32]!
-		return this._makePtr(start, gen)
-	}
-	public read(location: ArenaLocation): Uint8Array | null {
-		const { start, generation } = this.translate(location);
-		const idx = this._idx32(start)
-		const currgen = BigInt(this._view32[idx + HEADERS.GENERATION_BYTE_0_32]!)
-
-		if (generation !== currgen) return null
-		if (this._view8[start + HEADERS.DELETED_8] === 1) return null
-
-		const dataLength = this._view32[idx + HEADERS.PAYLOAD_LENGTH_0_32]!;
-		return this._view8.subarray(start + this.HEADER_SIZE_BYTES, start + this.HEADER_SIZE_BYTES + dataLength);
-	}
-	public free(location: ArenaLocation): ArenaLocation {
-		const { start, generation: _ } = this.translate(location)
-		const idx = this._idx32(start)
-		const currgen = this._view32[idx + HEADERS.GENERATION_BYTE_0_32]!
-
-		this._view32[idx + HEADERS.GENERATION_BYTE_0_32] = currgen + 1
-		this._view8[this._u(start) + HEADERS.DELETED_8] = 1
-
-		const totalBlockSize = this._view32[this._idx32(start) + HEADERS.TOTAL_LENGTH_0_32]!
-		const bucketIdx = (totalBlockSize >> this._allignShift) - 1
-		if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
-			const count = this._getBucketCount(bucketIdx)
-			const capacity = this._bucketCapacities[bucketIdx]!
-			if (count < capacity) {
-				this._setBucketOffset(bucketIdx, count, start);
-				this._setBucketCount(bucketIdx, count + 1);
-			}
-		}
-		return this._makePtr(0, 0) as ArenaLocation
-	}
-
-	private _checkForSpace(size: number): boolean {
-		if (this._buffer.byteLength >= (this._offset + size)) return false
-		return true
-	}
-
-	private _resize() {
-		//@ts-ignore
-		this._buffer = this._buffer.transfer(this._buffer.byteLength * 2)
-		this._view8 = new Uint8Array(this._buffer)
-		this._view32 = new Uint32Array(this._buffer)
-	}
-
-	public size(): number {
-		return this._buffer.byteLength
-	}
-
-	public getBuffer(): Uint8Array {
-		return this._view8.subarray(0, this._u(this._offset))
-	}
-	public reserve(size: number): Uint8Array {
-		const start = this._u(this._offset)
-		this._checkForSpace(start + this.HEADER_SIZE_BYTES + size + this._allignMask & ~this._allignMask) && this._resize()
-		this._initBlock(start, size, { header0: 0, header1: 0, header2: 0 })
-		this._offset = (this._offset + size + this.HEADER_SIZE_BYTES + this._allignMask & ~this._allignMask) >>> 0
-		return this._view8.subarray(start + this.HEADER_SIZE_BYTES, start + this.HEADER_SIZE_BYTES + size)
-	}
-	public translate(ptr: ArenaLocation) {
-		const start = this._getOffset(ptr)
-		const generation = ptr & 0xFFFFFFFFn;
-		return { start, generation }
-	}
-	public readWithHeaders(ptr: ArenaLocation): Uint8Array | null {
-		const { start, generation } = this.translate(ptr)
-		let idx32 = this._idx32(start)
-		let length = this._view32[idx32 + HEADERS.PAYLOAD_LENGTH_0_32]!
-		if (BigInt(this._view32[idx32 + HEADERS.GENERATION_BYTE_0_32]!) !== generation) return null
-		return this._view8.subarray(start + 12, start + this.HEADER_SIZE_BYTES + Number(length))
-	}
-	public label(): Array<ArenaLocation> {
-		const ptrArray = new Array<ArenaLocation>()
-		const limit = this._offset;
-		let pos = 0
-		while (this._u(pos) < this._u(limit)) {
-			const totalLength = this._view32[this._idx32(pos)]!;
-			if (totalLength === 0) {
-				pos = this._idx32((pos + 16) & ~15)
-				continue;
-			}
-			const isDeleted = this._view8[this._u(pos) + HEADERS.DELETED_8] === 1
-			if (!isDeleted) {
-				ptrArray.push(
-					this._makePtr(pos, this._view32[this._idx32(pos) + HEADERS.GENERATION_BYTE_0_32]!)
-				);
-			}
-			pos += totalLength
-			if (totalLength === 0) break;
-		}
-		return ptrArray
-	}
-	public getHeaders(ptr: ArenaLocation): ArenaHeaders {
-		const { start, generation: _ } = this.translate(ptr)
-		const idx = this._u(start)
-		return {
-			totalLength: Number(this._view32[this._idx32(start) + HEADERS.TOTAL_LENGTH_0_32]!.toString()),
-			payloadlength: Number(this._view32[this._idx32(start) + HEADERS.PAYLOAD_LENGTH_0_32]!.toString()),
-			deleted: this._view8[idx + HEADERS.DELETED_8] === 1,
-			header0: Number(this._view8[idx + HEADERS.USER_STATUS_0_8]!.toString()),
-			header1: Number(this._view8[idx + HEADERS.USER_STATUS_1_8]!.toString()),
-			header2: Number(this._view8[idx + HEADERS.USER_STATUS_2_8]!.toString()),
-		}
-	}
-	public estimate(size: number, amnt: number): number {
-		return (((size + this._allignMask) & ~this._allignMask) + this.HEADER_SIZE_BYTES) * amnt
-	}
-	public directAlloc(source: Uint8Array, startn: number, endn: number) {
-		const start = this._u(this._offset)
-		const len = endn - startn;
-		const needed = (len + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask;
-		const bucketIdx = (needed >> this._allignShift) - 1;
-		if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
-			const count = this._getBucketCount(bucketIdx);
-			if (count > 0) {
-				const recycledOffset = this._u(this._getBucketOffset(bucketIdx, count - 1));
-				this._setBucketCount(bucketIdx, count - 1);
-				this._initBlock(recycledOffset, needed, { header0: 0, header1: 0, header2: 0 });
-				const gen = this._view32[this._idx32(recycledOffset) + HEADERS.GENERATION_BYTE_0_32]!;
-				this._view8.set(source.subarray(startn, endn), recycledOffset + this.HEADER_SIZE_BYTES)
-				return this._makePtr(recycledOffset, gen)
-			}
-		}
-		if (this._checkForSpace(needed)) this._resize()
-		this._initBlock(start, len, { header0: 0, header1: 0, header2: 0 });
-		this._offset = this._u((start + needed) & ~this._allignMask);
-		this._view8.set(source.subarray(startn, endn), start + this.HEADER_SIZE_BYTES)
-		const gen = this._view32[this._idx32(start) + HEADERS.GENERATION_BYTE_0_32]!
-		return this._makePtr(start, gen)
-
-		// if (this._checkForSpace(needed)) this._resize()
-		// this._initBlock(start, needed, { header0: 0, header1: 0, header2: 0 })
-		// this._view8.set(source.subarray(startn, endn), start + this.HEADER_SIZE_BYTES)
-		// this._offset = this._u((start + needed) & ~this._allignMask);
-		//
-		// const gen = this._view32[this._idx32(start) + HEADERS.GENERATION_BYTE_0_32]!
-		// return this._makePtr(start, gen)
-
-	}
-	public clear() {
-		this._offset = 0
-		this._emptySpots.fill(0)
-	}
-}

package/bench/arena.ts

@@ -1,75 +0,0 @@
-import { pipeline } from "node:stream/promises";
-import { Arena } from "../arena";
-import { stream } from "./init.ts"
-
-
-let tmp: Uint8Array | null = null
-function getNewArenaTransform() {
-	return new WritableStream<Uint8Array>({
-		write(chunk) {
-			let sourceIdx = 0;
-			const chunkLen = chunk.byteLength;
-
-			if (tmp) {
-				const nextNewline = chunk.indexOf(10);
-				if (nextNewline !== -1) {
-					const totalLen = tmp.byteLength + nextNewline;
-					const target = new Uint8Array(totalLen)
-					target.set(tmp, 0);
-					target.set(chunk.subarray(0, nextNewline), tmp.byteLength);
-					arena.directAlloc(target, 0, target.length)
-					sourceIdx = nextNewline + 1;
-					tmp = null;
-				} else {
-					const newTmp = new Uint8Array(tmp.byteLength + chunkLen);
-					newTmp.set(tmp);
-					newTmp.set(chunk);
-					tmp = newTmp;
-					return;
-				}
-			}
-
-			// 2. Schnelle Schleife für den Rest des Chunks
-			while (true) {
-				const idx = chunk.indexOf(10, sourceIdx);
-				if (idx === -1) break;
-
-				const lineLength = idx - sourceIdx;
-				if (lineLength > 0) {
-					arena.directAlloc(chunk, 0, lineLength);
-				}
-				sourceIdx = idx + 1;
-			}
-
-			if (sourceIdx < chunkLen) {
-				tmp = chunk.slice(sourceIdx); // slice kopiert hier einmalig den Rest
-			}
-		},
-		close() {
-			if (tmp) {
-				arena.directAlloc(tmp, 0, tmp.length)
-				tmp = null
-			}
-		}
-	})
-};
-const arena = new Arena();
-(async () => {
-	const start = performance.now()
-	for (let i = 0; i < 10; i++) {
-		tmp = null
-		const arenatransform = getNewArenaTransform()
-		const reader = stream()
-
-		await pipeline(
-			reader,
-			arenatransform
-		)
-		const _ptr = arena.label()
-		arena.clear()
-	}
-	const end = performance.now()
-	console.log(`${(end - start).toFixed(2)} ms`)
-	console.log(process.memoryUsage())
-	console.log(`arenasize: ${arena.size() / 1024} KB`)
-})();

package/bench/array.ts

@@ -1,61 +0,0 @@
-import { pipeline } from "node:stream/promises";
-import { noopWriter, stream } from "./init.ts"
-
-const array: Array<string> = [];
-const decode = new TextDecoder()
-let tmp: Uint8Array | null = null // Rest vom vorherigen Chunk
-function getNewArrayTransformStream() {
-	return new WritableStream<Uint8Array>({
-		write(chunk) {
-			if (tmp) {
-				const combined = new Uint8Array(tmp.byteLength + chunk.byteLength)
-				combined.set(tmp, 0)
-				combined.set(chunk, tmp.byteLength)
-				chunk = combined
-				tmp = null
-			}
-
-			let firstIdx = 0
-			let idx: number
-
-			while ((idx = chunk.indexOf(10, firstIdx)) !== -1) {
-				const lineLength = idx - firstIdx
-				if (lineLength > 0) {
-					array.push(decode.decode(chunk.subarray(firstIdx, idx)!)!)
-				}
-				firstIdx = idx + 1
-			}
-
-			if (firstIdx < chunk.byteLength) {
-				tmp = chunk.subarray(firstIdx)
-			}
-		},
-		close() {
-			if (tmp) {
-				//@ts-ignore
-				array.push(tmp)
-				tmp = null
-			}
-		}
-	})
-};
-
-
-await (async () => {
-	const start = performance.now()
-	for (let i = 0; i < 100; i++) {
-		array.length = 0
-		tmp = null
-		const arraytransform = getNewArrayTransformStream()
-		const reader = stream()
-		await pipeline(
-			reader,
-			arraytransform,
-		)
-		for (const iter of array) noopWriter(iter)
-	}
-	const end = performance.now()
-	console.log(`${(end - start).toFixed(2)} ms`)
-	console.log(`Count: ${array.length}`)
-	console.log(process.memoryUsage())
-})();

package/bench/generateTestdata.ts

@@ -1,3 +0,0 @@
-import { generateData } from "./init.ts"
-
-generateData(12345, 10_000_000)

package/bench/init.ts

@@ -1,38 +0,0 @@
-import { createWriteStream, createReadStream } from "node:fs";
-const testfile = "test3.txt"
-function splitmix32(a: number) {
-	return function() {
-		a |= 0; a = a + 0x9e3779b9 | 0;
-		let t = a ^ a >>> 16; t = Math.imul(t, 0x21f0aaad);
-		t = t ^ t >>> 15; t = Math.imul(t, 0x735a2d97);
-		return ((t = t ^ t >>> 15) >>> 0) / 4294967296;
-	}
-};
-
-export function noopWriter(_data: any) { return true; };
-
-async function generateTestData(seed: number, count: number) {
-	const writer = createWriteStream(testfile, { highWaterMark: 16 * 1024 * 1024 })
-	const random = splitmix32(seed)
-	const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-	for (let i = 0; i < count; i++) {
-		let str = '';
-		const len = Math.floor(random() * 5) + 10;
-		for (let j = 0; j < len; j++) {
-			str += characters.charAt(Math.floor(Math.random() * characters.length));
-		}
-		if (!writer.write(str + "\n")) {
-			await new Promise((res, _rej) => {
-				writer.once("drain", res)
-			})
-		}
-	}
-};
-
-export const stream = () => {
-	return createReadStream(testfile)
-};
-
-export function generateData(seed: number, count: number) {
-	generateTestData(seed, count);
-}

package/dist/arena.d.ts

@@ -1,58 +0,0 @@
-export type ArenaLocation = bigint & {
-    readonly __data_pointer: unique symbol;
-};
-export interface ArenaOptions {
-    initalSize?: number;
-    littleEndian?: boolean;
-    allignment?: 8 | 16 | 32 | 64;
-    bucketOffsets?: number[];
-    bucketCapacities?: number[];
-}
-export interface ArenaCustomHeaders {
-    header0: number;
-    header1: number;
-    header2: number;
-}
-export interface ArenaHeaders {
-    totalLength: number;
-    payloadlength: number;
-    deleted: boolean;
-    header0: number;
-    header1: number;
-    header2: number;
-}
-export declare class Arena {
-    private HEADER_SIZE_BYTES;
-    private _buffer;
-    private _view8;
-    private _view32;
-    private _offset;
-    private _emptySpots;
-    private _allignMask;
-    private _allignShift;
-    private _bucketOffsets;
-    private _bucketCapacities;
-    private _bucketcount;
-    constructor(options?: ArenaOptions);
-    private _getBucketCount;
-    private _setBucketCount;
-    private _getBucketOffset;
-    private _setBucketOffset;
-    private _initBlock;
-    alloc(data: Uint8Array, headers?: ArenaCustomHeaders): ArenaLocation;
-    read(location: ArenaLocation): Uint8Array | null;
-    free(location: ArenaLocation): ArenaLocation;
-    private _checkForSpace;
-    private _resize;
-    size(): number;
-    getBuffer(): Uint8Array;
-    reserve(size: number): Uint8Array;
-    translate(ptr: ArenaLocation): {
-        start: number;
-        generation: bigint;
-    };
-    readWithHeaders(ptr: ArenaLocation): Uint8Array | null;
-    label(): Array<ArenaLocation>;
-    getHeaders(ptr: ArenaLocation): ArenaHeaders;
-    estimate(size: number, amnt: number): number;
-}

package/dist/arena.js

@@ -1,178 +0,0 @@
-var SHIFTOFFSETS;
-(function (SHIFTOFFSETS) {
-    SHIFTOFFSETS[SHIFTOFFSETS["BYTE_8"] = 0] = "BYTE_8";
-    SHIFTOFFSETS[SHIFTOFFSETS["BYTE_16"] = 1] = "BYTE_16";
-    SHIFTOFFSETS[SHIFTOFFSETS["BYTE_32"] = 2] = "BYTE_32";
-    SHIFTOFFSETS[SHIFTOFFSETS["BYTE_64"] = 3] = "BYTE_64";
-})(SHIFTOFFSETS || (SHIFTOFFSETS = {}));
-var HEADERS;
-(function (HEADERS) {
-    HEADERS[HEADERS["TOTAL_LENGTH_0_32"] = 0] = "TOTAL_LENGTH_0_32";
-    HEADERS[HEADERS["PAYLOAD_LENGTH_0_32"] = 1] = "PAYLOAD_LENGTH_0_32";
-    HEADERS[HEADERS["GENERATION_BYTE_0_32"] = 2] = "GENERATION_BYTE_0_32";
-    HEADERS[HEADERS["DELETED_8"] = 12] = "DELETED_8";
-    HEADERS[HEADERS["USER_STATUS_0_8"] = 13] = "USER_STATUS_0_8";
-    HEADERS[HEADERS["USER_STATUS_1_8"] = 14] = "USER_STATUS_1_8";
-    HEADERS[HEADERS["USER_STATUS_2_8"] = 15] = "USER_STATUS_2_8";
-})(HEADERS || (HEADERS = {}));
-export class Arena {
-    constructor(options) {
-        this.HEADER_SIZE_BYTES = 16;
-        this._buffer = new ArrayBuffer(options?.initalSize || 64 * 1024);
-        this._view8 = new Uint8Array(this._buffer);
-        this._view32 = new Uint32Array(this._buffer);
-        this._offset = 0;
-        //@ts-ignore
-        this._allignMask = ((options?.allignment || 8) - 1);
-        this._allignShift = Math.log2(this._allignMask + 1);
-        this._bucketCapacities = options?.bucketCapacities || [1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024];
-        this._bucketOffsets = [];
-        this._bucketcount = this._bucketCapacities.length;
-        let currentOffset = 0;
-        for (const cap of this._bucketCapacities) {
-            this._bucketOffsets.push(currentOffset);
-            currentOffset += (cap + 1);
-        }
-        this._emptySpots = new Uint32Array(currentOffset);
-    }
-    _getBucketCount(bucketIdx) {
-        return this._emptySpots[this._bucketOffsets[bucketIdx]];
-    }
-    _setBucketCount(bucketIdx, count) {
-        this._emptySpots[this._bucketOffsets[bucketIdx]] = count;
-    }
-    _getBucketOffset(bucketIdx, slotIdx) {
-        return this._emptySpots[this._bucketOffsets[bucketIdx] + slotIdx + 1];
-    }
-    _setBucketOffset(bucketIdx, slotIdx, offset) {
-        this._emptySpots[this._bucketOffsets[bucketIdx] + slotIdx + 1] = offset;
-    }
-    _initBlock(start, dataLength, { header0, header1, header2 }) {
-        const h0 = (header0 || 0) & 0xFF;
-        const h1 = (header1 || 0) & 0xFF;
-        const h2 = (header2 || 0) & 0xFF;
-        const shift32 = start >> SHIFTOFFSETS.BYTE_32;
-        this._view32[shift32 + HEADERS.TOTAL_LENGTH_0_32] = (dataLength + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask;
-        this._view32[shift32 + HEADERS.PAYLOAD_LENGTH_0_32] = dataLength;
-        this._view32[shift32 + (HEADERS.DELETED_8 >> SHIFTOFFSETS.BYTE_32)] = (h2 << 24) | (h1 << 16) | (h0 << 8) | 0;
-    }
-    alloc(data, headers) {
-        if (headers == undefined)
-            headers = { header0: 0, header1: 0, header2: 0 };
-        const totalBlockSize = (data.byteLength + this.HEADER_SIZE_BYTES + this._allignMask) & ~this._allignMask;
-        const bucketIdx = (totalBlockSize >> this._allignShift) - 1;
-        if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
-            const count = this._getBucketCount(bucketIdx);
-            if (count > 0) {
-                const recycledOffset = this._getBucketOffset(bucketIdx, count - 1);
-                this._setBucketCount(bucketIdx, count - 1);
-                this._initBlock(recycledOffset, data.length, headers);
-                return (BigInt(recycledOffset) << 32n | BigInt(this._view32[(recycledOffset >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32]));
-            }
-        }
-        const start = this._offset;
-        this._checkForSpace(data.byteLength + this.HEADER_SIZE_BYTES) && this._resize();
-        this._initBlock(start, data.byteLength, headers || {});
-        this._view8.set(data, start + this.HEADER_SIZE_BYTES);
-        this._offset = (data.byteLength + this.HEADER_SIZE_BYTES + this._offset + this._allignMask) & ~this._allignMask;
-        return (BigInt(start) << 32n | BigInt(this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32]));
-    }
-    read(location) {
-        let start = Number(BigInt(location) >> 32n);
-        const generation = BigInt(location) & 0xffffffffn;
-        let length = this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.PAYLOAD_LENGTH_0_32];
-        const diff = generation ^ BigInt(this._view32[((start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32)]);
-        if (diff !== 0n)
-            return null;
-        return this._view8.subarray(start + this.HEADER_SIZE_BYTES, start + this.HEADER_SIZE_BYTES + Number(length));
-    }
-    free(location) {
-        let start = Number(BigInt(location) >> 32n);
-        const currgen = this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32];
-        this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32] = currgen + 1; // this part can wrap around
-        this._view8[start + HEADERS.DELETED_8] = 1;
-        const totalBlockSize = this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.TOTAL_LENGTH_0_32];
-        const bucketIdx = (totalBlockSize >> this._allignShift) - 1;
-        if (bucketIdx >= 0 && bucketIdx < this._bucketcount) {
-            const count = this._getBucketCount(bucketIdx);
-            const capacity = this._bucketCapacities[bucketIdx];
-            if (count < capacity) {
-                this._setBucketOffset(bucketIdx, count, start);
-                this._setBucketCount(bucketIdx, count + 1);
-            }
-        }
-        return 0n;
-    }
-    _checkForSpace(size) {
-        if (this._buffer.byteLength >= this._offset + size)
-            return false;
-        return true;
-    }
-    _resize() {
-        //@ts-ignore
-        this._buffer = this._buffer.transfer(this._buffer.byteLength * 2);
-        this._view8 = new Uint8Array(this._buffer);
-        this._view32 = new Uint32Array(this._buffer);
-    }
-    size() {
-        return this._buffer.byteLength;
-    }
-    getBuffer() {
-        return this._view8.subarray(0, this._offset);
-    }
-    reserve(size) {
-        const start = this._offset;
-        this._checkForSpace(start + this.HEADER_SIZE_BYTES + size + this._allignMask & ~this._allignMask) && this._resize();
-        this._initBlock(start, size, {});
-        this._offset = this._offset + size + this.HEADER_SIZE_BYTES + this._allignMask & ~this._allignMask;
-        return this._view8.subarray(start + this.HEADER_SIZE_BYTES, start + this.HEADER_SIZE_BYTES + size);
-    }
-    translate(ptr) {
-        let start = Number(BigInt(ptr) >> 32n);
-        const generation = BigInt(this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32]);
-        return { start, generation };
-    }
-    readWithHeaders(ptr) {
-        let start = Number(BigInt(ptr) >> 32n);
-        const generation = BigInt(ptr) & 0xffffffffn;
-        let length = this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.PAYLOAD_LENGTH_0_32];
-        const diff = generation ^ BigInt(this._view32[((start >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32)]);
-        if (diff !== 0n)
-            return null;
-        return this._view8.subarray(start + 12, start + this.HEADER_SIZE_BYTES + Number(length));
-    }
-    label() {
-        const ptrArray = new Array();
-        const limit = this._offset;
-        let pos = 0;
-        while (pos < limit) {
-            const totalLength = this._view32[pos >> SHIFTOFFSETS.BYTE_32];
-            if (totalLength === 0) {
-                pos = (pos + 16) & ~15;
-                continue;
-            }
-            const isDeleted = this._view8[pos + HEADERS.DELETED_8] === 1;
-            if (!isDeleted) {
-                ptrArray.push(((BigInt(pos) << 32n) | BigInt(this._view32[(pos >> SHIFTOFFSETS.BYTE_32) + HEADERS.GENERATION_BYTE_0_32])));
-            }
-            pos += totalLength;
-            if (totalLength === 0)
-                break;
-        }
-        return ptrArray;
-    }
-    getHeaders(ptr) {
-        let start = Number(BigInt(ptr) >> 32n);
-        return {
-            totalLength: Number(this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.TOTAL_LENGTH_0_32].toString()),
-            payloadlength: Number(this._view32[(start >> SHIFTOFFSETS.BYTE_32) + HEADERS.PAYLOAD_LENGTH_0_32].toString()),
-            deleted: this._view8[start + HEADERS.DELETED_8] === 1,
-            header0: Number(this._view8[start + HEADERS.USER_STATUS_0_8].toString()),
-            header1: Number(this._view8[start + HEADERS.USER_STATUS_1_8].toString()),
-            header2: Number(this._view8[start + HEADERS.USER_STATUS_2_8].toString()),
-        };
-    }
-    estimate(size, amnt) {
-        return (((size + this._allignMask) & ~this._allignMask) + this.HEADER_SIZE_BYTES) * amnt;
-    }
-}

package/test/directAccess.ts

@@ -1,28 +0,0 @@
-import { Arena } from "../arena"
-
-export function TestDirectAlloc(): boolean {
-	//Init
-	const count = 255
-	const a = new Arena()
-	const testdata = new Array<Uint8Array>()
-	for (let i = 0; i < count; i++) {
-		const data = new Uint8Array([i, 1, 2, 3, 4, 5, 6, 7])
-		testdata.push(data)
-
-		a.directAlloc(data, 0, data.length)
-	}
-
-	const ptrs = a.label()
-	if (ptrs.length !== count) throw new Error(`Allocated wrong amount of items!: needed: ${count}, got: ${ptrs.length}`)
-
-	for (let i = 0; i < ptrs.length; i++) {
-		const buf = a.read(ptrs[i])
-		if (!buf) throw new Error(`data at index ${i} is Empty.`)
-
-		for (let j = 0; j < testdata.length; j++) {
-			if (buf[j] !== testdata[i][j]) throw new Error(`dataset ${i} at ${j} is broken!`)
-		}
-	}
-	return true
-}
-

package/test/ptrs.ts

@@ -1,37 +0,0 @@
-import { Arena } from "../arena"
-
-
-export function TestCheckPtrAccess(): boolean {
-	//Init
-	const a = new Arena()
-	const testdata = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7])
-	const headers = { header0: 42, header1: 24, header2: 240 };
-
-	// free Slot reuse
-	const ptr = a.alloc(testdata, headers)
-	const res = a.read(ptr)
-	if (res == null) throw new Error(`${testdata} Could not read data`)
-	const resultheaders = a.getHeaders(ptr)
-
-	if (resultheaders.totalLength !== testdata.byteLength + 16) throw new Error(`totalLength not right: got: ${resultheaders.totalLength} needed: ${testdata.byteLength}`)
-	if (resultheaders.payloadlength !== testdata.byteLength) throw new Error(`payloadLength not right: got: ${resultheaders.payloadlength} needed: ${testdata.byteLength}`)
-	if (resultheaders.header0 !== headers.header0) throw new Error(`header0: got: ${resultheaders.header0} needed: ${headers.header0}`)
-	if (resultheaders.header1 !== headers.header1) throw new Error(`header1: got: ${resultheaders.header1} needed: ${headers.header1}`)
-	if (resultheaders.header2 !== headers.header2) throw new Error(`header2: got: ${resultheaders.header2} needed: ${headers.header2}`)
-	if (res.toString() !== testdata.toString()) throw new Error(`${testdata} had a problem with data integrety`)
-
-	return true
-}
-export function TestUseAfterFree(): boolean {
-	//Init
-	const a = new Arena()
-	const testdata = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7])
-
-	// USE-AFTER-FREE init
-	const useAfterFreePtr = a.alloc(testdata)
-	a.free(useAfterFreePtr)
-	//final use after free with Generation this should never be possible
-	if (a.read(useAfterFreePtr) !== null) throw new Error(`Use after Free is Possible, this is a big Problem`)
-
-	return true
-}

package/test/reserve.ts

@@ -1,28 +0,0 @@
-import { Arena } from "../arena"
-
-
-export function TestCheckReserve(): boolean {
-	//Init
-	const count = 1_000
-	const a = new Arena()
-	const testdata = new Array<Uint8Array>()
-	for (let i = 0; i < count; i++) {
-		const data = new Uint8Array([i, 1, 2, 3, 4, 5, 6, 7])
-		testdata.push(data)
-
-		const buf = a.reserve(data.byteLength)
-		buf.set(data)
-	}
-
-	const ptrs = a.label()
-
-	for (let i = 0; i < ptrs.length; i++) {
-		const buf = a.read(ptrs[i])
-		if (!buf) throw new Error(`reservation failed at item: ${i}`)
-		for (let j = 0; j < ptrs.length; j++) {
-			if (buf[j] !== testdata[i][j]) throw new Error(`reservation failed at item ${i}:${j}`)
-		}
-	}
-
-	return true
-}

package/test/test.test.ts

@@ -1,12 +0,0 @@
-import { describe, test } from "node:test"
-import { equal } from "node:assert"
-import { TestCheckPtrAccess, TestUseAfterFree } from "./ptrs.ts"
-import { TestCheckReserve } from "./reserve.ts"
-import { TestDirectAlloc } from "./directAccess.ts"
-
-describe("Arena Checks", () => {
-	test("Pointer Access", () => equal(TestCheckPtrAccess(), true, "Data corruption is possible!"))
-	test("Use after free", () => equal(TestUseAfterFree(), true, "Use after free is possible!"))
-	test("Test Reserving Data", () => equal(TestCheckReserve(), true, "Something with the reservation is not working properly"))
-	test("Test allocating data directly", () => equal(TestDirectAlloc(), true, "Direct alloc isnt working properly"))
-})

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["ES2020"],
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowJs": true,
-    "verbatimModuleSyntax": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // für Build / .d.ts:
-    "declaration": true,
-    "emitDeclarationOnly": false,
-    "outDir": "dist"
-  },
-  "include": ["arena.ts"]
-}