bireader 1.0.15 → 1.0.17

package/lib/cjs/src/reader.js

@@ -13,23 +13,16 @@ const common_1 = require("./common");
 */
 class bireader {
     isBuffer(obj) {
-        return (typeof Buffer !== 'undefined' && obj instanceof Buffer);
+        return (0, common_1.buffcheck)(obj);
     }
     isBufferOrUint8Array(obj) {
-        return obj instanceof Uint8Array || this.isBuffer(obj);
+        return (0, common_1.arraybuffcheck)(this, obj);
     }
     extendArray(to_padd) {
-        if ((typeof Buffer !== 'undefined' && this.data instanceof Buffer)) {
-            var paddbuffer = Buffer.alloc(to_padd);
-            this.data = Buffer.concat([this.data, paddbuffer]);
-        }
-        else {
-            const addArray = new Array(to_padd);
-            this.data = new Uint8Array([...this.data, ...addArray]);
-        }
+        return (0, common_1.extendarray)(this, to_padd);
     }
-    check_size(read_size, read_bits) {
-        return (0, common_1.checkSize)(this, read_size || 0, read_bits || 0, this.offset);
+    check_size(write_bytes, write_bit, offset) {
+        return (0, common_1.checkSize)(this, write_bytes || 0, write_bit || 0, offset || this.offset);
     }
     /**
     * Binary reader, includes bitfields and strings
@@ -248,6 +241,54 @@ class bireader {
     saveOffset() {
         return this.offset;
     }
+    /**
+    * Get the current bit position (0-7)
+    *
+    * @return {number} current bit position
+    */
+    tellB() {
+        return this.bitoffset;
+    }
+    /**
+    * Get the current bit position (0-7)
+    *
+    * @return {number} current bit position
+    */
+    getOffsetBit() {
+        return this.bitoffset;
+    }
+    /**
+    * Get the current bit position (0-7)
+    *
+    * @return {number} current bit position
+    */
+    saveOffsetAbsBit() {
+        return (this.offset * 8) + this.bitoffset;
+    }
+    /**
+    * Get the current absolute bit position (from start of data)
+    *
+    * @return {number} current absolute bit position
+    */
+    tellAbsB() {
+        return (this.offset * 8) + this.bitoffset;
+    }
+    /**
+    * Get the current absolute bit position (from start of data)
+    *
+    * @return {number} current absolute bit position
+    */
+    getOffsetAbsBit() {
+        return (this.offset * 8) + this.bitoffset;
+    }
+    /**
+    * Get the current absolute bit position (from start of data)
+    *
+    * @return {number} current absolute bit position
+    */
+    saveOffsetBit() {
+        return (this.offset * 8) + this.bitoffset;
+    }
     //
     //strict mode change
     //
@@ -264,6 +305,262 @@ class bireader {
         this.strict = false;
     }
     //
+    //math
+    //
+    /**
+    * XOR data
+    *
+    * @param {number|string|Uint8Array|Buffer} xorKey - Value, string or array to XOR
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    xor(xorKey, startOffset, endOffset, consume) {
+        var XORKey = xorKey;
+        if (typeof xorKey == "number") {
+            //pass
+        }
+        else if (typeof xorKey == "string") {
+            //pass
+        }
+        else if (this.isBufferOrUint8Array(XORKey)) {
+            //pass
+        }
+        else {
+            throw new Error("XOR must be a number, string, Uint8Array or Buffer");
+        }
+        return (0, common_1.XOR)(this, xorKey, startOffset || this.offset, endOffset || this.size, consume || false);
+    }
+    /**
+    * XOR data
+    *
+    * @param {number|string|Uint8Array|Buffer} xorKey - Value, string or array to XOR
+    * @param {number} length - Length in bytes to XOR from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    xorThis(xorKey, length, consume) {
+        var Length = length || 1;
+        var XORKey = xorKey;
+        if (typeof xorKey == "number") {
+            Length = length || 1;
+        }
+        else if (typeof xorKey == "string") {
+            const encoder = new TextEncoder().encode(xorKey);
+            XORKey = encoder;
+            Length = length || encoder.length;
+        }
+        else if (this.isBufferOrUint8Array(XORKey)) {
+            Length = length || xorKey.length;
+        }
+        else {
+            throw new Error("XOR must be a number, string, Uint8Array or Buffer");
+        }
+        return (0, common_1.XOR)(this, XORKey, this.offset, this.offset + Length, consume || false);
+    }
+    /**
+    * OR data
+    *
+    * @param {number|string|Uint8Array|Buffer} orKey - Value, string or array to OR
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    or(orKey, startOffset, endOffset, consume) {
+        var ORKey = orKey;
+        if (typeof orKey == "number") {
+            //pass
+        }
+        else if (typeof orKey == "string") {
+            //pass
+        }
+        else if (this.isBufferOrUint8Array(ORKey)) {
+            //pass
+        }
+        else {
+            throw new Error("OR must be a number, string, Uint8Array or Buffer");
+        }
+        return (0, common_1.OR)(this, orKey, startOffset || this.offset, endOffset || this.size, consume || false);
+    }
+    /**
+    * OR data
+    *
+    * @param {number|string|Uint8Array|Buffer} orKey - Value, string or array to OR
+    * @param {number} length - Length in bytes to OR from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    orThis(orKey, length, consume) {
+        var Length = length || 1;
+        var ORKey = orKey;
+        if (typeof orKey == "number") {
+            Length = length || 1;
+        }
+        else if (typeof orKey == "string") {
+            const encoder = new TextEncoder().encode(orKey);
+            ORKey = encoder;
+            Length = length || encoder.length;
+        }
+        else if (this.isBufferOrUint8Array(ORKey)) {
+            Length = length || orKey.length;
+        }
+        else {
+            throw new Error("OR must be a number, string, Uint8Array or Buffer");
+        }
+        return (0, common_1.OR)(this, ORKey, this.offset, this.offset + Length, consume || false);
+    }
+    /**
+    * AND data
+    *
+    * @param {number|string|Uint8Array|Buffer} andKey - Value, string or array to AND
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    and(andKey, startOffset, endOffset, consume) {
+        var ANDKey = andKey;
+        if (typeof andKey == "number") {
+            //pass
+        }
+        else if (typeof andKey == "string") {
+            //pass
+        }
+        else if (this.isBufferOrUint8Array(ANDKey)) {
+            //pass
+        }
+        else {
+            throw new Error("AND must be a number, string, Uint8Array or Buffer");
+        }
+        return (0, common_1.AND)(this, andKey, startOffset || this.offset, endOffset || this.size, consume || false);
+    }
+    /**
+    * AND data
+    *
+    * @param {number|string|Uint8Array|Buffer} andKey - Value, string or array to AND
+    * @param {number} length - Length in bytes to AND from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    andThis(andKey, length, consume) {
+        var Length = length || 1;
+        var ANDKey = andKey;
+        if (typeof andKey == "number") {
+            Length = length || 1;
+        }
+        else if (typeof andKey == "string") {
+            const encoder = new TextEncoder().encode(andKey);
+            ANDKey = encoder;
+            Length = length || encoder.length;
+        }
+        else if (this.isBufferOrUint8Array(ANDKey)) {
+            Length = length || andKey.length;
+        }
+        else {
+            throw new Error("XOR must be a number, string, Uint8Array or Buffer");
+        }
+        return (0, common_1.AND)(this, ANDKey, this.offset, this.offset + Length, consume || false);
+    }
+    /**
+    * Not data
+    *
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    not(startOffset, endOffset, consume) {
+        return (0, common_1.NOT)(this, startOffset || this.offset, endOffset || this.size, consume || false);
+    }
+    /**
+    * Not data
+    *
+    * @param {number} length - Length in bytes to NOT from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    notThis(length, consume) {
+        return (0, common_1.NOT)(this, this.offset, this.offset + (length || 1), consume || false);
+    }
+    /**
+    * Left shift data
+    *
+    * @param {number} shiftValue - Value to left shift
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    lShift(shiftValue, startOffset, endOffset, consume) {
+        if (typeof shiftValue != "number") {
+            throw new Error("Shift value must be a number");
+        }
+        return (0, common_1.LSHIFT)(this, shiftValue, startOffset || this.offset, endOffset || this.size, consume || false);
+    }
+    /**
+    * Left shift data
+    *
+    * @param {number} shiftValue - Value to left shift
+    * @param {number} length - Length in bytes to left shift from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    lShiftThis(shiftValue, length, consume) {
+        var Length = length || 1;
+        if (typeof shiftValue != "number") {
+            throw new Error("Shift value must be a number");
+        }
+        return (0, common_1.LSHIFT)(this, shiftValue, this.offset, this.offset + Length, consume || false);
+    }
+    /**
+    * Right shift data
+    *
+    * @param {number} shiftValue - Value to right shift
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    rShift(shiftValue, startOffset, endOffset, consume) {
+        if (typeof shiftValue != "number") {
+            throw new Error("Shift value must be a number");
+        }
+        return (0, common_1.RSHIFT)(this, shiftValue, startOffset || this.offset, endOffset || this.size, consume || false);
+    }
+    /**
+    * Right shift data
+    *
+    * @param {number} shiftValue - Value to right shift
+    * @param {number} length - Length in bytes to right shift from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    rShiftThis(shiftValue, length, consume) {
+        var Length = length || 1;
+        if (typeof shiftValue != "number") {
+            throw new Error("Shift value must be a number");
+        }
+        return (0, common_1.RSHIFT)(this, shiftValue, this.offset, this.offset + Length, consume || false);
+    }
+    /**
+    * Add value to data
+    *
+    * @param {number} addValue - Value to add
+    * @param {number} startOffset - Start location (default current byte position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    add(addValue, startOffset, endOffset, consume) {
+        if (typeof addValue != "number") {
+            throw new Error("Add value must be a number");
+        }
+        return (0, common_1.ADD)(this, addValue, startOffset || this.offset, endOffset || this.size, consume || false);
+    }
+    /**
+    * Add value to data
+    *
+    * @param {number} addValue - Value to add
+    * @param {number} length - Length in bytes to add from curent position (default 1 byte for value, length of string or array for Uint8Array or Buffer)
+    * @param {boolean} consume - Move current position to end of data (default false)
+    */
+    addThis(addValue, length, consume) {
+        var Length = length || 1;
+        if (typeof addValue != "number") {
+            throw new Error("Add value must be a number");
+        }
+        return (0, common_1.ADD)(this, addValue, this.offset, this.offset + Length, consume || false);
+    }
+    //
     //remove part of data
     //
     /**
@@ -380,8 +677,8 @@ class bireader {
     * Note: Must be same data type as supplied data. Errors on strict mode.
     *
     * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to add to data
-    * @param {boolean} consume - Move current write position to end of data (default false)
-    * @param {number} offset - Offset to add it at (defaults to current position)
+    * @param {boolean} consume - Move current byte position to end of data (default false)
+    * @param {number} offset - Byte position to add at (defaults to current position)
     */
     insert(data, consume, offset) {
         return (0, common_1.addData)(this, data, consume || false, offset || this.offset);
@@ -391,13 +688,35 @@ class bireader {
     * Note: Must be same data type as supplied data. Errors on strict mode.
     *
     * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to add to data
-    * @param {boolean} consume - Move current write position to end of data (default false)
-    * @param {number} offset - Offset to add it at (defaults to current position)
+    * @param {boolean} consume - Move current byte position to end of data (default false)
+    * @param {number} offset - Byte position to add at (defaults to current position)
     */
     place(data, consume, offset) {
         return (0, common_1.addData)(this, data, consume || false, offset || this.offset);
     }
     /**
+    * Replaces data in data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to replace in data
+    * @param {boolean} consume - Move current byte position to end of data (default false)
+    * @param {number} offset - Offset to add it at (defaults to current position)
+    */
+    replace(data, consume, offset) {
+        return (0, common_1.addData)(this, data, consume || false, offset || this.offset, true);
+    }
+    /**
+    * Replaces data in data
+    * Note: Must be same data type as supplied data. Errors on strict mode.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to replace in data
+    * @param {boolean} consume - Move current byte position to end of data (default false)
+    * @param {number} offset - Offset to add it at (defaults to current position)
+    */
+    overwrite(data, consume, offset) {
+        return (0, common_1.addData)(this, data, consume || false, offset || this.offset, true);
+    }
+    /**
     * Adds data to start of supplied data
     * Note: Must be same data type as supplied data. Errors on strict mode.
     *
@@ -483,12 +802,12 @@ class bireader {
     /**
     * Console logs data as hex dump
     *
-    * @param {object} options - options object
+    * @param {object} options
     * ```javascript
     *   {
     *       length: 192, // number of bytes to log, default 192 or end of data
-    *       startByte: 0, // byte to start dump, default current position
-    *       supressUnicode: false // Supress unicode character preview for cleaner columns
+    *       startByte: 0, // byte to start dump (default current byte position)
+    *       supressUnicode: false // Supress unicode character preview for even columns
     *   }
     * ```
     */
@@ -511,6 +830,20 @@ class bireader {
     //bit reader
     //
     /**
+    *
+    * Write bits, must have at least value and number of bits
+    *
+    * ``Note``: When returning to a byte write, remaining bits are skipped
+    *
+    * @param {number} value - value as int
+    * @param {number} bits - number of bits to write
+    * @param {boolean} unsigned - if value is unsigned
+    * @param {string} endian - ``big`` or ``little``
+    */
+    writeBit(value, bits, unsigned, endian) {
+        return (0, common_1.wbit)(this, value, bits, unsigned, endian);
+    }
+    /**
     * Bit field reader
     *
     * Note: When returning to a byte read, remaining bits are dropped
@@ -521,48 +854,7 @@ class bireader {
     * @returns number
     */
     readBit(bits, unsigned, endian) {
-        if (bits == undefined || typeof bits != "number") {
-            throw new Error("Enter number of bits to read");
-        }
-        if (bits <= 0 || bits > 32) {
-            throw new Error('Bit length must be between 1 and 32.');
-        }
-        const size_needed = ((((bits - 1) + this.bitoffset) / 8) + this.offset);
-        if (bits <= 0 || size_needed > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("Invalid number of bits to read: " + size_needed + " of " + this.size);
-        }
-        var off_in_bits = (this.offset * 8) + this.bitoffset;
-        var value = 0;
-        for (var i = 0; i < bits;) {
-            var remaining = bits - i;
-            var bitOffset = off_in_bits & 7;
-            var currentByte = this.data[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;
-        }
-        this.offset = this.offset + Math.floor(((bits) + this.bitoffset) / 8); //end byte
-        this.bitoffset = ((bits) + this.bitoffset) % 8;
-        if (unsigned == true || bits <= 7) {
-            return value >>> 0;
-        }
-        if (bits !== 32 && value & (1 << (bits - 1))) {
-            value |= -1 ^ ((1 << bits) - 1);
-        }
-        return value;
+        return (0, common_1.rbit)(this, bits, unsigned, endian);
     }
     /**
     * Bit field reader
@@ -575,7 +867,7 @@ class bireader {
     * @returns number
     */
     bit(bits, unsigned, endian) {
-        return this.readBit(bits, unsigned, endian);
+        return this.bit(bits, unsigned, endian);
     }
     /**
     * Bit field reader
@@ -583,10 +875,11 @@ class bireader {
     * Note: When returning to a byte read, remaining bits are dropped
     *
     * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
     * @returns number
     */
-    bit1(unsigned) {
-        return this.bit(1, unsigned);
+    bit1(unsigned, endian) {
+        return this.bit(1, unsigned, endian);
     }
     /**
     * Bit field reader
@@ -2602,7 +2895,7 @@ class bireader {
     * @returns number
     */
     readUBitBE(bits) {
-        return this.readBit(bits, true, "big");
+        return this.bit(bits, true, "big");
     }
     /**
     * Bit field reader
@@ -2613,7 +2906,7 @@ class bireader {
     * @returns number
     */
     ubitbe(bits) {
-        return this.readBit(bits, true, "big");
+        return this.bit(bits, true, "big");
     }
     /**
     * Bit field reader
@@ -2625,7 +2918,7 @@ class bireader {
     * @returns number
     */
     readBitBE(bits, unsigned) {
-        return this.readBit(bits, unsigned, "big");
+        return this.bit(bits, unsigned, "big");
     }
     /**
     * Bit field reader
@@ -2637,7 +2930,7 @@ class bireader {
     * @returns number
     */
     bitbe(bits, unsigned) {
-        return this.readBit(bits, unsigned, "big");
+        return this.bit(bits, unsigned, "big");
     }
     /**
     * Bit field reader
@@ -2648,7 +2941,7 @@ class bireader {
     * @returns number
     */
     readUBitLE(bits) {
-        return this.readBit(bits, true, "little");
+        return this.bit(bits, true, "little");
     }
     /**
     * Bit field reader
@@ -2659,7 +2952,7 @@ class bireader {
     * @returns number
     */
     ubitle(bits) {
-        return this.readBit(bits, true, "little");
+        return this.bit(bits, true, "little");
     }
     /**
     * Bit field reader
@@ -2671,7 +2964,7 @@ class bireader {
     * @returns number
     */
     readBitLE(bits, unsigned) {
-        return this.readBit(bits, unsigned, "little");
+        return this.bit(bits, unsigned, "little");
     }
     /**
     * Bit field reader
@@ -2683,7 +2976,7 @@ class bireader {
     * @returns number
     */
     bitle(bits, unsigned) {
-        return this.readBit(bits, unsigned, "little");
+        return this.bit(bits, unsigned, "little");
     }
     //
     //byte read
@@ -2695,15 +2988,16 @@ class bireader {
     * @returns number
     */
     readByte(unsigned) {
-        this.check_size(1);
-        var read = this.data[this.offset];
-        this.offset += 1;
-        if (unsigned == true) {
-            return read & 0xFF;
-        }
-        else {
-            return read > 127 ? read - 256 : read;
-        }
+        return (0, common_1.rbyte)(this, unsigned);
+    }
+    /**
+    * Write byte
+    *
+    * @param {number} value - value as int
+    * @param {boolean} unsigned - if the value is unsigned
+    */
+    writeByte(value, unsigned) {
+        return (0, common_1.wbyte)(this, value, unsigned);
     }
     /**
     * Read byte
@@ -2758,21 +3052,17 @@ class bireader {
     * @returns number
     */
     readInt16(unsigned, endian) {
-        this.check_size(2);
-        var read;
-        if ((endian != undefined ? endian : this.endian) == "little") {
-            read = (this.data[this.offset + 1] << 8) | this.data[this.offset];
-        }
-        else {
-            read = (this.data[this.offset] << 8) | this.data[this.offset + 1];
-        }
-        this.offset += 2;
-        if (unsigned == undefined || unsigned == false) {
-            return read & 0x8000 ? -(0x10000 - read) : read;
-        }
-        else {
-            return read & 0xFFFF;
-        }
+        return (0, common_1.rint16)(this, unsigned, endian);
+    }
+    /**
+    * Write int16
+    *
+    * @param {number} value - value as int
+    * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeInt16(value, unsigned, endian) {
+        return (0, common_1.wint16)(this, value, unsigned, endian);
     }
     /**
     * Read short
@@ -2982,34 +3272,16 @@ class bireader {
     * @returns number
     */
     readHalfFloat(endian) {
-        this.check_size(2);
-        var uint16Value = this.readInt16(true, (endian != undefined ? endian : this.endian));
-        const sign = (uint16Value & 0x8000) >> 15;
-        const exponent = (uint16Value & 0x7C00) >> 10;
-        const fraction = uint16Value & 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);
-        }
-        return floatValue;
+        return (0, common_1.rhalffloat)(this, endian);
+    }
+    /**
+    * Writes half float
+    *
+    * @param {number} value - value as int
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeHalfFloat(value, endian) {
+        return (0, common_1.whalffloat)(this, value, endian);
     }
     /**
     * Read half float
@@ -3088,21 +3360,17 @@ class bireader {
     * @returns number
     */
     readInt32(unsigned, endian) {
-        this.check_size(4);
-        var read;
-        if ((endian != undefined ? endian : this.endian) == "little") {
-            read = ((this.data[this.offset + 3] << 24) | (this.data[this.offset + 2] << 16) | (this.data[this.offset + 1] << 8) | this.data[this.offset]);
-        }
-        else {
-            read = (this.data[this.offset] << 24) | (this.data[this.offset + 1] << 16) | (this.data[this.offset + 2] << 8) | this.data[this.offset + 3];
-        }
-        this.offset += 4;
-        if (unsigned == undefined || unsigned == false) {
-            return read;
-        }
-        else {
-            return read >>> 0;
-        }
+        return (0, common_1.rint32)(this, unsigned, endian);
+    }
+    /**
+    * Write int32
+    *
+    * @param {number} value - value as int
+    * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeInt32(value, unsigned, endian) {
+        return (0, common_1.wint32)(this, value, unsigned, endian);
     }
     /**
     * Read 32 bit integer
@@ -3354,28 +3622,16 @@ class bireader {
     * @returns number
     */
     readFloat(endian) {
-        this.check_size(4);
-        var uint32Value = this.readInt32(true, (endian == undefined ? this.endian : endian));
-        // Check if the value is negative (i.e., the most significant bit is set)
-        const isNegative = (uint32Value & 0x80000000) !== 0 ? 1 : 0;
-        // Extract the exponent and fraction parts
-        const exponent = (uint32Value >> 23) & 0xFF;
-        const fraction = uint32Value & 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));
-        }
-        return floatValue;
+        return (0, common_1.rfloat)(this, endian);
+    }
+    /**
+   * Write float
+   *
+   * @param {number} value - value as int
+   * @param {string} endian - ``big`` or ``little`
+   */
+    writeFloat(value, endian) {
+        return (0, common_1.wfloat)(this, value, endian);
     }
     /**
     * Read float
@@ -3428,39 +3684,17 @@ class bireader {
     * @returns number
     */
     readInt64(unsigned, endian) {
-        this.check_size(8);
-        // Convert the byte array to a BigInt
-        let value = BigInt(0);
-        if ((endian == undefined ? this.endian : endian) == "little") {
-            for (let i = 0; i < 8; i++) {
-                value = value | BigInt(this.data[this.offset]) << BigInt(8 * i);
-                this.offset += 1;
-            }
-            if (unsigned == undefined || unsigned == false) {
-                if (value & (BigInt(1) << BigInt(63))) {
-                    value -= BigInt(1) << BigInt(64);
-                }
-                return value;
-            }
-            else {
-                return value;
-            }
-        }
-        else {
-            for (let i = 0; i < 8; i++) {
-                value = (value << BigInt(8)) | BigInt(this.data[this.offset]);
-                this.offset += 1;
-            }
-            if (unsigned == undefined || unsigned == false) {
-                if (value & (BigInt(1) << BigInt(63))) {
-                    value -= BigInt(1) << BigInt(64);
-                }
-                return value;
-            }
-            else {
-                return value;
-            }
-        }
+        return (0, common_1.rint64)(this, unsigned, endian);
+    }
+    /**
+    * Write 64 bit integer
+    *
+    * @param {number} value - value as int
+    * @param {boolean} unsigned - if the value is unsigned
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeInt64(value, unsigned, endian) {
+        return (0, common_1.wint64)(this, value, unsigned, endian);
     }
     /**
     * Read signed 64 bit integer
@@ -3659,34 +3893,17 @@ class bireader {
     * @returns number
     */
     readDoubleFloat(endian) {
-        this.check_size(8);
-        var uint64Value = this.readInt64(true, (endian == undefined ? this.endian : endian));
-        const sign = (uint64Value & 0x8000000000000000n) >> 63n;
-        const exponent = Number((uint64Value & 0x7ff0000000000000n) >> 52n) - 1023;
-        const fraction = Number(uint64Value & 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);
-        }
-        return floatValue;
+        return (0, common_1.rdfloat)(this, endian);
+    }
+    /**
+    * Writes double float
+    *
+    * @param {number} value - value as int
+    * @param {number} offset - byte offset (default last write position)
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeDoubleFloat(value, endian) {
+        return (0, common_1.wdfloat)(this, value, endian);
     }
     /**
     * Read double float
@@ -3775,126 +3992,27 @@ class bireader {
     * @return string
     */
     readString(options) {
-        var length = options && options.length;
-        var stringType = options && options.stringType || 'utf-8';
-        var terminateValue = options && options.terminateValue;
-        var lengthReadSize = options && options.lengthReadSize || 1;
-        var stripNull = options && options.stripNull || true;
-        var encoding = options && options.encoding || 'utf-8';
-        var endian = options && options.endian || this.endian;
-        var terminate = terminateValue;
-        if (length != undefined) {
-            this.check_size(length);
-        }
-        if (typeof terminateValue == "number") {
-            terminate = terminateValue & 0xFF;
-        }
-        else {
-            if (terminateValue != undefined) {
-                throw new Error("terminateValue must be a number");
-            }
-        }
-        if (stringType == 'utf-8' || stringType == 'utf-16') {
-            if (encoding == undefined) {
-                if (stringType == 'utf-8') {
-                    encoding = 'utf-8';
-                }
-                if (stringType == 'utf-16') {
-                    encoding = 'utf-16';
-                }
-            }
-            // Read the string as UTF-8 encoded untill 0 or terminateValue
-            const encodedBytes = [];
-            if (length == undefined && terminateValue == undefined) {
-                terminate = 0;
-            }
-            var read_length = 0;
-            if (length != undefined) {
-                read_length = length;
-            }
-            else {
-                read_length = this.data.length - this.offset;
-            }
-            for (let i = 0; i < read_length; i++) {
-                if (stringType === 'utf-8') {
-                    var read = this.readUByte();
-                    if (read == terminate) {
-                        break;
-                    }
-                    else {
-                        if (!(stripNull == true && read == 0)) {
-                            encodedBytes.push(read);
-                        }
-                    }
-                }
-                else {
-                    var read = this.readInt16(true, endian);
-                    var read1 = read & 0xFF;
-                    var read2 = (read >> 8) & 0xFF;
-                    if (read == terminate) {
-                        break;
-                    }
-                    else {
-                        if (!(stripNull == true && read == 0)) {
-                            encodedBytes.push(read1);
-                            encodedBytes.push(read2);
-                        }
-                    }
-                }
-            }
-            return new TextDecoder(encoding).decode(new Uint8Array(encodedBytes));
-        }
-        else if (stringType == 'pascal' || stringType == 'wide-pascal') {
-            if (encoding == undefined) {
-                if (stringType == 'pascal') {
-                    encoding = 'utf-8';
-                }
-                if (stringType == 'wide-pascal') {
-                    encoding = 'utf-16';
-                }
-            }
-            var maxBytes;
-            if (lengthReadSize == 1) {
-                maxBytes = this.readUByte();
-            }
-            else if (lengthReadSize == 2) {
-                maxBytes = this.readInt16(true, endian);
-            }
-            else if (lengthReadSize == 4) {
-                maxBytes = this.readInt32(true, endian);
-            }
-            else {
-                this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-                throw new Error("Invalid length read size: " + lengthReadSize);
-            }
-            // Read the string as Pascal or Delphi encoded
-            const encodedBytes = [];
-            for (let i = 0; i < maxBytes; i++) {
-                if (stringType == 'wide-pascal') {
-                    const read = this.readInt16(true, endian);
-                    if (!(stripNull == true && read == 0)) {
-                        encodedBytes.push(read);
-                    }
-                }
-                else {
-                    const read = this.readUByte();
-                    if (!(stripNull == true && read == 0)) {
-                        encodedBytes.push(read);
-                    }
-                }
-            }
-            var str_return;
-            if (stringType == 'wide-pascal') {
-                str_return = new TextDecoder(encoding).decode(new Uint16Array(encodedBytes));
-            }
-            else {
-                str_return = new TextDecoder(encoding).decode(new Uint8Array(encodedBytes));
-            }
-            return str_return;
-        }
-        else {
-            throw new Error('Unsupported string type: ' + stringType);
-        }
+        return (0, common_1.rstring)(this, options);
+    }
+    /**
+    * Writes string, use options object for different types
+    *
+    *
+    * @param {string} string - text string
+    * @param {object} options - options:
+    * ```javascript
+    * {
+    *  length: string.length,  //for fixed length, non-terminate value utf strings
+    *  stringType: "utf-8", //utf-8, utf-16, pascal or wide-pascal
+    *  terminateValue: 0x00, // only with stringType: "utf"
+    *  lengthWriteSize: 1, //for pascal strings. 1, 2 or 4 byte length write size
+    *  encoding: "utf-8", //TextEncoder accepted types
+    *  endian: "little", //for wide-pascal and utf-16
+    * }
+    * ```
+    */
+    writeString(string, options) {
+        return (0, common_1.wstring)(this, string, options);
     }
     /**
     * Reads string, use options object for different types