bireader 1.0.12 → 1.0.14

package/lib/esm/src/reader.js

@@ -11,7 +11,8 @@ 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) {
-            throw new Error(`Reader reached end of data.`);
+            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) {
@@ -34,6 +35,7 @@ export class bireader {
         this.offset = 0;
         this.bitoffset = 0;
         this.size = 0;
+        this.errorDump = true;
         if (endianness != undefined && typeof endianness != "string") {
             throw new Error("Endian must be big or little");
         }
@@ -125,6 +127,7 @@ export class bireader {
     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;
@@ -146,8 +149,10 @@ export class bireader {
     * @param {number} bit - bit to jump to (0-7)
     */
     goto(byte, bit) {
-        if ((byte + Math.ceil((bit || 0) / 8)) > this.size) {
-            throw new Error("Goto outside of size of data: " + this.size);
+        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;
@@ -252,6 +257,14 @@ export class bireader {
         return this.offset;
     }
     /**
+    * Get the current byte position
+    *
+    * @return {number} current byte position
+    */
+    saveOffset() {
+        return this.offset;
+    }
+    /**
     * Truncates array from start to current position unless supplied
     * Note: Does not affect supplied data
     * @param {number} startOffset - Start location, default 0
@@ -259,6 +272,10 @@ export class bireader {
     * @returns {Buffer|Uint8Array} ``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);
     }
     /**
@@ -269,6 +286,10 @@ export class bireader {
     * @returns {Buffer|Uint8Array} ``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);
     }
     /**
@@ -279,6 +300,10 @@ export class bireader {
     * @returns {Buffer|Uint8Array} ``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);
     }
     /**
@@ -289,43 +314,49 @@ export class bireader {
     * @returns {Buffer|Uint8Array} ``Buffer`` or ``Uint8Array``
     */
     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);
     }
     /**
     * 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``
     */
-    extract(length) {
+    extract(length, consume) {
         if (this.offset + (length || 0) > this.size) {
-            throw new Error("End offset outside of data: " + 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);
         }
-        return this.data.slice(this.offset, this.offset + (length || 0));
+        const extract = this.data.slice(this.offset, Number(this.offset + (length || 0)));
+        if (consume) {
+            this.offset += length;
+        }
+        return extract;
     }
     /**
     * 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``
     */
-    wrap(length) {
-        if (this.offset + (length || 0) > this.size) {
-            throw new Error("End offset outside of data: " + this.size);
-        }
-        return this.data.slice(this.offset, this.offset + (length || 0));
+    wrap(length, consume) {
+        return this.extract(length, consume);
     }
     /**
     * 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``
     */
-    lift(length) {
-        if (this.offset + (length || 0) > this.size) {
-            throw new Error("End offset outside of data: " + this.size);
-        }
-        return this.data.slice(this.offset, this.offset + (length || 0));
+    lift(length, consume) {
+        return this.extract(length, consume);
     }
     /**
     * Returns current data
@@ -365,6 +396,212 @@ export class bireader {
     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;
+    }
+    /**
+    * Console logs data as hex dump
+    *
+    * @param {object} options - options object
+    * ```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
+    *   }
+    * ```
+    */
+    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"));
+    }
     //
     //bit reader
     //
@@ -387,6 +624,7 @@ export class bireader {
         }
         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;
@@ -413,7 +651,7 @@ export class bireader {
         }
         this.offset = this.offset + Math.floor(((bits) + this.bitoffset) / 8); //end byte
         this.bitoffset = ((bits) + this.bitoffset) % 8;
-        if (unsigned == true) {
+        if (unsigned == true || bits <= 7) {
             return value >>> 0;
         }
         if (bits !== 32 && value & (1 << (bits - 1))) {
@@ -435,13 +673,13 @@ export class bireader {
         return this.readBit(bits, unsigned, endian);
     }
     /**
-* Bit field reader
-*
-* Note: When returning to a byte read, remaining bits are dropped
-*
-* @param {boolean} unsigned - if the value is unsigned
-* @returns number
-*/
+    * Bit field reader
+    *
+    * Note: When returning to a byte read, remaining bits are dropped
+    *
+    * @param {boolean} unsigned - if the value is unsigned
+    * @returns number
+    */
     bit1(unsigned) {
         return this.bit(1, unsigned);
     }
@@ -3721,6 +3959,7 @@ export class bireader {
                 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