bireader 1.0.14 → 1.0.17

package/lib/esm/src/reader.js

@@ -1,41 +1,43 @@
+import { buffcheck, arraybuffcheck, extendarray, skip, goto, remove, checkSize, addData, hexDump, XOR, AND, OR, NOT, LSHIFT, RSHIFT, ADD, wbit, rbit, rbyte, wbyte, wint16, rint16, whalffloat, rhalffloat, rint32, wint32, rfloat, wfloat, wint64, rint64, rdfloat, wdfloat, wstring, rstring } from './common';
 /**
+* Binary reader, includes bitfields and strings
 *
-* byte reader, includes bitfields and strings
-*
-* @param {Buffer|Uint8Array} data - ```Buffer``` or ```Uint8Array```
-* @param {number} byteOffset - byte offset to start reader, default is 0
-* @param {number} bitOffset - bit offset to start reader, 0-7
-* @param {string} endianness - endianness ```big``` or ```little``` (default ```little```)
+* @param {Buffer|Uint8Array} data - ```Buffer``` or ```Uint8Array```. Always found in ``biwriter.data``
+* @param {number} byteOffset - Byte offset to start reader (default 0)
+* @param {number} bitOffset - Bit offset 0-7 to start reader (default 0)
+* @param {string} endianness - Endianness ```big``` or ```little``` (default ```little```)
+* @param {boolean} strict - Strict mode: if true does not extend supplied array on outside write (default true)
 */
 export class bireader {
-    check_size(read_size, read_bits) {
-        const new_off = this.offset + (read_size || 0) + Math.ceil((this.bitoffset + (read_bits || 0)) / 8);
-        if (new_off > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error(`Reader reached end of data: reading to ` + new_off + " at " + this.offset + " of " + this.size);
-        }
-    }
     isBuffer(obj) {
-        return (typeof Buffer !== 'undefined' && obj instanceof Buffer);
+        return buffcheck(obj);
     }
     isBufferOrUint8Array(obj) {
-        return obj instanceof Uint8Array || this.isBuffer(obj);
+        return arraybuffcheck(this, obj);
+    }
+    extendArray(to_padd) {
+        return extendarray(this, to_padd);
+    }
+    check_size(write_bytes, write_bit, offset) {
+        return checkSize(this, write_bytes || 0, write_bit || 0, offset || this.offset);
     }
     /**
+    * Binary reader, includes bitfields and strings
     *
-    * byte reader, includes bitfields and strings
-    *
-    * @param {Buffer|Uint8Array} data - ```Buffer``` or ```Uint8Array```
-    * @param {number} byteOffset - byte offset to start reader, default is 0
-    * @param {number} bitOffset - bit offset to start reader, 0-7
-    * @param {string} endianness - endianness ```big``` or ```little``` (default ```little```)
+    * @param {Buffer|Uint8Array} data - ```Buffer``` or ```Uint8Array```. Always found in ``biwriter.data``
+    * @param {number} byteOffset - Byte offset to start reader (default 0)
+    * @param {number} bitOffset - Bit offset 0-7 to start reader (default 0)
+    * @param {string} endianness - Endianness ```big``` or ```little``` (default ```little```)
+    * @param {boolean} strict - Strict mode: if true does not extend supplied array on outside write (default true)
     */
-    constructor(data, byteOffset, bitOffset, endianness) {
+    constructor(data, byteOffset, bitOffset, endianness, strict) {
         this.endian = "little";
         this.offset = 0;
         this.bitoffset = 0;
         this.size = 0;
+        this.strict = false;
         this.errorDump = true;
+        this.data = [];
         if (endianness != undefined && typeof endianness != "string") {
             throw new Error("Endian must be big or little");
         }
@@ -54,6 +56,14 @@ export class bireader {
         if (bitOffset != undefined) {
             this.bitoffset = bitOffset % 8;
         }
+        if (typeof strict == "boolean") {
+            this.strict = strict;
+        }
+        else {
+            if (strict != undefined) {
+                throw new Error("Strict mode must be true of false");
+            }
+        }
         if (data == undefined) {
             throw new Error("Data required");
         }
@@ -118,126 +128,98 @@ export class bireader {
     le() {
         this.endianness("little");
     }
+    //
+    // move from current position
+    //
     /**
-    * Move current read byte or bit position
+    * Offset current byte or bit position
+    * Note: Will extend array if strict mode is off and outside of max size
     *
-    * @param {number} bytes - bytes to skip
-    * @param {number} bits - bits to skip
+    * @param {number} bytes - Bytes to skip
+    * @param {number} bits - Bits to skip (0-7)
     */
     skip(bytes, bits) {
-        this.check_size(bytes || 0);
-        if ((((bytes || 0) + this.offset) + Math.ceil((this.bitoffset + (bits || 0)) / 8)) > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("Seek outside of size of data: " + this.size);
-        }
-        this.bitoffset += (bits || 0) % 8;
-        this.offset += (bytes || 0);
+        return skip(this, bytes, bits);
     }
     /**
-    * Move current read byte or bit position
+    * Offset current byte or bit position
+    * Note: Will extend array if strict mode is off and outside of max size
     *
-    * @param {number} bytes - bytes to skip
-    * @param {number} bits - bits to skip
+    * @param {number} bytes - Bytes to skip
+    * @param {number} bits - Bits to skip (0-7)
     */
-    fskip(bytes, bits) {
+    jump(bytes, bits) {
         this.skip(bytes, bits);
     }
+    //
+    // directly set current position
+    //
     /**
-    * Change current byte or bit read position
+    * Change position directly to address
+    * Note: Will extend array if strict mode is off and outside of max size
     *
-    * @param {number} byte - byte to jump to
-    * @param {number} bit - bit to jump to (0-7)
+    * @param {number} byte - byte to set to
+    * @param {number} bit - bit to set to (0-7)
     */
     goto(byte, bit) {
-        const new_size = (byte + Math.ceil((bit || 0) / 8));
-        if (new_size > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("Goto outside of size of data: goto " + new_size + " of " + this.size);
-        }
-        this.offset = byte;
-        this.bitoffset = (bit || 0) % 8;
+        return goto(this, byte, bit);
     }
     /**
-    * Change current byte or bit read position
+    * Change position directly to address
+    * Note: Will extend array if strict mode is off and outside of max size
     *
-    * @param {number} byte - byte to jump to
-    * @param {number} bit - bit to jump to (0-7)
+    * @param {number} byte - byte to set to
+    * @param {number} bit - bit to set to (0-7)
     */
     seek(byte, bit) {
-        this.goto(byte, bit);
-    }
-    /**
-    * Change current byte or bit read position
-    *
-    * @param {number} byte - byte to jump to
-    * @param {number} bit - bit to jump to (0-7)
-    */
-    fseek(byte, bit) {
-        this.goto(byte, bit);
+        return this.goto(byte, bit);
     }
     /**
-    * Change current byte or bit read position
+    * Change position directly to address
+    * Note: Will extend array if strict mode is off and outside of max size
     *
-    * @param {number} byte - byte to jump to
-    * @param {number} bit - bit to jump to (0-7)
-    */
-    jump(byte, bit) {
-        this.goto(byte, bit);
-    }
-    /**
-    * Change current byte or bit read position
-    *
-    * @param {number} byte - byte to jump to
-    * @param {number} bit - bit to jump to (0-7)
+    * @param {number} byte - byte to set to
+    * @param {number} bit - bit to set to (0-7)
     */
     pointer(byte, bit) {
-        this.goto(byte, bit);
+        return this.goto(byte, bit);
     }
     /**
-    * Change current byte or bit read position
+    * Change position directly to address
+    * Note: Will extend array if strict mode is off and outside of max size
     *
-    * @param {number} byte - byte to jump to
-    * @param {number} bit - bit to jump to (0-7)
+    * @param {number} byte - byte to set to
+    * @param {number} bit - bit to set to (0-7)
     */
     warp(byte, bit) {
-        this.goto(byte, bit);
-    }
-    /**
-    * Change current byte or bit read position
-    *
-    * @param {number} byte - byte to jump to
-    * @param {number} bit - bit to jump to (0-7)
-    */
-    fsetpos(byte, bit) {
-        this.goto(byte, bit);
+        return this.goto(byte, bit);
     }
+    //
+    //go to start
+    //
     /**
-    * Set offset to start of file
+    * Set byte and bit position to start of data
     */
     rewind() {
         this.offset = 0;
         this.bitoffset = 0;
     }
     /**
-    * Set offset to start of file
+    * Set byte and bit position to start of data
     */
     gotostart() {
         this.offset = 0;
         this.bitoffset = 0;
     }
-    /**
-    * Set offset to start of file
-    */
-    tostart() {
-        this.offset = 0;
-        this.bitoffset = 0;
-    }
+    //
+    //get position
+    //
     /**
     * Get the current byte position
     *
     * @return {number} current byte position
     */
-    ftell() {
+    tell() {
         return this.offset;
     }
     /**
@@ -245,7 +227,7 @@ export class bireader {
     *
     * @return {number} current byte position
     */
-    tell() {
+    getOffset() {
         return this.offset;
     }
     /**
@@ -253,113 +235,530 @@ export class bireader {
     *
     * @return {number} current byte position
     */
-    fgetpos() {
+    saveOffset() {
         return this.offset;
     }
     /**
-    * Get the current byte position
+    * Get the current bit position (0-7)
     *
-    * @return {number} current byte position
+    * @return {number} current bit position
     */
-    saveOffset() {
-        return this.offset;
+    tellB() {
+        return this.bitoffset;
     }
     /**
-    * Truncates array from start to current position unless supplied
-    * Note: Does not affect supplied data
-    * @param {number} startOffset - Start location, default 0
-    * @param {number} endOffset - end location, default current write position
-    * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
+    * 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
     */
-    clip(startOffset, endOffset) {
-        if ((endOffset || this.offset) > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("End offset outside of data: endOffset" + endOffset + " of " + this.size);
+    saveOffsetBit() {
+        return (this.offset * 8) + this.bitoffset;
+    }
+    //
+    //strict mode change
+    //
+    /**
+    * Disallows extending data if position is outside of max size
+    */
+    restrict() {
+        this.strict = true;
+    }
+    /**
+    * Allows extending data if position is outside of max size
+    */
+    unrestrict() {
+        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 this.data.slice(startOffset || 0, endOffset || this.offset);
+        return XOR(this, xorKey, startOffset || this.offset, endOffset || this.size, consume || false);
     }
     /**
-    * Truncates array from start to current position unless supplied
-    * Note: Does not affect supplied data
-    * @param {number} startOffset - Start location, default 0
-    * @param {number} endOffset - end location, default current write position
-    * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
+    * 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)
     */
-    crop(startOffset, endOffset) {
-        if ((endOffset || this.offset) > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("End offset outside of data: endOffset" + endOffset + " of " + this.size);
+    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 this.data.slice(startOffset || 0, endOffset || this.offset);
+        return XOR(this, XORKey, this.offset, this.offset + Length, consume || false);
     }
     /**
-    * Truncates array from start to current position unless supplied
-    * Note: Does not affect supplied data
-    * @param {number} startOffset - Start location, default 0
-    * @param {number} endOffset - end location, default current write position
-    * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
+    * 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)
     */
-    truncate(startOffset, endOffset) {
-        if ((endOffset || this.offset) > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("End offset outside of data: endOffset" + endOffset + " of " + this.size);
+    or(orKey, startOffset, endOffset, consume) {
+        var ORKey = orKey;
+        if (typeof orKey == "number") {
+            //pass
         }
-        return this.data.slice(startOffset || 0, endOffset || this.offset);
+        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 OR(this, orKey, startOffset || this.offset, endOffset || this.size, consume || false);
     }
     /**
-    * Truncates array from start to current position unless supplied
-    * Note: Does not affect supplied data
-    * @param {number} startOffset - Start location, default 0
-    * @param {number} endOffset - end location, default current write position
-    * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
+    * 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)
     */
-    slice(startOffset, endOffset) {
-        if ((endOffset || this.offset) > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("End offset outside of data: endOffset" + endOffset + " of " + this.size);
+    orThis(orKey, length, consume) {
+        var Length = length || 1;
+        var ORKey = orKey;
+        if (typeof orKey == "number") {
+            Length = length || 1;
         }
-        return this.data.slice(startOffset || 0, endOffset || this.offset);
+        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 OR(this, ORKey, this.offset, this.offset + Length, consume || false);
     }
     /**
-    * Extract array from current position to length supplied
-    * Note: Does not affect supplied data
-    * @param {number} length - length of data to copy from current offset
-    * @param {number} consume - moves offset to end of length
-    * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
+    * 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)
     */
-    extract(length, consume) {
-        if (this.offset + (length || 0) > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("End offset outside of data: at " + this.offset + " reading " + length + " of" + this.size);
+    and(andKey, startOffset, endOffset, consume) {
+        var ANDKey = andKey;
+        if (typeof andKey == "number") {
+            //pass
+        }
+        else if (typeof andKey == "string") {
+            //pass
         }
-        const extract = this.data.slice(this.offset, Number(this.offset + (length || 0)));
-        if (consume) {
-            this.offset += length;
+        else if (this.isBufferOrUint8Array(ANDKey)) {
+            //pass
         }
-        return extract;
+        else {
+            throw new Error("AND must be a number, string, Uint8Array or Buffer");
+        }
+        return 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 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 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 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 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 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 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 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 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 ADD(this, addValue, this.offset, this.offset + Length, consume || false);
+    }
+    //
+    //remove part of data
+    //
+    /**
+    * Deletes part of data from start to current byte position unless supplied, returns removed
+    * Note: Errors in strict mode
+    *
+    * @param {number} startOffset - Start location (default 0)
+    * @param {number} endOffset - End location (default current position)
+    * @param {boolean} consume - Move position to end of removed data (default false)
+    * @returns {Buffer|Uint8Array} Removed data as ``Buffer`` or ``Uint8Array``
+    */
+    delete(startOffset, endOffset, consume) {
+        return remove(this, startOffset || 0, endOffset || this.offset, consume || false, true);
+    }
+    /**
+    * Deletes part of data from start to current byte position unless supplied, returns removed
+    * Note: Errors in strict mode
+    *
+    * @param {number} startOffset - Start location (default 0)
+    * @param {number} endOffset - End location (default current position)
+    * @param {boolean} consume - Move position to end of removed data (default false)
+    * @returns {Buffer|Uint8Array} Removed data as ``Buffer`` or ``Uint8Array``
+    */
+    clip(startOffset, endOffset, consume) {
+        return remove(this, startOffset || 0, endOffset || this.offset, consume || false, true);
+    }
+    /**
+    * Deletes part of data from current byte position to supplied length, returns removed
+    * Note: Errors in strict mode
+    *
+    * @param {number} length - Length of data in bytes to remove
+    * @param {boolean} consume - Move position to end of removed data (default false)
+    * @returns {Buffer|Uint8Array} Removed data as ``Buffer`` or ``Uint8Array``
+    */
+    crop(length, consume) {
+        return remove(this, this.offset, this.offset + (length || 0), consume || false, true);
     }
     /**
-    * Extract array from current position to length supplied
+    * Deletes part of data from current position to supplied length, returns removed
+    * Note: Only works in strict mode
+    *
+    * @param {number} length - Length of data in bytes to remove
+    * @param {boolean} consume - Move position to end of removed data (default false)
+    * @returns {Buffer|Uint8Array} Removed data as ``Buffer`` or ``Uint8Array``
+    */
+    drop(length, consume) {
+        return remove(this, this.offset, this.offset + (length || 0), consume || false, true);
+    }
+    //
+    //copy out
+    //
+    /**
+    * Returns part of data from current byte position to end of data unless supplied
+    *
+    * @param {number} startOffset - Start location (default current position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move position to end of lifted data (default false)
+    * @param {number} fillValue - Byte value to to fill returned data (does NOT fill unless supplied)
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
+    */
+    lift(startOffset, endOffset, consume, fillValue) {
+        return remove(this, startOffset || this.offset, endOffset || this.size, consume || false, false, fillValue);
+    }
+    /**
+    * Returns part of data from current byte position to end of data unless supplied
+    *
+    * @param {number} startOffset - Start location (default current position)
+    * @param {number} endOffset - End location (default end of data)
+    * @param {boolean} consume - Move position to end of lifted data (default false)
+    * @param {number} fillValue - Byte value to to fill returned data (does NOT fill unless supplied)
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
+    */
+    fill(startOffset, endOffset, consume, fillValue) {
+        return remove(this, startOffset || this.offset, endOffset || this.size, consume || false, false, fillValue);
+    }
+    /**
+    * Extract data from current position to length supplied
     * Note: Does not affect supplied data
-    * @param {number} length - length of data to copy from current offset
-    * @param {number} consume - moves offset to end of length
-    * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
+    *
+    * @param {number} length - Length of data in bytes to copy from current offset
+    * @param {number} consume - Moves offset to end of length
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
     */
-    wrap(length, consume) {
-        return this.extract(length, consume);
+    extract(length, consume) {
+        return remove(this, this.offset, length || 0, consume || false, false);
     }
     /**
-    * Extract array from current position to length supplied
+    * Extract data from current position to length supplied
     * Note: Does not affect supplied data
-    * @param {number} length - length of data to copy from current offset
-    * @param {number} consume - moves offset to end of length
-    * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
+    *
+    * @param {number} length - Length of data in bytes to copy from current offset
+    * @param {number} consume - Moves offset to end of length
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
+    */
+    slice(length, consume) {
+        return remove(this, this.offset, length || 0, consume || false, false);
+    }
+    /**
+    * Extract data from current position to length supplied
+    * Note: Does not affect supplied data
+    *
+    * @param {number} length - Length of data in bytes to copy from current offset
+    * @param {number} consume - Moves offset to end of length
+    * @returns {Buffer|Uint8Array} Selected data as ```Uint8Array``` or ```Buffer```
+    */
+    wrap(length, consume) {
+        return remove(this, this.offset, length || 0, consume || false, false);
+    }
+    //
+    //insert
+    //
+    /**
+    * Inserts data into data
+    * 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 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 addData(this, data, consume || false, offset || this.offset);
+    }
+    /**
+    * Inserts data into data
+    * 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 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 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 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 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.
+    *
+    * @param {Buffer|Uint8Array} data - ```Uint8Array``` or ```Buffer``` to add to data
+    * @param {boolean} consume - Move current write position to end of data (default false)
+    */
+    unshift(data, consume) {
+        return addData(this, data, consume || false, 0);
+    }
+    /**
+    * Adds data to start of supplied data
+    * 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)
     */
-    lift(length, consume) {
-        return this.extract(length, consume);
+    prepend(data, consume) {
+        return addData(this, data, consume || false, 0);
     }
     /**
+    * Adds data to end of supplied data
+    * 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)
+    */
+    push(data, consume) {
+        return addData(this, data, consume || false, this.size);
+    }
+    /**
+    * Adds data to end of supplied data
+    * 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)
+    */
+    append(data, consume) {
+        return addData(this, data, consume || false, this.size);
+    }
+    //
+    //finishing
+    //
+    /**
     * Returns current data
+    *
     * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
     */
     get() {
@@ -367,245 +766,81 @@ export class bireader {
     }
     /**
     * Returns current data
+    *
     * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
     */
     return() {
         return this.data;
     }
     /**
-    * removes reading data
+    * removes data
     */
     end() {
-        this.data = [];
+        this.data = undefined;
     }
     /**
-    * removes reading data
+    * removes data
     */
     close() {
-        this.data = [];
+        this.data = undefined;
     }
     /**
-    * removes reading data
+    * removes data
     */
     done() {
-        this.data = [];
+        this.data = undefined;
     }
     /**
-    * removes reading data
+    * removes data
     */
     finished() {
-        this.data = [];
-    }
-    /**
-    * Turn hexdump on error off, default on
-    */
-    errorDumpOff() {
-        this.errorDump = false;
-    }
-    /**
-    * Turn hexdump on error on, default on
-    */
-    errorDumpOn() {
-        this.errorDump = true;
+        this.data = undefined;
     }
     /**
     * 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
     *   }
     * ```
     */
     hexdump(options) {
-        var length = options && options.length;
-        var startByte = options && options.startByte;
-        var supressUnicode = options && options.supressUnicode || false;
-        if ((startByte || 0) > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("Hexdump start is outside of data size: " + startByte + " of " + this.size);
-        }
-        const start = startByte || this.offset;
-        const end = Math.min(start + (length || 192), this.size);
-        if (start + (length || 0) > this.size) {
-            this.errorDump ? "[Error], hexdump:\n" + this.hexdump() : "";
-            throw new Error("Hexdump amount is outside of data size: " + (start + (length || 0)) + " of " + end);
-        }
-        function hex_check(byte, bits) {
-            var value = 0;
-            for (var i = 0; i < bits;) {
-                var remaining = bits - i;
-                var bitOffset = 0;
-                var currentByte = byte;
-                var read = Math.min(remaining, 8 - bitOffset);
-                var mask, readBits;
-                mask = ~(0xFF << read);
-                readBits = (currentByte >> (8 - read - bitOffset)) & mask;
-                value <<= read;
-                value |= readBits;
-                i += read;
-            }
-            value = value >>> 0;
-            return value;
-        }
-        const rows = [];
-        var header = "   0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F  ";
-        var ending = "0123456789ABCDEF";
-        var addr = "";
-        for (let i = start; i < end; i += 16) {
-            addr = i.toString(16).padStart(5, '0');
-            var row = this.data?.slice(i, i + 16) || [];
-            var hex = Array.from(row, (byte) => byte.toString(16).padStart(2, '0')).join(' ');
-            rows.push(`${addr}  ${hex.padEnd(47)}  `);
-        }
-        let result = '';
-        let make_wide = false;
-        let i = start;
-        while (i < end) {
-            const byte = this.data[i];
-            if (byte < 32 || byte == 127) {
-                result += '.';
-            }
-            else if (byte < 127) {
-                // Valid UTF-8 start byte or single-byte character
-                // Convert the byte to a character and add it to the result
-                result += String.fromCharCode(byte);
-            }
-            else if (supressUnicode) {
-                result += '.';
-            }
-            else if (hex_check(byte, 1) == 0) {
-                //Byte 1
-                result += String.fromCharCode(byte);
-            }
-            else if (hex_check(byte, 3) == 6) {
-                //Byte 2
-                if (i + 1 <= end) {
-                    //check second byte
-                    const byte2 = this.data[i + 1];
-                    if (hex_check(byte2, 2) == 2) {
-                        const charCode = ((byte & 0x1f) << 6) | (byte2 & 0x3f);
-                        i++;
-                        make_wide = true;
-                        const read = " " + String.fromCharCode(charCode);
-                        result += read;
-                    }
-                    else {
-                        result += ".";
-                    }
-                }
-                else {
-                    result += ".";
-                }
-            }
-            else if (hex_check(byte, 4) == 14) {
-                //Byte 3
-                if (i + 1 <= end) {
-                    //check second byte
-                    const byte2 = this.data[i + 1];
-                    if (hex_check(byte2, 2) == 2) {
-                        if (i + 2 <= end) {
-                            //check third byte
-                            const byte3 = this.data[i + 2];
-                            if (hex_check(byte3, 2) == 2) {
-                                const charCode = ((byte & 0x0f) << 12) |
-                                    ((byte2 & 0x3f) << 6) |
-                                    (byte3 & 0x3f);
-                                i += 2;
-                                make_wide = true;
-                                const read = "  " + String.fromCharCode(charCode);
-                                result += read;
-                            }
-                            else {
-                                i++;
-                                result += " .";
-                            }
-                        }
-                        else {
-                            i++;
-                            result += " .";
-                        }
-                    }
-                    else {
-                        result += ".";
-                    }
-                }
-                else {
-                    result += ".";
-                }
-            }
-            else if (hex_check(byte, 5) == 28) {
-                //Byte 4
-                if (i + 1 <= end) {
-                    //check second byte
-                    const byte2 = this.data[i + 1];
-                    if (hex_check(byte2, 2) == 2) {
-                        if (i + 2 <= end) {
-                            //check third byte
-                            const byte3 = this.data[i + 2];
-                            if (hex_check(byte3, 2) == 2) {
-                                if (i + 3 <= end) {
-                                    //check fourth byte
-                                    const byte4 = this.data[i + 2];
-                                    if (hex_check(byte4, 2) == 2) {
-                                        const charCode = (((byte4 & 0xFF) << 24) | ((byte3 & 0xFF) << 16) | ((byte2 & 0xFF) << 8) | (byte & 0xFF));
-                                        i += 3;
-                                        make_wide = true;
-                                        const read = "   " + String.fromCharCode(charCode);
-                                        result += read;
-                                    }
-                                    else {
-                                        i += 2;
-                                        result += "  .";
-                                    }
-                                }
-                                else {
-                                    i += 2;
-                                    result += "  .";
-                                }
-                            }
-                            else {
-                                i++;
-                                result += " .";
-                            }
-                        }
-                        else {
-                            i++;
-                            result += " .";
-                        }
-                    }
-                    else {
-                        result += ".";
-                    }
-                }
-                else {
-                    result += ".";
-                }
-            }
-            else {
-                // Invalid UTF-8 byte, add a period to the result
-                result += '.';
-            }
-            i++;
-        }
-        const chunks = result.match(new RegExp(`.{1,${16}}`, 'g'));
-        chunks?.forEach((self, i) => {
-            rows[i] = rows[i] + (make_wide ? "|" + self + "|" : self);
-        });
-        header = "".padStart(addr.length) + header + (make_wide ? "" : ending);
-        rows.unshift(header);
-        if (make_wide) {
-            rows.push("*Removed character byte header on unicode detection");
-        }
-        console.log(rows.join("\n"));
+        return hexDump(this, options);
+    }
+    /**
+    * Turn hexdump on error off (default on)
+    */
+    errorDumpOff() {
+        this.errorDump = false;
+    }
+    /**
+    * Turn hexdump on error on (default on)
+    */
+    errorDumpOn() {
+        this.errorDump = true;
     }
     //
     //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 wbit(this, value, bits, unsigned, endian);
+    }
+    /**
     * Bit field reader
     *
     * Note: When returning to a byte read, remaining bits are dropped
@@ -616,48 +851,7 @@ export 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 rbit(this, bits, unsigned, endian);
     }
     /**
     * Bit field reader
@@ -670,7 +864,7 @@ export class bireader {
     * @returns number
     */
     bit(bits, unsigned, endian) {
-        return this.readBit(bits, unsigned, endian);
+        return this.bit(bits, unsigned, endian);
     }
     /**
     * Bit field reader
@@ -678,10 +872,11 @@ export 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
@@ -2697,7 +2892,7 @@ export class bireader {
     * @returns number
     */
     readUBitBE(bits) {
-        return this.readBit(bits, true, "big");
+        return this.bit(bits, true, "big");
     }
     /**
     * Bit field reader
@@ -2708,7 +2903,7 @@ export class bireader {
     * @returns number
     */
     ubitbe(bits) {
-        return this.readBit(bits, true, "big");
+        return this.bit(bits, true, "big");
     }
     /**
     * Bit field reader
@@ -2720,7 +2915,7 @@ export class bireader {
     * @returns number
     */
     readBitBE(bits, unsigned) {
-        return this.readBit(bits, unsigned, "big");
+        return this.bit(bits, unsigned, "big");
     }
     /**
     * Bit field reader
@@ -2732,7 +2927,7 @@ export class bireader {
     * @returns number
     */
     bitbe(bits, unsigned) {
-        return this.readBit(bits, unsigned, "big");
+        return this.bit(bits, unsigned, "big");
     }
     /**
     * Bit field reader
@@ -2743,7 +2938,7 @@ export class bireader {
     * @returns number
     */
     readUBitLE(bits) {
-        return this.readBit(bits, true, "little");
+        return this.bit(bits, true, "little");
     }
     /**
     * Bit field reader
@@ -2754,7 +2949,7 @@ export class bireader {
     * @returns number
     */
     ubitle(bits) {
-        return this.readBit(bits, true, "little");
+        return this.bit(bits, true, "little");
     }
     /**
     * Bit field reader
@@ -2766,7 +2961,7 @@ export class bireader {
     * @returns number
     */
     readBitLE(bits, unsigned) {
-        return this.readBit(bits, unsigned, "little");
+        return this.bit(bits, unsigned, "little");
     }
     /**
     * Bit field reader
@@ -2778,7 +2973,7 @@ export class bireader {
     * @returns number
     */
     bitle(bits, unsigned) {
-        return this.readBit(bits, unsigned, "little");
+        return this.bit(bits, unsigned, "little");
     }
     //
     //byte read
@@ -2790,15 +2985,16 @@ export 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 rbyte(this, unsigned);
+    }
+    /**
+    * Write byte
+    *
+    * @param {number} value - value as int
+    * @param {boolean} unsigned - if the value is unsigned
+    */
+    writeByte(value, unsigned) {
+        return wbyte(this, value, unsigned);
     }
     /**
     * Read byte
@@ -2853,21 +3049,17 @@ export 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 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 wint16(this, value, unsigned, endian);
     }
     /**
     * Read short
@@ -3077,34 +3269,16 @@ export 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 rhalffloat(this, endian);
+    }
+    /**
+    * Writes half float
+    *
+    * @param {number} value - value as int
+    * @param {string} endian - ``big`` or ``little`
+    */
+    writeHalfFloat(value, endian) {
+        return whalffloat(this, value, endian);
     }
     /**
     * Read half float
@@ -3183,21 +3357,17 @@ export 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 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 wint32(this, value, unsigned, endian);
     }
     /**
     * Read 32 bit integer
@@ -3449,28 +3619,16 @@ export 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 rfloat(this, endian);
+    }
+    /**
+   * Write float
+   *
+   * @param {number} value - value as int
+   * @param {string} endian - ``big`` or ``little`
+   */
+    writeFloat(value, endian) {
+        return wfloat(this, value, endian);
     }
     /**
     * Read float
@@ -3523,39 +3681,17 @@ export 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 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 wint64(this, value, unsigned, endian);
     }
     /**
     * Read signed 64 bit integer
@@ -3754,34 +3890,17 @@ export 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 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 wdfloat(this, value, endian);
     }
     /**
     * Read double float
@@ -3870,127 +3989,45 @@ export 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 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 wstring(this, string, options);
     }
+    /**
+    * Reads string, use options object for different types
+    *
+    * @param {object} options
+    * ```javascript
+    * {
+    *  length: number, //for fixed length, non-terminate value utf strings
+    *  stringType: "utf-8", //utf-8, utf-16, pascal or wide-pascal
+    *  terminateValue: 0x00, // only for non-fixed length utf strings
+    *  lengthReadSize: 1, //for pascal strings. 1, 2 or 4 byte length read size
+    *  stripNull: true, // removes 0x00 characters
+    *  encoding: "utf-8", //TextEncoder accepted types
+    *  endian: "little", //for wide-pascal and utf-16
+    * }
+    * ```
+    * @return string
+    */
     string(options) {
         return this.readString(options);
     }