bireader 1.0.14 → 1.0.15

package/lib/cjs/src/reader.js

@@ -1,44 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bireader = void 0;
+const common_1 = require("./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)
 */
 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);
     }
     isBufferOrUint8Array(obj) {
         return obj instanceof Uint8Array || this.isBuffer(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]);
+        }
+    }
+    check_size(read_size, read_bits) {
+        return (0, common_1.checkSize)(this, read_size || 0, read_bits || 0, 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");
         }
@@ -57,6 +66,14 @@ 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");
         }
@@ -121,126 +138,98 @@ 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 (0, common_1.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 (0, common_1.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;
     }
     /**
@@ -248,7 +237,7 @@ class bireader {
     *
     * @return {number} current byte position
     */
-    tell() {
+    getOffset() {
         return this.offset;
     }
     /**
@@ -256,113 +245,204 @@ class bireader {
     *
     * @return {number} current byte position
     */
-    fgetpos() {
+    saveOffset() {
         return this.offset;
     }
+    //
+    //strict mode change
+    //
     /**
-    * Get the current byte position
+    * 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;
+    }
+    //
+    //remove part of data
+    //
+    /**
+    * Deletes part of data from start to current byte position unless supplied, returns removed
+    * Note: Errors in strict mode
     *
-    * @return {number} current byte position
+    * @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``
     */
-    saveOffset() {
-        return this.offset;
+    delete(startOffset, endOffset, consume) {
+        return (0, common_1.remove)(this, startOffset || 0, endOffset || this.offset, consume || false, true);
     }
     /**
-    * 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``
+    * 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) {
-        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);
-        }
-        return this.data.slice(startOffset || 0, endOffset || this.offset);
+    clip(startOffset, endOffset, consume) {
+        return (0, common_1.remove)(this, startOffset || 0, endOffset || this.offset, consume || false, true);
     }
     /**
-    * 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``
+    * 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(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);
-        }
-        return this.data.slice(startOffset || 0, endOffset || this.offset);
+    crop(length, consume) {
+        return (0, common_1.remove)(this, this.offset, this.offset + (length || 0), consume || false, true);
     }
     /**
-    * 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``
+    * 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``
     */
-    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);
-        }
-        return this.data.slice(startOffset || 0, endOffset || this.offset);
+    drop(length, consume) {
+        return (0, common_1.remove)(this, this.offset, this.offset + (length || 0), consume || false, true);
     }
+    //
+    //copy out
+    //
     /**
-    * 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``
+    * 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```
     */
-    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);
-        }
-        return this.data.slice(startOffset || 0, endOffset || this.offset);
+    lift(startOffset, endOffset, consume, fillValue) {
+        return (0, common_1.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 (0, common_1.remove)(this, startOffset || this.offset, endOffset || this.size, consume || false, false, fillValue);
     }
     /**
-    * 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```
     */
     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);
-        }
-        const extract = this.data.slice(this.offset, Number(this.offset + (length || 0)));
-        if (consume) {
-            this.offset += length;
-        }
-        return extract;
+        return (0, common_1.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```
     */
-    wrap(length, consume) {
-        return this.extract(length, consume);
+    slice(length, consume) {
+        return (0, common_1.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```
+    */
+    wrap(length, consume) {
+        return (0, common_1.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 write position to end of data (default false)
+    * @param {number} offset - Offset to add it at (defaults to current position)
+    */
+    insert(data, consume, offset) {
+        return (0, common_1.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 write position to end of data (default false)
+    * @param {number} offset - Offset to add it at (defaults to current position)
+    */
+    place(data, consume, offset) {
+        return (0, common_1.addData)(this, data, consume || false, offset || this.offset);
+    }
+    /**
+    * 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 (0, common_1.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)
+    */
+    prepend(data, consume) {
+        return (0, common_1.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)
     */
-    lift(length, consume) {
-        return this.extract(length, consume);
+    push(data, consume) {
+        return (0, common_1.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 (0, common_1.addData)(this, data, consume || false, this.size);
+    }
+    //
+    //finishing
+    //
+    /**
     * Returns current data
+    *
     * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
     */
     get() {
@@ -370,46 +450,35 @@ 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
@@ -424,186 +493,19 @@ class bireader {
     * ```
     */
     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 (0, common_1.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
@@ -3994,6 +3896,23 @@ class bireader {
             throw new Error('Unsupported string type: ' + stringType);
         }
     }
+    /**
+    * 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);
     }