bireader 1.0.43 → 1.0.44

package/lib/cjs/index.js

@@ -670,6 +670,212 @@ function ADD(_this, add_key, start, end, consume) {
         }
     }
 }
+function fString(_this, searchString) {
+    // Convert the searchString to Uint8Array
+    const searchArray = new TextEncoder().encode(searchString);
+    for (let i = _this.offset; i <= _this.size - searchArray.length; i++) {
+        let match = true;
+        for (let j = 0; j < searchArray.length; j++) {
+            if (_this.data[i + j] !== searchArray[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match) {
+            return i; // Found the string, return the index
+        }
+    }
+    return -1; // String not found
+}
+function fNumber(_this, targetNumber, bits, unsigned, endian) {
+    check_size(_this, Math.floor(bits / 8), 0);
+    for (let z = _this.offset; z <= (_this.size - (bits / 8)); z++) {
+        var off_in_bits = 0;
+        var value = 0;
+        for (var i = 0; i < bits;) {
+            var remaining = bits - i;
+            var bitOffset = off_in_bits & 7;
+            var currentByte = _this.data[z + (off_in_bits >> 3)];
+            var read = Math.min(remaining, 8 - bitOffset);
+            var mask, readBits;
+            if ((endian != undefined ? endian : _this.endian) == "big") {
+                mask = ~(0xFF << read);
+                readBits = (currentByte >> (8 - read - bitOffset)) & mask;
+                value <<= read;
+                value |= readBits;
+            }
+            else {
+                mask = ~(0xFF << read);
+                readBits = (currentByte >> bitOffset) & mask;
+                value |= readBits << i;
+            }
+            off_in_bits += read;
+            i += read;
+        }
+        if (unsigned == true || bits <= 7) {
+            value = value >>> 0;
+        }
+        else {
+            if (bits !== 32 && value & (1 << (bits - 1))) {
+                value |= -1 ^ ((1 << bits) - 1);
+            }
+        }
+        if (value === targetNumber) {
+            return z; // Found the byte, return the index
+        }
+    }
+    return -1; // number not found
+}
+function fHalfFloat(_this, targetNumber, endian) {
+    check_size(_this, 2, 0);
+    for (let z = _this.offset; z <= (_this.size - 2); z++) {
+        var value = 0;
+        if ((endian != undefined ? endian : _this.endian) == "little") {
+            value = (_this.data[z + 1] << 8) | _this.data[z];
+        }
+        else {
+            value = (_this.data[z] << 8) | _this.data[z + 1];
+        }
+        const sign = (value & 0x8000) >> 15;
+        const exponent = (value & 0x7C00) >> 10;
+        const fraction = value & 0x03FF;
+        let floatValue;
+        if (exponent === 0) {
+            if (fraction === 0) {
+                floatValue = (sign === 0) ? 0 : -0; // +/-0
+            }
+            else {
+                // Denormalized number
+                floatValue = (sign === 0 ? 1 : -1) * Math.pow(2, -14) * (fraction / 0x0400);
+            }
+        }
+        else if (exponent === 0x1F) {
+            if (fraction === 0) {
+                floatValue = (sign === 0) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+            }
+            else {
+                floatValue = Number.NaN;
+            }
+        }
+        else {
+            // Normalized number
+            floatValue = (sign === 0 ? 1 : -1) * Math.pow(2, exponent - 15) * (1 + fraction / 0x0400);
+        }
+        if (floatValue === targetNumber) {
+            return z; // Found the number, return the index
+        }
+    }
+    return -1; // number not found
+}
+function fFloat(_this, targetNumber, endian) {
+    check_size(_this, 4, 0);
+    for (let z = _this.offset; z <= (_this.size - 4); z++) {
+        var value = 0;
+        if ((endian != undefined ? endian : _this.endian) == "little") {
+            value = ((_this.data[z + 3] << 24) | (_this.data[z + 2] << 16) | (_this.data[z + 1] << 8) | _this.data[z]);
+        }
+        else {
+            value = (_this.data[z] << 24) | (_this.data[z + 1] << 16) | (_this.data[z + 2] << 8) | _this.data[z + 3];
+        }
+        const isNegative = (value & 0x80000000) !== 0 ? 1 : 0;
+        // Extract the exponent and fraction parts
+        const exponent = (value >> 23) & 0xFF;
+        const fraction = value & 0x7FFFFF;
+        // Calculate the float value
+        let floatValue;
+        if (exponent === 0) {
+            // Denormalized number (exponent is 0)
+            floatValue = Math.pow(-1, isNegative) * Math.pow(2, -126) * (fraction / Math.pow(2, 23));
+        }
+        else if (exponent === 0xFF) {
+            // Infinity or NaN (exponent is 255)
+            floatValue = fraction === 0 ? (isNegative ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY) : Number.NaN;
+        }
+        else {
+            // Normalized number
+            floatValue = Math.pow(-1, isNegative) * Math.pow(2, exponent - 127) * (1 + fraction / Math.pow(2, 23));
+        }
+        if (floatValue === targetNumber) {
+            return z; // Found the number, return the index
+        }
+    }
+    return -1; // number not found
+}
+function fBigInt(_this, targetNumber, unsigned, endian) {
+    check_size(_this, 8, 0);
+    for (let z = _this.offset; z <= (_this.size - 8); z++) {
+        let value = BigInt(0);
+        if ((endian == undefined ? _this.endian : endian) == "little") {
+            for (let i = 0; i < 8; i++) {
+                value = value | BigInt(_this.data[z + i]) << BigInt(8 * i);
+            }
+            if (unsigned == undefined || unsigned == false) {
+                if (value & (BigInt(1) << BigInt(63))) {
+                    value -= BigInt(1) << BigInt(64);
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < 8; i++) {
+                value = (value << BigInt(8)) | BigInt(_this.data[z + i]);
+            }
+            if (unsigned == undefined || unsigned == false) {
+                if (value & (BigInt(1) << BigInt(63))) {
+                    value -= BigInt(1) << BigInt(64);
+                }
+            }
+        }
+        if (value == BigInt(targetNumber)) {
+            return z;
+        }
+    }
+    return -1; // number not found
+}
+function fDoubleFloat(_this, targetNumber, endian) {
+    check_size(_this, 8, 0);
+    for (let z = _this.offset; z <= (_this.size - 8); z++) {
+        let value = BigInt(0);
+        if ((endian == undefined ? _this.endian : endian) == "little") {
+            for (let i = 0; i < 8; i++) {
+                value = value | BigInt(_this.data[z + i]) << BigInt(8 * i);
+            }
+        }
+        else {
+            for (let i = 0; i < 8; i++) {
+                value = (value << BigInt(8)) | BigInt(_this.data[z + i]);
+            }
+        }
+        const sign = (value & 0x8000000000000000n) >> 63n;
+        const exponent = Number((value & 0x7ff0000000000000n) >> 52n) - 1023;
+        const fraction = Number(value & 0x000fffffffffffffn) / Math.pow(2, 52);
+        var floatValue;
+        if (exponent == -1023) {
+            if (fraction == 0) {
+                floatValue = (sign == 0n) ? 0 : -0; // +/-0
+            }
+            else {
+                // Denormalized number
+                floatValue = (sign == 0n ? 1 : -1) * Math.pow(2, -1022) * fraction;
+            }
+        }
+        else if (exponent == 1024) {
+            if (fraction == 0) {
+                floatValue = (sign == 0n) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+            }
+            else {
+                floatValue = Number.NaN;
+            }
+        }
+        else {
+            // Normalized number
+            floatValue = (sign == 0n ? 1 : -1) * Math.pow(2, exponent) * (1 + fraction);
+        }
+        if (floatValue == targetNumber) {
+            return z;
+        }
+    }
+    return -1; // number not found
+}
 function wbit(_this, value, bits, unsigned, endian) {
     if (value == undefined) {
         throw new Error('Must supply value.');
@@ -1447,16 +1653,16 @@ class bireader {
             throw new Error("Byte order must be big or little");
         }
         this.endian = endianness || "little";
-        if (byteOffset != undefined) {
-            if (typeof byteOffset == "number") {
-                this.offset = Math.round(byteOffset) || 0;
-            }
-            else {
-                throw new Error("Byte offset must be number");
-            }
-        }
-        if (bitOffset != undefined) {
-            this.bitoffset = bitOffset % 8;
+        if (byteOffset != undefined || bitOffset != undefined) {
+            this.offset = ((Math.abs(byteOffset || 0)) + Math.ceil((Math.abs(bitOffset || 0)) / 8));
+            // Adjust byte offset based on bit overflow
+            this.offset += Math.floor((Math.abs(bitOffset || 0)) / 8);
+            // Adjust bit offset
+            this.bitoffset = (Math.abs(bitOffset || 0) + 64) % 8;
+            // Ensure bit offset stays between 0-7
+            this.bitoffset = Math.min(Math.max(this.bitoffset, 0), 7);
+            // Ensure offset doesn't go negative
+            this.offset = Math.max(this.offset, 0);
         }
         if (typeof strict == "boolean") {
             this.strict = strict;
@@ -2317,6 +2523,116 @@ class bireader {
         this.errorDump = true;
     }
     //
+    //find
+    //
+    /**
+    * Searches for byte position of string from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {string} string - String to search for.
+    */
+    findString(string) {
+        return fString(this, string);
+    }
+    /**
+    * Searches for byte value (can be signed or unsigned) position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {boolean} unsigned - If the number is unsigned (default true)
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findByte(value, unsigned, endian) {
+        return fNumber(this, value, 8, unsigned == undefined ? true : unsigned, endian);
+    }
+    /**
+    * Searches for short value (can be signed or unsigned) position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {boolean} unsigned - If the number is unsigned (default true)
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findShort(value, unsigned, endian) {
+        return fNumber(this, value, 16, unsigned == undefined ? true : unsigned, endian);
+    }
+    /**
+    * Searches for integer value (can be signed or unsigned) position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {boolean} unsigned - If the number is unsigned (default true)
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findInt(value, unsigned, endian) {
+        return fNumber(this, value, 32, unsigned == undefined ? true : unsigned, endian);
+    }
+    /**
+    * Searches for half float value position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findHalfFloat(value, endian) {
+        return fHalfFloat(this, value, endian);
+    }
+    /**
+    * Searches for float value position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findFloat(value, endian) {
+        return fFloat(this, value, endian);
+    }
+    /**
+    * Searches for 64 bit value (can be signed or unsigned) position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {boolean} unsigned - If the number is unsigned (default true)
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findInt64(value, unsigned, endian) {
+        return fBigInt(this, value, unsigned == undefined ? true : unsigned, endian);
+    }
+    /**
+    * Searches for double float value position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findDoubleFloat(value, endian) {
+        return fDoubleFloat(this, value, endian);
+    }
+    //
     //bit reader
     //
     /**
@@ -5904,16 +6220,16 @@ class biwriter {
             throw new Error("Endianness must be big or little");
         }
         this.endian = endianness || "little";
-        if (byteOffset != undefined) {
-            if (typeof byteOffset == "number") {
-                this.offset = Math.round(byteOffset) || 0;
-            }
-            else {
-                throw new Error("Byte offset must be number");
-            }
-        }
-        if (bitOffset != undefined) {
-            this.bitoffset = (bitOffset % 8);
+        if (byteOffset != undefined || bitOffset != undefined) {
+            this.offset = ((Math.abs(byteOffset || 0)) + Math.ceil((Math.abs(bitOffset || 0)) / 8));
+            // Adjust byte offset based on bit overflow
+            this.offset += Math.floor((Math.abs(bitOffset || 0)) / 8);
+            // Adjust bit offset
+            this.bitoffset = (Math.abs(bitOffset || 0) + 64) % 8;
+            // Ensure bit offset stays between 0-7
+            this.bitoffset = Math.min(Math.max(this.bitoffset, 0), 7);
+            // Ensure offset doesn't go negative
+            this.offset = Math.max(this.offset, 0);
         }
         if (typeof strict == "boolean") {
             this.strict = strict;
@@ -5924,7 +6240,12 @@ class biwriter {
             }
         }
         if (data == undefined) {
-            throw new Error("Data required");
+            if (typeof Buffer !== 'undefined') {
+                this.data = Buffer.alloc(this.offset || 1 + (this.bitoffset != 0 ? 1 : 0));
+            }
+            else {
+                this.data = new Uint8Array(this.offset || 1 + (this.bitoffset != 0 ? 1 : 0));
+            }
         }
         else {
             if (!this.isBufferOrUint8Array(data)) {
@@ -6780,6 +7101,116 @@ class biwriter {
         this.errorDump = true;
     }
     //
+    //find
+    //
+    /**
+    * Searches for byte position of string from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {string} string - String to search for.
+    */
+    findString(string) {
+        return fString(this, string);
+    }
+    /**
+    * Searches for byte value (can be signed or unsigned) position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {boolean} unsigned - If the number is unsigned (default true)
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findByte(value, unsigned, endian) {
+        return fNumber(this, value, 8, unsigned == undefined ? true : unsigned, endian);
+    }
+    /**
+    * Searches for short value (can be signed or unsigned) position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {boolean} unsigned - If the number is unsigned (default true)
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findShort(value, unsigned, endian) {
+        return fNumber(this, value, 16, unsigned == undefined ? true : unsigned, endian);
+    }
+    /**
+    * Searches for integer value (can be signed or unsigned) position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {boolean} unsigned - If the number is unsigned (default true)
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findInt(value, unsigned, endian) {
+        return fNumber(this, value, 32, unsigned == undefined ? true : unsigned, endian);
+    }
+    /**
+    * Searches for half float value position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findHalfFloat(value, endian) {
+        return fHalfFloat(this, value, endian);
+    }
+    /**
+    * Searches for float value position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findFloat(value, endian) {
+        return fFloat(this, value, endian);
+    }
+    /**
+    * Searches for 64 bit value (can be signed or unsigned) position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {boolean} unsigned - If the number is unsigned (default true)
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findInt64(value, unsigned, endian) {
+        return fBigInt(this, value, unsigned == undefined ? true : unsigned, endian);
+    }
+    /**
+    * Searches for double float value position from current read position.
+    *
+    * Returns -1 if not found.
+    *
+    * Does not change current read position.
+    *
+    * @param {number} value - Number to search for.
+    * @param {string} endian - endianness of value (default set endian).
+    */
+    findDoubleFloat(value, endian) {
+        return fDoubleFloat(this, value, endian);
+    }
+    //
     //bit writer
     //
     /**