binary-structures-values 0.1.0

package/dist/esm/bit-stream-writer.js

@@ -0,0 +1,335 @@
+export class BitStreamWriter {
+    deletePreviousDataOnGetFixedBytes;
+    bufferByte = 0; // Accumulate 32 bits
+    bufferSize = 0;
+    byteArray;
+    bitPosition = 0;
+    nextFixedBytePosition = 0;
+    guaranteedCapacity;
+    static textEncoder = new TextEncoder();
+    _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(deletePreviousDataOnGetFixedBytes = true) {
+        this.deletePreviousDataOnGetFixedBytes = deletePreviousDataOnGetFixedBytes;
+        const bytes = 1024;
+        this.byteArray = new Uint8Array(bytes);
+        this.guaranteedCapacity = bytes * 8;
+    }
+    clear() {
+        const bytes = 1024;
+        this.byteArray = new Uint8Array(bytes);
+        this.bitPosition = 0;
+        this.guaranteedCapacity = bytes * 8;
+    }
+    ensureCapacity(newBits) {
+        const needed = this.bitPosition + newBits;
+        if (needed <= this.guaranteedCapacity)
+            return;
+        const requiredBytes = Math.ceil(needed / 8);
+        const newBuffer = new Uint8Array(requiredBytes * 2);
+        newBuffer.set(this.byteArray);
+        this.byteArray = newBuffer;
+        this.guaranteedCapacity = requiredBytes * 16;
+    }
+    writeBit(bit) {
+        if (this.bitPosition >= this.guaranteedCapacity) {
+            this.ensureCapacity(1);
+        }
+        const byteIndex = this.bitPosition >>> 3;
+        const bitIndex = 7 - (this.bitPosition & 7);
+        this.byteArray[byteIndex] |= bit << bitIndex;
+        this.bitPosition++;
+    }
+    // INCOMPLETE: write with buffer, need to implement for all individual write functions
+    // private writeBitFast(bit: 0 | 1) {
+    //     this.bufferByte = (this.bufferByte << 1) | (bit ? 1 : 0);
+    //     this.bufferSize++;
+    //
+    //     if (this.bufferSize === 8) {  // Flush every 8 bits (1 byte)
+    //         this.bitPosition += 8;
+    //         if (this.bitPosition >= this.guaranteedCapacity) {
+    //             this.ensureCapacity(8);
+    //         }
+    //         const byteIndex = this.bitPosition >>> 3;
+    //         this.byteArray[byteIndex] = this.bufferByte & 0xFF;
+    //         this.bufferByte = 0;
+    //         this.bufferSize = 0;
+    //     }
+    // }
+    writeBits(bits) {
+        const len = bits.length;
+        this.ensureCapacity(len);
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        for (let i = 0; i < len; i++) {
+            const byteIndex = pos >>> 3;
+            const bitIndex = 7 - (pos & 7);
+            data[byteIndex] |= (bits[i] ? 1 : 0) << bitIndex;
+            pos++;
+        }
+        this.bitPosition = pos;
+    }
+    // // dynamic sized int
+    // writeInt(value: number | bigint) {
+    //
+    // }
+    writeIntBytes(value, bytes) {
+        this.ensureCapacity(bytes * 8);
+        const val = typeof value === 'bigint' ? value : BigInt(Math.floor(value));
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        // Extract bytes from BigInt (MSB first to match original bit order)
+        const byteValues = new Uint8Array(bytes);
+        for (let i = 0; i < bytes; i++) {
+            byteValues[i] = Number((val >> BigInt((bytes - 1 - i) * 8)) & 0xffn);
+        }
+        if (bitOffset === 0) {
+            // Byte-aligned: fastest path
+            for (let i = 0; i < bytes; i++) {
+                data[byteIndex + i] = byteValues[i];
+            }
+        }
+        else {
+            // Bit-unaligned: optimized bit insertion
+            const shift = 8 - bitOffset;
+            const mask = 0xFF >> bitOffset;
+            // First byte (partial)
+            data[byteIndex] = (data[byteIndex] & ~mask) | ((byteValues[0] >> bitOffset) & mask);
+            // Middle bytes
+            for (let i = 1; i < bytes; i++) {
+                data[byteIndex + i] = (byteValues[i - 1] << shift) | ((byteValues[i] >> bitOffset) & mask);
+            }
+            // Last byte (partial)
+            data[byteIndex + bytes] = (data[byteIndex + bytes] & (0xFF << shift)) | (byteValues[bytes - 1] << shift);
+        }
+        this.bitPosition = pos + (bytes * 8);
+    }
+    // Specialized versions for common sizes (even faster)
+    writeInt8(value) {
+        this.ensureCapacity(8);
+        const val = Math.floor(value) & 0xFF;
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        if (bitOffset === 0) {
+            data[byteIndex] = val;
+        }
+        else {
+            const shift = 8 - bitOffset;
+            const mask = 0xFF >> bitOffset;
+            data[byteIndex] = (data[byteIndex] & ~mask) | ((val >> bitOffset) & mask);
+            data[byteIndex + 1] = (data[byteIndex + 1] & (0xFF << shift)) | (val << shift);
+        }
+        this.bitPosition = pos + 8;
+    }
+    writeInt16(value) {
+        this.ensureCapacity(16);
+        const val = Math.floor(value) & 0xFFFF;
+        const byte0 = (val >> 8) & 0xFF;
+        const byte1 = val & 0xFF;
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        if (bitOffset === 0) {
+            data[byteIndex] = byte0;
+            data[byteIndex + 1] = byte1;
+        }
+        else {
+            const shift = 8 - bitOffset;
+            const mask = 0xFF >> bitOffset;
+            data[byteIndex] = (data[byteIndex] & ~mask) | ((byte0 >> bitOffset) & mask);
+            data[byteIndex + 1] = (byte0 << shift) | ((byte1 >> bitOffset) & mask);
+            data[byteIndex + 2] = (data[byteIndex + 2] & (0xFF << shift)) | (byte1 << shift);
+        }
+        this.bitPosition = pos + 16;
+    }
+    writeInt32(value) {
+        this.ensureCapacity(32);
+        const val = Math.floor(value);
+        const byte0 = (val >>> 24) & 0xFF;
+        const byte1 = (val >>> 16) & 0xFF;
+        const byte2 = (val >>> 8) & 0xFF;
+        const byte3 = val & 0xFF;
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        if (bitOffset === 0) {
+            data[byteIndex] = byte0;
+            data[byteIndex + 1] = byte1;
+            data[byteIndex + 2] = byte2;
+            data[byteIndex + 3] = byte3;
+        }
+        else {
+            const shift = 8 - bitOffset;
+            const mask = 0xFF >> bitOffset;
+            data[byteIndex] = (data[byteIndex] & ~mask) | ((byte0 >> bitOffset) & mask);
+            data[byteIndex + 1] = (byte0 << shift) | ((byte1 >> bitOffset) & mask);
+            data[byteIndex + 2] = (byte1 << shift) | ((byte2 >> bitOffset) & mask);
+            data[byteIndex + 3] = (byte2 << shift) | ((byte3 >> bitOffset) & mask);
+            data[byteIndex + 4] = (data[byteIndex + 4] & (0xFF << shift)) | (byte3 << shift);
+        }
+        this.bitPosition = pos + 32;
+    }
+    writeBigInt(value) {
+        const encoded = value >= 0n ? value << 1n : ((-value) << 1n) - 1n;
+        let temp = encoded;
+        let bytesNeeded = 0;
+        do {
+            bytesNeeded++;
+            temp >>= 7n;
+        } while (temp !== 0n);
+        this.ensureCapacity(bytesNeeded * 8);
+        let val = encoded;
+        let currentBitPos = this.bitPosition;
+        do {
+            let byte = Number(val & 0x7fn);
+            val >>= 7n;
+            if (val !== 0n)
+                byte |= 0x80;
+            const byteIndex = currentBitPos >> 3;
+            const bitOffset = currentBitPos & 7;
+            if (bitOffset === 0) {
+                this.byteArray[byteIndex] = byte;
+            }
+            else {
+                const shift = 8 - bitOffset;
+                const mask = 0xFF >> bitOffset;
+                this.byteArray[byteIndex] = (this.byteArray[byteIndex] & ~mask) | ((byte >> bitOffset) & mask);
+                this.byteArray[byteIndex + 1] = (this.byteArray[byteIndex + 1] & (0xFF << shift)) | (byte << shift);
+            }
+            currentBitPos += 8;
+        } while (val !== 0n);
+        this.bitPosition = currentBitPos;
+    }
+    dumpBytes(label, bytes) {
+        console.log(label, Array.from(bytes).map(b => b.toString(2).padStart(8, '0')).join(' '));
+    }
+    writeFloat32(value) {
+        this.ensureCapacity(32);
+        this._shared_float_32_array[0] = value;
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        if (bitOffset === 0) {
+            // Byte-aligned: fastest path
+            data[byteIndex] = this._shared_uint8_array[0];
+            data[byteIndex + 1] = this._shared_uint8_array[1];
+            data[byteIndex + 2] = this._shared_uint8_array[2];
+            data[byteIndex + 3] = this._shared_uint8_array[3];
+        }
+        else {
+            // Bit-unaligned: optimized bit insertion
+            const shift = 8 - bitOffset;
+            const mask = 0xFF >> bitOffset;
+            data[byteIndex] = (data[byteIndex] & ~mask) | ((this._shared_uint8_array[0] >> bitOffset) & mask);
+            data[byteIndex + 1] = (this._shared_uint8_array[0] << shift) | ((this._shared_uint8_array[1] >> bitOffset) & mask);
+            data[byteIndex + 2] = (this._shared_uint8_array[1] << shift) | ((this._shared_uint8_array[2] >> bitOffset) & mask);
+            data[byteIndex + 3] = (this._shared_uint8_array[2] << shift) | ((this._shared_uint8_array[3] >> bitOffset) & mask);
+            data[byteIndex + 4] = (data[byteIndex + 4] & (0xFF << shift)) | (this._shared_uint8_array[3] << shift);
+        }
+        this.bitPosition = pos + 32;
+    }
+    writeFloat64(value) {
+        this.ensureCapacity(32);
+        this._shared_float_64_array[0] = value;
+        const data = this.byteArray;
+        let pos = this.bitPosition;
+        const bitOffset = pos & 7;
+        const byteIndex = pos >> 3;
+        if (bitOffset === 0) {
+            // Byte-aligned: fastest path
+            data[byteIndex] = this._shared_uint8_array[0];
+            data[byteIndex + 1] = this._shared_uint8_array[1];
+            data[byteIndex + 2] = this._shared_uint8_array[2];
+            data[byteIndex + 3] = this._shared_uint8_array[3];
+            data[byteIndex + 4] = this._shared_uint8_array[4];
+            data[byteIndex + 5] = this._shared_uint8_array[5];
+            data[byteIndex + 6] = this._shared_uint8_array[6];
+            data[byteIndex + 7] = this._shared_uint8_array[7];
+        }
+        else {
+            // Bit-unaligned: optimized bit insertion
+            const shift = 8 - bitOffset;
+            const mask = 0xFF >> bitOffset;
+            data[byteIndex] = (data[byteIndex] & ~mask) | ((this._shared_uint8_array[0] >> bitOffset) & mask);
+            data[byteIndex + 1] = (this._shared_uint8_array[0] << shift) | ((this._shared_uint8_array[1] >> bitOffset) & mask);
+            data[byteIndex + 2] = (this._shared_uint8_array[1] << shift) | ((this._shared_uint8_array[2] >> bitOffset) & mask);
+            data[byteIndex + 3] = (this._shared_uint8_array[2] << shift) | ((this._shared_uint8_array[3] >> bitOffset) & mask);
+            data[byteIndex + 4] = (this._shared_uint8_array[3] << shift) | ((this._shared_uint8_array[4] >> bitOffset) & mask);
+            data[byteIndex + 5] = (this._shared_uint8_array[4] << shift) | ((this._shared_uint8_array[5] >> bitOffset) & mask);
+            data[byteIndex + 6] = (this._shared_uint8_array[5] << shift) | ((this._shared_uint8_array[6] >> bitOffset) & mask);
+            data[byteIndex + 7] = (this._shared_uint8_array[6] << shift) | ((this._shared_uint8_array[7] >> bitOffset) & mask);
+            data[byteIndex + 8] = (data[byteIndex + 8] & (0xFF << shift)) | (this._shared_uint8_array[7] << shift);
+        }
+        this.bitPosition = pos + 64;
+    }
+    writeString(value, end = 0) {
+        const data = BitStreamWriter.textEncoder.encode(value);
+        const len = data.length;
+        this.ensureCapacity((len + 1) * 8);
+        for (let i = 0; i < len; i++) {
+            this.writeIntBytes(data[i], 1);
+        }
+        this.writeIntBytes(end, 1);
+    }
+    removeBits(count) {
+        if (this.nextFixedBytePosition > 0)
+            throw new Error(`Cannot remove bits after fixed bytes have been read (using getNextFixedBytes)`);
+        if (count > this.bitPosition)
+            throw new Error(`Cannot remove more bits (${count}) than are available (${this.bitPosition})`);
+        this.bitPosition -= count;
+        const data = this.byteArray;
+        const startBit = this.bitPosition;
+        for (let i = 0; i < count; i++) {
+            const absBit = startBit + i;
+            const byteIndex = absBit >>> 3;
+            const bitInByte = 7 - (absBit & 7);
+            data[byteIndex] &= ~(1 << bitInByte);
+        }
+    }
+    getBytes() {
+        const dataLength = Math.ceil(this.bitPosition / 8);
+        const output = new Uint8Array(dataLength + 1);
+        output.set(this.byteArray.subarray(0, dataLength));
+        output[dataLength] = (8 - (this.bitPosition & 7)) & 7;
+        return output;
+    }
+    getNextFixedBytes() {
+        const fixedBytesCount = this.bitPosition >>> 3;
+        const nextFixedBytes = this.byteArray.subarray(this.nextFixedBytePosition, fixedBytesCount);
+        this.nextFixedBytePosition = fixedBytesCount;
+        if (this.deletePreviousDataOnGetFixedBytes) {
+            // remove fixed bits from the beginning to free up space
+            this.byteArray = this.byteArray.subarray(fixedBytesCount);
+            this.bitPosition -= fixedBytesCount * 8;
+            this.guaranteedCapacity -= fixedBytesCount * 8;
+        }
+        return nextFixedBytes;
+    }
+    getRemainingBytesAfterFixed() {
+        const dataLength = Math.ceil(this.bitPosition / 8);
+        const remaining = this.byteArray.subarray(this.nextFixedBytePosition, dataLength);
+        const output = new Uint8Array(remaining.length + 1);
+        output.set(remaining);
+        output[remaining.length] = (8 - (this.bitPosition & 7)) & 7;
+        return output;
+    }
+    getNextFixedBuffer() {
+        return Buffer.from(this.getNextFixedBytes());
+    }
+    getRemainingBufferAfterFixed() {
+        return Buffer.from(this.getRemainingBytesAfterFixed());
+    }
+    getBuffer() {
+        return Buffer.from(this.getBytes());
+    }
+}

package/dist/esm/compiler-old.d.ts

@@ -0,0 +1,9 @@
+import { SchemaBase } from "./schema-structure";
+/**
+ * Compiles a SchemaBase into a high-performance writer function.
+ */
+export declare function compileWriter(schema: SchemaBase): string;
+/**
+ * Compiles a SchemaBase into a high-performance reader function.
+ */
+export declare function compileReader(schema: SchemaBase): (reader: any) => any;

package/dist/esm/compiler-old.js

@@ -0,0 +1,264 @@
+/**
+ * Compiles a SchemaBase into a high-performance writer function.
+ */
+export function compileWriter(schema) {
+    let code = "";
+    let varCount = 0;
+    function nextVar() {
+        return `v${varCount++}`;
+    }
+    function generateTypeEncoder(def, dataPath, indent) {
+        if ("types" in def) {
+            generateMultiTypeEncoder(def, dataPath, indent);
+        }
+        else {
+            generateSingleTypeEncoder(def, dataPath, indent);
+        }
+    }
+    function generateSingleTypeEncoder(def, dataPath, indent) {
+        const isOptional = 'optional' in def && def.optional;
+        if (isOptional) {
+            code += `${indent}if (${dataPath} === undefined || ${dataPath} === null) {\n`;
+            code += `${indent}  writer.writeBit(false);\n`;
+            if ('default' in def && def.default !== undefined) {
+                // We handle defaults by not writing anything if it's missing, 
+                // the reader will fill it in.
+            }
+            code += `${indent}} else {\n`;
+            code += `${indent}  writer.writeBit(true);\n`;
+            generateBaseTypeEncoder(def, dataPath, indent + "  ");
+            code += `${indent}}\n`;
+        }
+        else {
+            generateBaseTypeEncoder(def, dataPath, indent);
+        }
+    }
+    function generateBaseTypeEncoder(def, dataPath, indent) {
+        switch (def.type) {
+            case 'null':
+                break;
+            case 'boolean':
+                code += `${indent}writer.writeBit(${dataPath});\n`;
+                break;
+            case 'string':
+                code += `${indent}writer.writeString(${dataPath});\n`;
+                break;
+            case 'int-8':
+                code += `${indent}writer.writeInt8(${dataPath});\n`;
+                break;
+            case 'int-16':
+                code += `${indent}writer.writeInt16(${dataPath});\n`;
+                break;
+            case 'int-32':
+                code += `${indent}writer.writeInt32(${dataPath});\n`;
+                break;
+            case 'bigint':
+                code += `${indent}writer.writeBigInt(${dataPath});\n`;
+                break;
+            case 'float-32':
+                code += `${indent}writer.writeFloat32(${dataPath});\n`;
+                break;
+            case 'float-64':
+                code += `${indent}writer.writeFloat64(${dataPath});\n`;
+                break;
+            case 'object':
+                generateObjectEncoder(def.items, dataPath, indent);
+                break;
+            case 'array':
+                generateArrayEncoder(def.items, dataPath, indent);
+                break;
+        }
+    }
+    function generateObjectEncoder(schema, dataPath, indent) {
+        const keys = Object.keys(schema);
+        for (const key of keys) {
+            generateTypeEncoder(schema[key], `${dataPath}["${key}"]`, indent);
+        }
+    }
+    function generateArrayEncoder(itemDef, dataPath, indent) {
+        const iVar = nextVar();
+        const lenVar = nextVar();
+        code += `${indent}const ${lenVar} = ${dataPath}.length;\n`;
+        code += `${indent}writer.writeInt32(${lenVar});\n`;
+        code += `${indent}for (let ${iVar} = 0; ${iVar} < ${lenVar}; ${iVar}++) {\n`;
+        generateTypeEncoder(itemDef, `${dataPath}[${iVar}]`, indent + "  ");
+        code += `${indent}}\n`;
+    }
+    function generateMultiTypeEncoder(def, dataPath, indent) {
+        const noOfDefs = def.types.length;
+        const minBits = Math.ceil(Math.log2(noOfDefs));
+        // This part is complex because we need to match the type at runtime.
+        // For now, I'll use a simplified version that matches exactly like the DataStreamWriter does.
+        // But for performance, we should ideally have a pre-calculated mapping.
+        code += `${indent}// MultiType matching for ${dataPath}\n`;
+        for (let i = 0; i < noOfDefs; i++) {
+            let typeDef = def.types[i];
+            if (typeof typeDef === 'string')
+                typeDef = { type: typeDef };
+            const condition = getTypeMatchCondition(typeDef, dataPath);
+            code += `${indent}${i === 0 ? 'if' : 'else if'} (${condition}) {\n`;
+            // Write type index bits
+            const bits = intToBits(i, minBits);
+            for (const bit of bits) {
+                code += `${indent}  writer.writeBit(${bit});\n`;
+            }
+            generateSingleTypeEncoder(typeDef, dataPath, indent + "  ");
+            code += `${indent}}\n`;
+        }
+        code += `${indent}else {\n`;
+        code += `${indent}  throw new Error("No matching type found in MultiType for value at ${dataPath}");\n`;
+        code += `${indent}}\n`;
+    }
+    function getTypeMatchCondition(def, dataPath) {
+        switch (def.type) {
+            case 'null':
+                return `${dataPath} === null`;
+            case 'boolean':
+                return `typeof ${dataPath} === "boolean"`;
+            case 'string':
+                return `typeof ${dataPath} === "string"`;
+            case 'int-8':
+            case 'int-16':
+            case 'int-32':
+            case 'float-32':
+            case 'float-64':
+                return `typeof ${dataPath} === "number"`;
+            case 'bigint':
+                return `typeof ${dataPath} === "bigint"`;
+            case 'array':
+                return `Array.isArray(${dataPath})`;
+            case 'object':
+                return `typeof ${dataPath} === "object" && ${dataPath} !== null && !Array.isArray(${dataPath})`;
+            default:
+                return "false";
+        }
+    }
+    function intToBits(int, bitCount) {
+        const bits = [];
+        for (let i = 0; i < bitCount; i++) {
+            bits.push((int & (1 << i)) !== 0);
+        }
+        return bits;
+    }
+    generateObjectEncoder(schema, "data", "");
+    return code;
+    // return new Function("writer", "data", code) as (writer: any, data: any) => void;
+}
+/**
+ * Compiles a SchemaBase into a high-performance reader function.
+ */
+export function compileReader(schema) {
+    let code = "const result = {};\n";
+    let varCount = 0;
+    function nextVar() {
+        return `v${varCount++}`;
+    }
+    function generateTypeDecoder(def, indent) {
+        if ("types" in def) {
+            return generateMultiTypeDecoder(def, indent);
+        }
+        else {
+            return generateSingleTypeDecoder(def, indent);
+        }
+    }
+    function generateSingleTypeDecoder(def, indent) {
+        const isOptional = 'optional' in def && def.optional;
+        const v = nextVar();
+        if (isOptional) {
+            code += `${indent}let ${v};\n`;
+            code += `${indent}if (reader.readBit()) {\n`;
+            const baseDecoder = generateBaseTypeDecoder(def, indent + "  ");
+            code += `${indent}  ${v} = ${baseDecoder};\n`;
+            code += `${indent}} else {\n`;
+            if ('default' in def && def.default !== undefined) {
+                code += `${indent}  ${v} = ${JSON.stringify(def.default)};\n`;
+            }
+            else {
+                code += `${indent}  ${v} = undefined;\n`;
+            }
+            code += `${indent}}\n`;
+        }
+        else {
+            const baseDecoder = generateBaseTypeDecoder(def, indent);
+            code += `${indent}const ${v} = ${baseDecoder};\n`;
+        }
+        return v;
+    }
+    function generateBaseTypeDecoder(def, indent) {
+        switch (def.type) {
+            case 'null':
+                return "null";
+            case 'boolean':
+                return "reader.readBit()";
+            case 'string':
+                return "reader.readString()";
+            case 'int-8':
+                return "reader.readInt8()";
+            case 'int-16':
+                return "reader.readInt16()";
+            case 'int-32':
+                return "reader.readInt32()";
+            case 'bigint':
+                return "reader.readBigInt()";
+            case 'float-32':
+                return "reader.readFloat32()";
+            case 'float-64':
+                return "reader.readFloat64()";
+            case 'object':
+                return generateObjectDecoder(def.items, indent);
+            case 'array':
+                return generateArrayDecoder(def.items, indent);
+            default:
+                throw new Error(`Unsupported type: ${def.type}`);
+        }
+    }
+    function generateObjectDecoder(schema, indent) {
+        const objVar = nextVar();
+        code += `${indent}const ${objVar} = {};\n`;
+        const keys = Object.keys(schema);
+        for (const key of keys) {
+            const valVar = generateTypeDecoder(schema[key], indent);
+            code += `${indent}${objVar}["${key}"] = ${valVar};\n`;
+        }
+        return objVar;
+    }
+    function generateArrayDecoder(itemDef, indent) {
+        const arrVar = nextVar();
+        const lenVar = nextVar();
+        const iVar = nextVar();
+        code += `${indent}const ${lenVar} = reader.readInt32();\n`;
+        code += `${indent}const ${arrVar} = new Array(${lenVar});\n`;
+        code += `${indent}for (let ${iVar} = 0; ${iVar} < ${lenVar}; ${iVar}++) {\n`;
+        const itemVar = generateTypeDecoder(itemDef, indent + "  ");
+        code += `${indent}  ${arrVar}[${iVar}] = ${itemVar};\n`;
+        code += `${indent}}\n`;
+        return arrVar;
+    }
+    function generateMultiTypeDecoder(def, indent) {
+        const resVar = nextVar();
+        const noOfDefs = def.types.length;
+        const minBits = Math.ceil(Math.log2(noOfDefs));
+        const indexVar = nextVar();
+        code += `${indent}let ${indexVar} = 0;\n`;
+        for (let i = 0; i < minBits; i++) {
+            code += `${indent}if (reader.readBit()) ${indexVar} |= (1 << ${i});\n`;
+        }
+        code += `${indent}let ${resVar};\n`;
+        code += `${indent}switch (${indexVar}) {\n`;
+        for (let i = 0; i < noOfDefs; i++) {
+            let typeDef = def.types[i];
+            if (typeof typeDef === 'string')
+                typeDef = { type: typeDef };
+            code += `${indent}  case ${i}:\n`;
+            const valVar = generateSingleTypeDecoder(typeDef, indent + "    ");
+            code += `${indent}    ${resVar} = ${valVar};\n`;
+            code += `${indent}    break;\n`;
+        }
+        code += `${indent}  default: throw new Error("Invalid MultiType index: " + ${indexVar});\n`;
+        code += `${indent}}\n`;
+        return resVar;
+    }
+    const finalObjVar = generateObjectDecoder(schema, "");
+    code += `return ${finalObjVar};\n`;
+    return new Function("reader", code);
+}

package/dist/esm/data-stream-reader.d.ts

@@ -0,0 +1,23 @@
+import { BitStreamReader } from "./bit-stream-reader";
+import { DataValue, SchemaBase } from "./schema-structure";
+export declare class DataStreamReader extends BitStreamReader {
+    private schema;
+    private metaData;
+    constructor();
+    constructor(initialData: Uint8Array | Buffer<ArrayBuffer>);
+    constructor(initialData: Uint8Array | Buffer<ArrayBuffer>, isComplete: true);
+    constructor(initialData: Uint8Array | Buffer<ArrayBuffer>, isComplete: false);
+    constructor(schema: string | SchemaBase);
+    constructor(schema: string | SchemaBase, initialData: Uint8Array | Buffer<ArrayBuffer>);
+    constructor(schema: string | SchemaBase, initialData: Uint8Array | Buffer<ArrayBuffer>, isComplete: true);
+    constructor(schema: string | SchemaBase, initialData: Uint8Array | Buffer<ArrayBuffer>, isComplete: false);
+    static compile(schema: SchemaBase): (reader: any) => any;
+    readCompiled(compiledFn: (reader: DataStreamReader) => any): any;
+    addData(data: Uint8Array): void;
+    isReadyToRead(): boolean;
+    read(): DataValue | null;
+    private readObject;
+    private readSingleType;
+    private readMultiType;
+    private readArray;
+}