binary-structures-values 0.1.0

package/dist/cjs/schema-structure.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeSchemaString = exports.encodeSchema = exports.createSchema = void 0;
+const createSchema = (schema) => {
+    return schema;
+};
+exports.createSchema = createSchema;
+// OPTIMIZATION 4: Improved Base62 with fast path
+const BASE62_CHARS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const encodeBase62 = (n) => {
+    if (n < 0)
+        throw new Error('Cannot encode negative numbers');
+    if (n < 62)
+        return BASE62_CHARS[n]; // Fast path for single digit
+    const digits = [];
+    while (n > 0) {
+        digits.push(BASE62_CHARS[n % 62]);
+        n = Math.floor(n / 62);
+    }
+    return digits.reverse().join('');
+};
+const decodeBase62 = (str) => {
+    let result = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const value = BASE62_CHARS.indexOf(char);
+        if (value === -1)
+            throw new Error(`Invalid base62 character: ${char}`);
+        result = result * 62 + value;
+    }
+    return result;
+};
+// OPTIMIZATION 2: Map-based lookups for O(1) complexity
+const encodeSingleType = (type, key, keyMap, typeMap) => {
+    // Use Map for O(1) lookup instead of indexOf O(n)
+    let typeIndex = typeMap.get(type.type);
+    if (typeIndex === undefined) {
+        typeIndex = typeMap.size;
+        typeMap.set(type.type, typeIndex);
+    }
+    const typeIndexEncoded = encodeBase62(typeIndex);
+    // if (type.type === 'null') return typeIndexEncoded
+    if (type.type === 'object') {
+        const [keys, types] = encodeObjectSchema(type.items, keyMap, typeMap);
+        let typeStr = `{${types}}`;
+        if ('optional' in type && type.optional) {
+            typeStr += `?`;
+        }
+        return [`{${keys}}`, typeStr];
+    }
+    if (type.type === 'array') {
+        const [keys, types] = encodeDataType(type.items, key, keyMap, typeMap);
+        let typeStr = `[${types}]`;
+        if ('optional' in type && type.optional) {
+            typeStr += `?`;
+        }
+        return [`[${keys}]`, typeStr];
+    }
+    if (!('optional' in type))
+        return typeIndexEncoded;
+    return `${typeIndexEncoded}${type.optional ? `?${type.default !== undefined ? `${JSON.stringify(type.default)}` : ''}` : ''}`;
+};
+const encodeDataType = (datatype, key, keyMap, typeMap) => {
+    let keys = [];
+    let types = [];
+    if ("types" in datatype) {
+        const midTypes = [];
+        const midKeys = [];
+        let isFirst = true;
+        for (let valueType of datatype.types) {
+            if (typeof valueType === 'string')
+                valueType = { type: valueType };
+            if ("optional" in valueType && valueType.optional && !isFirst)
+                throw new Error(`Only first type can be optional for multi-type`);
+            isFirst = false;
+            const returnValue = encodeSingleType(valueType, key, keyMap, typeMap);
+            if (typeof returnValue === 'string') {
+                midTypes.push(returnValue);
+                midKeys.push(key);
+                continue;
+            }
+            const [vKey, vType] = returnValue;
+            midKeys.push(`${key}${vKey}`);
+            midTypes.push(`${vType}`);
+        }
+        types.push(midTypes.join('|'));
+        keys.push(midKeys.join('|'));
+    }
+    else {
+        const returnValue = encodeSingleType(datatype, key, keyMap, typeMap);
+        if (typeof returnValue === 'string') {
+            keys.push(key);
+            types.push(encodeSingleType(datatype, key, keyMap, typeMap));
+        }
+        else {
+            const [vKey, vType] = returnValue;
+            keys.push(`${key}${vKey}`);
+            types.push(`${vType}`);
+        }
+    }
+    return [keys, types];
+};
+// OPTIMIZATION 2 & 5: Map-based lookups + pre-sorted keys
+const encodeObjectSchema = (schema, keyMap, typeMap) => {
+    let keys = [];
+    let types = [];
+    // OPTIMIZATION 5: Pre-sort keys once (avoid Object.entries tuple allocation)
+    const sortedKeys = Object.keys(schema).sort();
+    for (const key of sortedKeys) {
+        const value = schema[key];
+        // OPTIMIZATION 2: Use Map for O(1) lookup instead of indexOf O(n)
+        let keyIndex = keyMap.get(key);
+        if (keyIndex === undefined) {
+            keyIndex = keyMap.size;
+            keyMap.set(key, keyIndex);
+        }
+        const keyIndexEncoded = encodeBase62(keyIndex);
+        const [k, t] = encodeDataType(value, keyIndexEncoded, keyMap, typeMap);
+        keys.push(...k);
+        types.push(...t);
+    }
+    return [keys.join(','), types.join(',')];
+};
+const encodeSchema = (schema) => {
+    const keyMap = new Map();
+    const typeMap = new Map();
+    const [keys, types] = encodeObjectSchema(schema, keyMap, typeMap);
+    const keyList = Array.from(keyMap.entries()).sort((a, b) => a[1] - b[1]).map(([k]) => k);
+    const typeList = Array.from(typeMap.entries()).sort((a, b) => a[1] - b[1]).map(([k]) => k);
+    return `${keyList.join(',')}\n${typeList.join(',')}\n${keys}\n${types}`;
+};
+exports.encodeSchema = encodeSchema;
+const decodeObjectSchemaFromStrings = (keyList, typeList, keysEncoded, typesEncoded) => {
+    const keyTokens = splitTopLevel(keysEncoded, ',');
+    const typeTokens = splitTopLevel(typesEncoded, ',');
+    if (keyTokens.length !== typeTokens.length) {
+        throw new Error('Invalid schema string: keys/types length mismatch');
+    }
+    const out = {};
+    for (let i = 0; i < keyTokens.length; i++) {
+        const keyToken = keyTokens[i];
+        const typeToken = typeTokens[i];
+        const [keyIndex] = parseLeadingBase62(keyToken);
+        const keyName = keyList[keyIndex];
+        if (keyName === undefined)
+            throw new Error(`Invalid schema string: unknown key index ${keyIndex}`);
+        out[keyName] = decodeDataTypeFromTokens(keyList, typeList, keyToken, typeToken);
+    }
+    return out;
+};
+const splitTopLevel = (input, separator) => {
+    if (!input)
+        return [];
+    const parts = [];
+    let start = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === '{')
+            braceDepth++;
+        else if (ch === '}')
+            braceDepth--;
+        else if (ch === '[')
+            bracketDepth++;
+        else if (ch === ']')
+            bracketDepth--;
+        if (braceDepth === 0 && bracketDepth === 0 && ch === separator) {
+            parts.push(input.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(input.slice(start));
+    return parts;
+};
+const parseLeadingBase62 = (input) => {
+    let i = 0;
+    while (i < input.length && BASE62_CHARS.indexOf(input[i]) !== -1) {
+        i++;
+    }
+    if (i === 0)
+        throw new Error(`Invalid schema token: expected leading index, got: ${input}`);
+    const encoded = input.slice(0, i);
+    return [decodeBase62(encoded), i];
+};
+const stripWrapper = (input, open, close) => {
+    if (!input.startsWith(open) || !input.endsWith(close)) {
+        throw new Error(`Invalid schema token: expected ${open}...${close}, got: ${input}`);
+    }
+    return input.slice(1, -1);
+};
+const decodeDataTypeFromTokens = (keyList, typeList, keyToken, typeToken) => {
+    const typeParts = splitTopLevel(typeToken, '|');
+    if (typeParts.length > 1) {
+        const keyParts = splitTopLevel(keyToken, '|');
+        if (keyParts.length !== typeParts.length) {
+            throw new Error('Invalid schema string: multi-type keys/types length mismatch');
+        }
+        return {
+            types: typeParts.map((t, idx) => decodeSingleTypeFromTokens(keyList, typeList, keyParts[idx], t))
+        };
+    }
+    return decodeSingleTypeFromTokens(keyList, typeList, keyToken, typeToken);
+};
+const decodeSingleTypeFromTokens = (keyList, typeList, keyToken, typeToken) => {
+    if (typeToken.startsWith('{')) {
+        const braceEnd = typeToken.lastIndexOf('}');
+        if (braceEnd === -1)
+            throw new Error(`Invalid schema token: expected } in ${typeToken}`);
+        const [keyIndex, keyIndexLen] = parseLeadingBase62(keyToken);
+        const innerKeys = stripWrapper(keyToken.slice(keyIndexLen), '{', '}');
+        const innerTypes = typeToken.slice(1, braceEnd);
+        let out = {
+            type: 'object',
+            items: decodeObjectSchemaFromStrings(keyList, typeList, innerKeys, innerTypes)
+        };
+        const optionalPart = typeToken.slice(braceEnd + 1);
+        if (optionalPart.startsWith('?')) {
+            out.optional = true;
+        }
+        return out;
+    }
+    if (typeToken.startsWith('[')) {
+        const bracketEnd = typeToken.lastIndexOf(']');
+        if (bracketEnd === -1)
+            throw new Error(`Invalid schema token: expected ] in ${typeToken}`);
+        const [keyIndex, keyIndexLen] = parseLeadingBase62(keyToken);
+        const keySuffix = keyToken.slice(keyIndexLen);
+        const innerKeys = stripWrapper(keySuffix, '[', ']');
+        const innerTypes = typeToken.slice(1, bracketEnd);
+        const innerKeyTokens = splitTopLevel(innerKeys, ',');
+        const innerTypeTokens = splitTopLevel(innerTypes, ',');
+        if (innerKeyTokens.length !== 1 || innerTypeTokens.length !== 1) {
+            throw new Error('Invalid schema string: array item encoding malformed');
+        }
+        let out = {
+            type: 'array',
+            items: decodeDataTypeFromTokens(keyList, typeList, innerKeyTokens[0], innerTypeTokens[0])
+        };
+        const optionalPart = typeToken.slice(bracketEnd + 1);
+        if (optionalPart.startsWith('?')) {
+            out.optional = true;
+        }
+        return out;
+    }
+    const [typeIndexRaw, optionalRaw] = typeToken.split('?', 2);
+    const typeIndex = decodeBase62(typeIndexRaw);
+    const resolvedType = typeList[typeIndex];
+    if (!resolvedType)
+        throw new Error(`Invalid schema string: unknown type index ${typeIndex}`);
+    if (optionalRaw === undefined)
+        return { type: resolvedType };
+    const out = { type: resolvedType, optional: true };
+    if (optionalRaw.length)
+        out.default = JSON.parse(optionalRaw);
+    return out;
+};
+const decodeSchemaString = (schemaString) => {
+    const lines = schemaString.split(/\r?\n/);
+    if (lines.length < 4 || lines.length > 5)
+        throw new Error('Invalid schema string: expected 4 or 5 lines');
+    let metadata = '';
+    if (lines.length === 5) {
+        metadata = lines.shift();
+    }
+    const keyList = lines[0].length ? lines[0].split(',') : [];
+    const typeList = lines[1].length ? lines[1].split(',') : [];
+    const keysEncoded = lines[2] ?? '';
+    const typesEncoded = lines[3] ?? '';
+    const schema = decodeObjectSchemaFromStrings(keyList, typeList, keysEncoded, typesEncoded);
+    return [schema, metadata];
+};
+exports.decodeSchemaString = decodeSchemaString;

package/dist/esm/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/esm/bit-stream-reader.js

@@ -0,0 +1,336 @@
+export class BitStreamReader {
+    bitPosition = 0;
+    currentDataSize = 0;
+    totalAvailableBits = 0;
+    isComplete = false;
+    _shared_array_buffer = new ArrayBuffer(8);
+    _shared_float_64_array = new Float64Array(this._shared_array_buffer);
+    _shared_float_32_array = new Float32Array(this._shared_array_buffer);
+    _shared_uint8_array = new Uint8Array(this._shared_array_buffer);
+    _shared_data_view = new DataView(this._shared_array_buffer);
+    constructor(initialData, isComplete = false) {
+        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;
+    }
+}

package/dist/esm/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>;
+}