binary-structures-values 0.1.0

package/dist/cjs/bit-stream-reader.d.ts

@@ -0,0 +1,33 @@
+export declare class BitStreamReader {
+    private byteArray;
+    protected bitPosition: number;
+    private currentDataSize;
+    private totalAvailableBits;
+    private isComplete;
+    private _shared_array_buffer;
+    private _shared_float_64_array;
+    private _shared_float_32_array;
+    private _shared_uint8_array;
+    private _shared_data_view;
+    constructor(initialData?: Uint8Array | Buffer<ArrayBuffer>, isComplete?: boolean);
+    private resizeIfNeeded;
+    markComplete(): void;
+    private recalculateTotalBits;
+    reset(): void;
+    addData(data: Uint8Array): void;
+    readBit(): boolean;
+    readBits(count: number): boolean[];
+    readByte(): number;
+    private readInt;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readBigInt(): bigint;
+    readFloat32(): number;
+    readFloat64(): number;
+    readString(): string;
+    canReadBits(size: number, throwIfNotEnough?: boolean): boolean;
+    canReadString(throwIfNotEnough?: boolean): boolean;
+    getAvailableBits(): number;
+    isDataComplete(): boolean;
+}

package/dist/cjs/bit-stream-reader.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitStreamReader = void 0;
+class BitStreamReader {
+    constructor(initialData, isComplete = false) {
+        this.bitPosition = 0;
+        this.currentDataSize = 0;
+        this.totalAvailableBits = 0;
+        this.isComplete = false;
+        this._shared_array_buffer = new ArrayBuffer(8);
+        this._shared_float_64_array = new Float64Array(this._shared_array_buffer);
+        this._shared_float_32_array = new Float32Array(this._shared_array_buffer);
+        this._shared_uint8_array = new Uint8Array(this._shared_array_buffer);
+        this._shared_data_view = new DataView(this._shared_array_buffer);
+        this.byteArray = new Uint8Array(0);
+        this.isComplete = isComplete;
+        if (initialData)
+            this.addData(initialData);
+    }
+    resizeIfNeeded(needed) {
+        if (this.currentDataSize + needed > this.byteArray.length) {
+            const newLength = Math.max(this.byteArray.length << 1, this.currentDataSize + needed);
+            const newArray = new Uint8Array(newLength);
+            newArray.set(this.byteArray.subarray(0, this.currentDataSize));
+            this.byteArray = newArray;
+        }
+    }
+    markComplete() {
+        this.isComplete = true;
+        this.recalculateTotalBits();
+    }
+    recalculateTotalBits() {
+        if (this.currentDataSize === 0) {
+            this.totalAvailableBits = 0;
+            return;
+        }
+        if (this.isComplete) {
+            const paddingByte = this.byteArray[this.currentDataSize - 1];
+            this.totalAvailableBits = ((this.currentDataSize - 1) << 3) - paddingByte;
+        }
+        else {
+            const safeBytesCount = Math.max(0, this.currentDataSize - 2);
+            this.totalAvailableBits = safeBytesCount << 3;
+        }
+    }
+    reset() {
+        this.bitPosition = 0;
+    }
+    addData(data) {
+        this.resizeIfNeeded(data.length);
+        this.byteArray.set(data, this.currentDataSize);
+        this.currentDataSize += data.length;
+        this.recalculateTotalBits();
+    }
+    readBit() {
+        if (!this.isComplete) {
+            if (this.bitPosition >= this.totalAvailableBits) {
+                throw new Error(`Cannot read 1 bits at position ${this.bitPosition}, not enough bits available`);
+            }
+        }
+        const byteIndex = this.bitPosition >>> 3;
+        const bitIndex = 7 - (this.bitPosition & 7);
+        const bit = (this.byteArray[byteIndex] >> bitIndex) & 1;
+        this.bitPosition++;
+        return bit === 1;
+    }
+    readBits(count) {
+        if (!this.isComplete) {
+            if (this.bitPosition + count > this.totalAvailableBits) {
+                throw new Error(`Cannot read ${count} bits at position ${this.bitPosition}, not enough bits available`);
+            }
+        }
+        const bits = new Array(count);
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        for (let i = 0; i < count; i++) {
+            const byteIndex = pos >>> 3;
+            const bitIndex = 7 - (pos & 7);
+            bits[i] = ((data[byteIndex] >> bitIndex) & 1) === 1;
+            pos++;
+        }
+        this.bitPosition = pos;
+        return bits;
+    }
+    readByte() {
+        if (!this.isComplete) {
+            if (this.bitPosition + 8 > this.totalAvailableBits) {
+                throw new Error(`Cannot read 8 bits at position ${this.bitPosition}, not enough bits available`);
+            }
+        }
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        let value = 0;
+        for (let i = 7; i >= 0; i--) {
+            const byteIndex = pos >>> 3;
+            const bitIndex = 7 - (pos & 7);
+            const bit = (data[byteIndex] >> bitIndex) & 1;
+            if (bit)
+                value |= (1 << i);
+            pos++;
+        }
+        this.bitPosition = pos;
+        return value;
+    }
+    readInt(bytes) {
+        const totalBits = bytes << 3;
+        if (!this.isComplete) {
+            if (this.bitPosition + totalBits > this.totalAvailableBits) {
+                throw new Error(`Cannot read ${totalBits} bits at position ${this.bitPosition}, not enough bits available`);
+            }
+        }
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        let value = 0n;
+        if (bitOffset === 0) {
+            // Byte-aligned: fastest path
+            for (let i = 0; i < bytes; i++) {
+                value = (value << 8n) | BigInt(data[byteIndex + i]);
+            }
+        }
+        else {
+            // Bit-unaligned: optimized bit extraction
+            const shift = 8 - bitOffset;
+            for (let i = 0; i < bytes; i++) {
+                const byte = (data[byteIndex + i] << bitOffset) | (data[byteIndex + i + 1] >> shift);
+                value = (value << 8n) | BigInt(byte & 0xFF);
+            }
+        }
+        this.bitPosition = pos + totalBits;
+        return value;
+    }
+    // Specialized versions for common sizes (even faster)
+    readInt8() {
+        if (!this.isComplete) {
+            if (this.bitPosition + 8 > this.totalAvailableBits) {
+                throw new Error(`Cannot read 8 bits at position ${this.bitPosition}, not enough bits available`);
+            }
+        }
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        let value;
+        if (bitOffset === 0) {
+            value = data[byteIndex];
+        }
+        else {
+            const shift = 8 - bitOffset;
+            value = ((data[byteIndex] << bitOffset) | (data[byteIndex + 1] >> shift)) & 0xFF;
+        }
+        this.bitPosition = pos + 8;
+        return (value << 24) >> 24;
+    }
+    readInt16() {
+        if (!this.isComplete) {
+            if (this.bitPosition + 16 > this.totalAvailableBits) {
+                throw new Error(`Cannot read 16 bits at position ${this.bitPosition}, not enough bits available`);
+            }
+        }
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        let value;
+        if (bitOffset === 0) {
+            value = (data[byteIndex] << 8) | data[byteIndex + 1];
+        }
+        else {
+            const shift = 8 - bitOffset;
+            const byte0 = ((data[byteIndex] << bitOffset) | (data[byteIndex + 1] >> shift)) & 0xFF;
+            const byte1 = ((data[byteIndex + 1] << bitOffset) | (data[byteIndex + 2] >> shift)) & 0xFF;
+            value = (byte0 << 8) | byte1;
+        }
+        this.bitPosition = pos + 16;
+        return (value << 16) >> 16;
+    }
+    readInt32() {
+        if (!this.isComplete) {
+            if (this.bitPosition + 32 > this.totalAvailableBits) {
+                throw new Error(`Cannot read 32 bits at position ${this.bitPosition}, not enough bits available`);
+            }
+        }
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        let value;
+        if (bitOffset === 0) {
+            value = (data[byteIndex] << 24) | (data[byteIndex + 1] << 16) |
+                (data[byteIndex + 2] << 8) | data[byteIndex + 3];
+        }
+        else {
+            const shift = 8 - bitOffset;
+            const byte0 = ((data[byteIndex] << bitOffset) | (data[byteIndex + 1] >> shift)) & 0xFF;
+            const byte1 = ((data[byteIndex + 1] << bitOffset) | (data[byteIndex + 2] >> shift)) & 0xFF;
+            const byte2 = ((data[byteIndex + 2] << bitOffset) | (data[byteIndex + 3] >> shift)) & 0xFF;
+            const byte3 = ((data[byteIndex + 3] << bitOffset) | (data[byteIndex + 4] >> shift)) & 0xFF;
+            value = (byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3;
+        }
+        this.bitPosition = pos + 32;
+        return value;
+    }
+    readBigInt() {
+        let result = 0n;
+        let shift = 0n;
+        let currentBitPos = this.bitPosition;
+        let byte;
+        do {
+            const byteIndex = currentBitPos >> 3;
+            const bitOffset = currentBitPos & 7;
+            if (bitOffset === 0) {
+                byte = this.byteArray[byteIndex];
+            }
+            else {
+                const shift_amount = 8 - bitOffset;
+                const mask = 0xFF >> bitOffset;
+                const part1 = (this.byteArray[byteIndex] & mask) << bitOffset;
+                const part2 = this.byteArray[byteIndex + 1] >> shift_amount;
+                byte = part1 | part2;
+            }
+            result |= BigInt(byte & 0x7F) << shift;
+            shift += 7n;
+            currentBitPos += 8;
+        } while ((byte & 0x80) !== 0);
+        this.bitPosition = currentBitPos;
+        return (result & 1n) === 0n ? result >> 1n : -((result + 1n) >> 1n);
+    }
+    readFloat32() {
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        if (bitOffset === 0) {
+            // Byte-aligned: fastest path
+            this._shared_uint8_array[0] = data[byteIndex];
+            this._shared_uint8_array[1] = data[byteIndex + 1];
+            this._shared_uint8_array[2] = data[byteIndex + 2];
+            this._shared_uint8_array[3] = data[byteIndex + 3];
+        }
+        else {
+            // Bit-unaligned: optimized bit extraction
+            const shift = 8 - bitOffset;
+            this._shared_uint8_array[0] = (data[byteIndex] << bitOffset) | (data[byteIndex + 1] >> shift);
+            this._shared_uint8_array[1] = (data[byteIndex + 1] << bitOffset) | (data[byteIndex + 2] >> shift);
+            this._shared_uint8_array[2] = (data[byteIndex + 2] << bitOffset) | (data[byteIndex + 3] >> shift);
+            this._shared_uint8_array[3] = (data[byteIndex + 3] << bitOffset) | (data[byteIndex + 4] >> shift);
+        }
+        this.bitPosition = pos + 32;
+        return this._shared_float_32_array[0];
+    }
+    // readFloat32(): number {
+    //     const uint32 = Number(this.readInt(4));
+    //     const buffer = new ArrayBuffer(4);
+    //     const view = new DataView(buffer);
+    //     view.setUint32(0, uint32, true);
+    //     return view.getFloat32(0, true);
+    // }
+    readFloat64() {
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        if (bitOffset === 0) {
+            // Byte-aligned: fastest path
+            this._shared_uint8_array[0] = data[byteIndex];
+            this._shared_uint8_array[1] = data[byteIndex + 1];
+            this._shared_uint8_array[2] = data[byteIndex + 2];
+            this._shared_uint8_array[3] = data[byteIndex + 3];
+            this._shared_uint8_array[4] = data[byteIndex + 4];
+            this._shared_uint8_array[5] = data[byteIndex + 5];
+            this._shared_uint8_array[6] = data[byteIndex + 6];
+            this._shared_uint8_array[7] = data[byteIndex + 7];
+        }
+        else {
+            // Bit-unaligned: optimized bit extraction
+            const shift = 8 - bitOffset;
+            this._shared_uint8_array[0] = (data[byteIndex] << bitOffset) | (data[byteIndex + 1] >> shift);
+            this._shared_uint8_array[1] = (data[byteIndex + 1] << bitOffset) | (data[byteIndex + 2] >> shift);
+            this._shared_uint8_array[2] = (data[byteIndex + 2] << bitOffset) | (data[byteIndex + 3] >> shift);
+            this._shared_uint8_array[3] = (data[byteIndex + 3] << bitOffset) | (data[byteIndex + 4] >> shift);
+            this._shared_uint8_array[4] = (data[byteIndex + 4] << bitOffset) | (data[byteIndex + 5] >> shift);
+            this._shared_uint8_array[5] = (data[byteIndex + 5] << bitOffset) | (data[byteIndex + 6] >> shift);
+            this._shared_uint8_array[6] = (data[byteIndex + 6] << bitOffset) | (data[byteIndex + 7] >> shift);
+            this._shared_uint8_array[7] = (data[byteIndex + 7] << bitOffset) | (data[byteIndex + 8] >> shift);
+        }
+        this.bitPosition = pos + 64;
+        return this._shared_float_64_array[0];
+    }
+    readString() {
+        const bytes = [];
+        while (true) {
+            const byte = this.readByte();
+            if (byte === 0)
+                break;
+            bytes.push(byte);
+        }
+        return new TextDecoder().decode(new Uint8Array(bytes));
+    }
+    canReadBits(size, throwIfNotEnough = false) {
+        const enough = (this.bitPosition + size) <= this.totalAvailableBits;
+        if (!enough && throwIfNotEnough) {
+            throw new Error(`Cannot read ${size} bits at position ${this.bitPosition}, not enough bits available`);
+        }
+        return enough;
+    }
+    canReadString(throwIfNotEnough = false) {
+        let tempPos = this.bitPosition;
+        while (true) {
+            if (tempPos + 8 > this.totalAvailableBits) {
+                if (throwIfNotEnough) {
+                    throw new Error(`Cannot read string at position ${this.bitPosition}, not enough bits available`);
+                }
+                return false;
+            }
+            let isZero = true;
+            for (let i = 0; i < 8; i++) {
+                const byteIndex = tempPos >>> 3;
+                const bitIndex = 7 - (tempPos & 7);
+                const bit = (this.byteArray[byteIndex] >> bitIndex) & 1;
+                if (bit === 1) {
+                    isZero = false;
+                    tempPos += 8 - i;
+                    break;
+                }
+                tempPos++;
+            }
+            if (isZero)
+                return true;
+        }
+    }
+    getAvailableBits() {
+        return this.totalAvailableBits - this.bitPosition;
+    }
+    isDataComplete() {
+        return this.isComplete;
+    }
+}
+exports.BitStreamReader = BitStreamReader;

package/dist/cjs/bit-stream-writer.d.ts

@@ -0,0 +1,36 @@
+export declare class BitStreamWriter {
+    private deletePreviousDataOnGetFixedBytes;
+    private bufferByte;
+    private bufferSize;
+    private byteArray;
+    private bitPosition;
+    private nextFixedBytePosition;
+    private guaranteedCapacity;
+    private static textEncoder;
+    private _shared_array_buffer;
+    private _shared_float_64_array;
+    private _shared_float_32_array;
+    private _shared_uint8_array;
+    private _shared_data_view;
+    constructor(deletePreviousDataOnGetFixedBytes?: boolean);
+    clear(): void;
+    ensureCapacity(newBits: number): void;
+    writeBit(bit: 0 | 1): void;
+    writeBits(bits: (0 | 1)[]): void;
+    private writeIntBytes;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeBigInt(value: bigint): void;
+    dumpBytes(label: string, bytes: Uint8Array): void;
+    writeFloat32(value: number): void;
+    writeFloat64(value: number): void;
+    writeString(value: string, end?: number): void;
+    removeBits(count: number): void;
+    getBytes(): Uint8Array<ArrayBuffer>;
+    getNextFixedBytes(): Uint8Array<ArrayBufferLike>;
+    getRemainingBytesAfterFixed(): Uint8Array<ArrayBuffer>;
+    getNextFixedBuffer(): Buffer<ArrayBuffer>;
+    getRemainingBufferAfterFixed(): Buffer<ArrayBuffer>;
+    getBuffer(): Buffer<ArrayBuffer>;
+}