@opcua/for-node-red 3.34.2 → 3.36.0

package/node_modules/@sterfive/opcua-pinned/node_modules/{hexy → node-opcua-debug/node_modules/hexy}/hexy.js

@@ -24,6 +24,7 @@
 // 
 // but you can configure:
 // 
+//   * Line numbering
 //   * Line width
 //   * Format of byte grouping
 //   * The case (upper/lower) of hex decimals
@@ -58,50 +59,46 @@
 // 
 // ## Formatting Options
 // 
-// Formatting options are configured by passing a `config` object to the `hexy` function:
-// 
-// var config: {
-//   bytesPerLine = n,   // how many bytes per line, default 16
-//   bytesPerGroup = g,  // [0, 1, 2, 4, 8], number of bytes per group
-//                       // 0 = no delimiters, default 1
-//   showAddress = true, // show address at start of line, default true
-//   radix = b,          // [2, 8, 10, 16], the radix for numeral representation
-//                       // for the right column, default 16
-//   littleEndian = true,// endianness of data, default false
-//                       // applies when bytesPerGroup > 1
-//   extendedChs = true, // allow displaying more characters in the text column
-//                       // default false
-//   caps = c,           // ["lower"|"upper"], default lower
-//   annotate = a,       // ["ascii"|"none"], ascii annotation at end of line?
-//                       // default "ascii"
-//   prefix = p,         // <string> something pretty to put in front of each line
-//                       // default ""
-//   indent = i,         // <num> number of spaces to indent every output line
-//                       // default 0
-//   html = true,        // funky html divs 'n stuff! experimental.
-//                       // default: false
-//   offset = X,         // generate hexdump based on X byte offset
-//                       // into the provided source
-//                       // default 0
-//   length = Y,         // process Y bytes of the provide source 
-//                       // starting at `offset`. -1 for all
-//                       // default -1
-//   displayOffset = Z,  // add Z to the address prepended to each line
-//                       // (note, even if `offset` is provided, addressing
-//                       // is started at 0)
-//                       // default 0
-//
-//   // DEPRECATED (but still supported for backward compatibility):
-//   width = n,          // deprecated, use bytesPerLine instead
-//   format = f,         // deprecated, use bytesPerGroup instead
-//                       // ["none"|"twos"|"fours"|"eights"|"sixteens"]
-//   numbering = n,      // deprecated, use showAddress instead
-//                       // ["hex_bytes"|"none"]
-//   display_offset = Z, // deprecated, use displayOffset instead
-// };
-// 
-// console.log(hexy.hexy(buffer, config));
+// Formatting options are configured by passing a `format` object to the `hexy` function:
+// 
+//```javascript
+//var format = {}
+//    format.width = width // how many bytes per line, default 16
+//    format.numbering = n // ["hex_bytes" | "none"],  default "hex_bytes"
+//    format.radix = b     // [2, 8, 10, 16], the radix for numeral representation
+//                         // for the right column,    default 16
+//    format.format = f    // ["twos"|"fours"|"eights"|"sixteens"|"none"], number of nibbles per group
+//                         //                          default "fours"
+//    format.littleEndian = true
+//                         // endiannes of data,       default false
+//                         // counts when number of nibbles is more than "twos",
+//                         // i.e. displaying groups bigger than one byte
+//    format.extendedChs = true
+//                         // allow displaying more characters in the text column
+//                         //                          default false
+//    format.caps = c      // ["lower"|"upper"],       default lower
+//    format.annotate = a  // ["ascii"|"none"], ascii annotation at end of line?
+//                         //                          default "ascii"
+//    format.prefix = p    // <string> something pretty to put in front of each line
+//                         //                          default ""
+//    format.indent = i    // <num> number of spaces to indent
+//                         //                          default 0
+//    format.html = true   // funky html divs 'n stuff! experimental.
+//                         //                          default: false
+//    format.offset = X    // generate hexdump based on X byte offset
+//                         // into the provided source
+//                         //                          default 0
+//    format.length = Y    // process Y bytes of the provide source 
+//                         // starting at `offset`. -1 for all
+//                         //                          default -1
+//    format.display_offset = Z
+//                         // add Z to the address prepended to each line
+//                         // (note, even if `offset` is provided, addressing
+//                         // is started at 0)
+//                         //                          default 0
 //
+//console.log(hexy.hexy(buffer, format))
+//``` 
 // In case you're really nerdy, you'll have noticed that the defaults correspond
 // to how `xxd` formats its output.
 //            
@@ -183,20 +180,15 @@
 // * Koen Houtman (https://github.com/automagisch)
 // * Stef Levesque (https://github.com/stef-levesque)
 // * Abdulaziz Ghuloum (https://github.com/azizghuloum)
-// * rom-p (https://github.com/rom-p) for fixing issue #24
 // 
 // ## History
 // 
-// This started a fairly straightforward port of `hexy.rb` which does more or less the same thing. You can find it here:
+// This is a fairly straightforward port of `hexy.rb` which does more or less the
+// same thing. You can find it here: 
 //  
 //     http://github.com/a2800276/hexy
 //  
-//
-// ### 0.4.0 (updating the minor version: the API changes, see below)
-//
-// * the init parameters no longer contain strings: all params are scalar-defined
-// * names of parameters have been changed to be more consistent
-// * defaults to single-byte grouping
+// in case these sorts of things interest you.
 //
 // ### 0.3.4
 //
@@ -233,7 +225,14 @@
 //
 // * adds typescript support. Thanks Abdulaziz!
 // * remove support for old node versions (0.6-0.12)
+// 
+// ## Mail
+// 
+// In case you discover bugs, spelling errors, offer suggestions for
+// improvements or would like to help out with the project, you can contact
+// me directly (tim@kuriositaet.de). 
 
+(function (arg) {
 
 var hexy = function(buffer, config) {
   const h = new Hexy(buffer, config)
@@ -246,61 +245,45 @@ var Hexy = function(buffer, config) {
 
   // if we have a Buffer class, convert
   if (typeof Buffer !== 'undefined') {
-    buffer = (Buffer.isBuffer(buffer) && buffer)
+    buffer = (Buffer.isBuffer(buffer) && buffer) 
       || (typeof buffer === 'string' && Buffer.from(buffer)) 
       || (buffer && (buffer.constructor === Array) && Buffer.from(buffer)) // accept num arrays
-      || (buffer instanceof Uint8Array && new TextDecoder().decode(buffer))
       || Buffer.alloc(0)
   }
   buffer = buffer || []
   config = config || {}
-
-  // Backward compatibility: map old parameter names to new ones
-  if ('width' in config && !('bytesPerLine' in config)) {
-    config.bytesPerLine = config.width
-  }
-  if ('numbering' in config && !('showAddress' in config)) {
-    config.showAddress = config.numbering !== "none"
-  }
-  if ('format' in config && !('bytesPerGroup' in config)) {
-    // Map old string-based format to numeric bytesPerGroup
-    const formatMap = {
-      "none": 0,
-      "twos": 1,
-      "fours": 2,
-      "eights": 4,
-      "sixteens": 8
-    }
-    config.bytesPerGroup = formatMap[config.format] !== undefined ? formatMap[config.format] : 2
-  }
-  if ('display_offset' in config && !('displayOffset' in config)) {
-    config.displayOffset = config.display_offset
+ 
+  self.buffer         = buffer // magic string conversion here?
+  self.bytes_per_line = parseInt(config.width) || 16 // formerly `width`
+  self.numbering      = config.numbering == "none" ? "none" : "hex_bytes"
+
+  self.bytes_per_group = 2  // by default (not handled below) "fours" will fold into `bytes_per_group == 2`
+  switch (config.format) {
+    case "none":
+      self.bytes_per_group = 0 // one byte per group, but no delimiters
+      break
+    case "twos":
+      self.bytes_per_group = 1
+      break
+    case "eights":
+      self.bytes_per_group = 4
+      break
+    case "sixteens":
+      self.bytes_per_group = 8
+      break
   }
-
-  this.buffer         = buffer // magic string conversion here?
-
-  self.bytesPerLine   = 'bytesPerLine' in config ? parseInt(config.bytesPerLine) : 16
-  self.bytesPerGroup  = 'bytesPerGroup' in config ? parseInt(config.bytesPerGroup) : 2
-  self.showAddress    = 'showAddress' in config ? config.showAddress : true
+                                                                                                   
   self.littleEndian   = config.littleEndian   || false
   self.radix          = config.radix          || 16
   self.caps           = config.caps           == "upper" ? "upper" : "lower"
   self.annotate       = config.annotate       == "none"  ? "none"  : "ascii"
   self.prefix         = config.prefix         || ""
   self.indent         = config.indent         || 0
+  self.html           = config.html           || false
   self.offset         = config.offset         || 0
-  self.displayOffset  = config.displayOffset  || 0
   self.length         = config.length         || -1
   self.extendedChs    = config.extendedChs    || false
-  self.html           = config.html           || false
-
-  if (isNaN(self.bytesPerLine) || self.bytesPerLine < 1 || self.bytesPerLine > 256) {
-    self.bytesPerLine = 16
-  }
-
-  if (![0, 1, 2, 4, 8].includes(self.bytesPerGroup)) {
-    self.bytesPerGroup = 1
-  }
+  self.display_offset = config.display_offset || 0
 
   if (self.offset) {
     if (self.offset < self.buffer.length) {
@@ -316,33 +299,33 @@ var Hexy = function(buffer, config) {
 
   self.prefix = (self.html ? "&nbsp;" : " ").repeat(self.indent) + self.prefix
 
-  self.hex_line_length = (maxnumberlen(self.bytesPerGroup, self.radix)) * self.bytesPerLine
-                        / Math.max(self.bytesPerGroup, 1)
-  switch (self.bytesPerGroup) {   // the original code (now documented in the tests),
+  self.hex_line_length = (maxnumberlen(self.bytes_per_group, self.radix)) * self.bytes_per_line
+                        / Math.max(self.bytes_per_group, 1)
+  switch (self.bytes_per_group) { // the original code (now documented in the tests),
       case 8:                     // some modes had mode-dependent number of extra spaces at the end of the line
       case 4:
       case 2:
-        self.hex_line_length += Math.floor(self.bytesPerLine / self.bytesPerGroup)
+        self.hex_line_length += Math.floor(self.bytes_per_line / self.bytes_per_group)
         break
       case 1:
-        self.hex_line_length += self.bytesPerLine + 3
+        self.hex_line_length += self.bytes_per_line + 3
         break
       case 0:
         self.hex_line_length += 2
         break
   }
-  self.bytesPerGroup = Math.min(self.bytesPerGroup, self.bytesPerLine)
+  self.bytes_per_group = Math.min(self.bytes_per_group, self.bytes_per_line)
 
   this.toString = function() {
     var str = ""
-    var addr = self.offset + self.displayOffset
+    var addr = self.offset + self.display_offset
     var odd = false
 
     if (self.html) { str += "<div class='hexy'>\n" }
 
     // each `slice` is a single output line:
-    for (var start = 0; start < self.buffer.length; start += self.bytesPerLine) {
-      const end = Math.min(start + self.bytesPerLine, self.buffer.length)
+    for (var start = 0; start < self.buffer.length; start += self.bytes_per_line) {
+      const end = Math.min(start + self.bytes_per_line, self.buffer.length)
       const slice = self.buffer.slice(start, end)
 
       if (self.html) {
@@ -352,12 +335,12 @@ var Hexy = function(buffer, config) {
       str += self.prefix
 
       // the address column:
-      if (self.showAddress) {
+      if (self.numbering === "hex_bytes") {
         str += num2str(addr, MAX_ADDRESS_LENGTH, 16) + ": "
       }
 
       // the binary representation column:
-      str += hex(slice, self.bytesPerLine, self.bytesPerGroup, self.radix, self.littleEndian)
+      str += hex(slice, self.bytes_per_line, self.bytes_per_group, self.radix, self.littleEndian)
 
       // the text representation column:
       if (self.annotate === "ascii") {
@@ -375,7 +358,7 @@ var Hexy = function(buffer, config) {
         str += " " + (self.html ? html_escape(text) : ascii_escape(text))
       }
       str += self.html ? "</div>\n" : "\n"
-      addr += self.bytesPerLine
+      addr += self.bytes_per_line
     }
 
     if (self.html) { str += "</div>\n" }
@@ -383,36 +366,30 @@ var Hexy = function(buffer, config) {
   }
 
   // renders the binary representation of individual line
-  var hex = function(buffer, bytesPerLine, bytesPerGroup, radix, littleEndian) {
+  var hex = function(buffer, bytes_per_line, bytes_per_group, radix, littleEndian) {
     var str = ""
-    const delimiter = bytesPerGroup == 0 ? "" : " "
-    var group_len = maxnumberlen(bytesPerGroup, radix)  // this changes for the very last group in the file
-    const padlen = (bytesPerLine - buffer.length) * (bytesPerGroup == 0 ? group_len: (group_len + 1) / bytesPerGroup)
-    if (bytesPerGroup == 0) {
-      bytesPerGroup = 1
+    const delimiter = bytes_per_group == 0 ? "" : " "
+    const group_len = maxnumberlen(bytes_per_group, radix)
+    const padlen = (bytes_per_line - buffer.length) * (bytes_per_group == 0 ? group_len: (group_len + 1) / bytes_per_group)
+    if (bytes_per_group == 0) {
+      bytes_per_group = 1
     }
-    const start = littleEndian ? bytesPerGroup - 1 : 0
-    const end   = littleEndian ? -1 : bytesPerGroup
+    const start = littleEndian ? bytes_per_group - 1 : 0
+    const end   = littleEndian ? -1 : bytes_per_group
     const step  = littleEndian ? -1 : 1
-    for (var group = 0; group < buffer.length / bytesPerGroup; ++group) {
-      var val = bytesPerGroup < 4 ? 0 : BigInt(0)
-      var bytes_in_group = 0  // count how many bytes we actually have in this group
+    for (var group = 0; group < buffer.length / bytes_per_group; ++group) {
+      var val = bytes_per_group < 4 ? 0 : BigInt(0)
       for (var ii = start; ii != end; ii += step) {
-        const i = group * bytesPerGroup + ii
-        if (i >= buffer.length) { // dangling bytes
-          continue
+        const i = group * bytes_per_group + ii
+        if (i >= buffer.length) { // not rendering dangling bytes.  TODO: render them as smaller grouping
+          break
         }
-        bytes_in_group++
-        if (bytesPerGroup < 4) {
+        if (bytes_per_group < 4) {
           val = val * 256 + ((buffer.constructor == String ? buffer.codePointAt(i) : buffer[i]) & 0xff)
         } else {
           val = BigInt(val) * BigInt(256) + BigInt(((buffer.constructor == String ? buffer.codePointAt(i) : buffer[i]) & 0xff))
         }
       }
-      // For incomplete groups, adjust group_len based on actual bytes present
-      if (bytes_in_group < bytesPerGroup) {
-        group_len = maxnumberlen(bytes_in_group, radix)
-      }
       const text = val.toString(radix)
       for (var c = 0; c < group_len - text.length; c++) {
         str += "0"
@@ -423,7 +400,7 @@ var Hexy = function(buffer, config) {
         str = str.toUpperCase()
       }
     }
-    if (buffer.length < bytesPerLine) {
+    if (buffer.length < bytes_per_line) {
       str += (self.html ? "&nbsp;": " ").repeat(padlen)
     }
     str = rpad(str, self.hex_line_length)
@@ -469,10 +446,8 @@ var Hexy = function(buffer, config) {
   }
 }
 
-Hexy.VERSION = "0.4.0"
-
+Hexy.VERSION = "0.3.4"
 
-// Deprecated: maxnumberlen is an internal helper and will be removed in a future release.
 var maxnumberlen = function(bytes, radix) {
   var result = 2
   if (bytes == 0) {
@@ -521,13 +496,25 @@ var maxnumberlen = function(bytes, radix) {
   return result
 }
 
-// Browser global scope support (for file:// protocol and legacy usage)
-if (typeof window !== 'undefined') {
-  window.hexy = hexy;
-  window.Hexy = Hexy;
-  window.maxnumberlen = maxnumberlen;
+
+// This is probably not the prettiest or coolest way to to determine runtime
+// environment. It seems to work and I'm not up to the task figuring out what
+// the module system du jour is and how to interface with it ...
+
+// If anyone wants to fix this to include this module "properly", I'm more than
+// happy to incorporate any fixes...
+
+var _exp
+if (typeof exports !== "undefined") {
+  _exp = exports
+} else if (arg === window) {
+  _exp = window
+} else {
+  // who knows?
+  _exp = arg // or this or somethings. ...
 }
+_exp.hexy = hexy
+_exp.Hexy = Hexy
+_exp.maxnumberlen = maxnumberlen
 
-// ES module exports for Node.js, Deno, and browsers
-export { hexy, Hexy, maxnumberlen }
-export default hexy
+})(this)

package/node_modules/@sterfive/opcua-pinned/node_modules/node-opcua-debug/node_modules/hexy/index.d.ts

@@ -0,0 +1,21 @@
+
+declare module "hexy" {
+  type FormatOptions = {
+    width?: number;
+    littleEndian?: boolean;
+    radix?: number;
+    numbering?: "hex_bytes" | "none";
+    format?: "eights" | "fours" | "twos" | "none";
+    caps?: "lower" | "upper";
+    annotate?: "ascii" | "none";
+    prefix?: string;
+    indent?: number;
+    html?: boolean;
+    extendedChs?: boolean;
+    offset?: number;
+    length?: number;
+    display_offset?: number;
+  }
+  export const hexy: (arg: Buffer | string | number[], format?: FormatOptions) => string;
+  export const maxnumberlen: (bytes: number, radix: number) => number;
+}

package/node_modules/@sterfive/opcua-pinned/node_modules/node-opcua-debug/node_modules/hexy/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "hexy",
+  "version": "0.3.5",
+  "description": "hexdump, binary pretty-printing",
+  "author": "Tim Becker <tim.becker@kuriositaet.de>",
+  "license": "MIT",
+  "main": "./hexy.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/a2800276/hexy.js.git"
+  },
+  "engines": {
+    "node": ">=10.4"
+  },
+  "browserslist": ["> 1%", "last 4 versions"],
+  "scripts": {
+    "test": "node ./test.js"
+  },
+  "bin": {
+    "hexy": "./bin/hexy_cmd.js"
+  },
+  "devDependencies": {
+    "@types/node": "14.x"
+  }
+}

package/node_modules/@sterfive/opcua-pinned/node_modules/node-opcua-debug/node_modules/hexy/test/testcases.js

@@ -0,0 +1,151 @@
+const str = "0123456789abcdefghijklmnopqrstuvwxzy";
+const nums = [ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 
+  101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
+  115, 116, 117, 118, 119, 120, 122, 121 ];
+
+var bundle = null;
+if (typeof window === 'undefined') {
+  bundle = [ Buffer.from("0123456789abcdefghijklmnopqrstuvwxzy"), str, nums ]; // this is node.js case
+} else {
+  bundle = [ str, nums ]; // this is browser case: `Buffer` is not the same here
+}
+
+const _00 = String.fromCharCode(0);
+const _0000 = _00 + _00;
+const _08 = String.fromCharCode(8);
+const _40 = "@";
+const _53 = "S";
+const _5100 = "Q"+_00;
+const str3 = "#include<stdio.h>\n";
+const arr = [0x1001, 0x2002, 0x3003, 0xf00f];
+const arr_e = "00000000: 0102 030f                                ....\n";
+
+
+const results = [
+"00000000: 3031 3233 3435 3637 3839 6162 6364 6566  0123456789abcdef\n"+
+"00000010: 6768 696a 6b6c 6d6e 6f70 7172 7374 7576  ghijklmnopqrstuv\n"+
+"00000020: 7778 7a79                                wxzy\n",
+
+"00000000: 3031 3233 3435 3637 3839 6162 6364 6566  0123456789abcdef\n"+
+"00000010: 6768 696A 6B6C 6D6E 6F70 7172 7374 7576  ghijklmnopqrstuv\n"+
+"00000020: 7778 7A79                                wxzy\n",
+
+"00000000: 3031 3233 3435 3637  01234567\n"+
+"00000008: 3839 6162 6364 6566  89abcdef\n"+
+"00000010: 6768 696a 6b6c 6d6e  ghijklmn\n"+
+"00000018: 6f70 7172 7374 7576  opqrstuv\n"+
+"00000020: 7778 7a79            wxzy\n",
+
+"00000000: 3031 3233 3435 3637  01234567\n"+
+"00000008: 3839 6162 6364 6566  89abcdef\n"+
+"00000010: 6768 696A 6B6C 6D6E  ghijklmn\n"+
+"00000018: 6F70 7172 7374 7576  opqrstuv\n"+
+"00000020: 7778 7A79            wxzy\n",
+
+"3031 3233 3435 3637 3839 6162 6364 6566  0123456789abcdef\n"+
+"6768 696a 6b6c 6d6e 6f70 7172 7374 7576  ghijklmnopqrstuv\n"+
+"7778 7a79                                wxzy\n",
+
+"00000000: 30 31 32 33 34 35 36 37 38 39 61 62 63 64 65 66    0123456789abcdef\n"+
+"00000010: 67 68 69 6a 6b 6c 6d 6e 6f 70 71 72 73 74 75 76    ghijklmnopqrstuv\n"+
+"00000020: 77 78 7a 79                                        wxzy\n",
+
+"00000000: 30313233 34353637 38396162 63646566  0123456789abcdef\n" +
+"00000010: 6768696a 6b6c6d6e 6f707172 73747576  ghijklmnopqrstuv\n" +
+"00000020: 77787a79                             wxzy\n",
+
+"00000000: 30313233343536373839616263646566  0123456789abcdef\n"+
+"00000010: 6768696a6b6c6d6e6f70717273747576  ghijklmnopqrstuv\n"+
+"00000020: 77787a79                          wxzy\n",
+
+"00000000: 3031 3233 3435 3637 3839 6162 6364 6566 \n"+
+"00000010: 6768 696a 6b6c 6d6e 6f70 7172 7374 7576 \n"+
+"00000020: 7778 7a79                               \n",
+
+"-00000000: 3031 3233 3435 3637 3839 6162 6364 6566  0123456789abcdef\n"+
+"-00000010: 6768 696a 6b6c 6d6e 6f70 7172 7374 7576  ghijklmnopqrstuv\n"+
+"-00000020: 7778 7a79                                wxzy\n",
+
+"     00000000: 3031 3233 3435 3637 3839 6162 6364 6566  0123456789abcdef\n"+
+"     00000010: 6768 696a 6b6c 6d6e 6f70 7172 7374 7576  ghijklmnopqrstuv\n"+
+"     00000020: 7778 7a79                                wxzy\n",
+
+"dingdong30 31 32 33 34 35 36 37 38 39 61 62 63 64 65 66   \n"+
+"dingdong67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76   \n"+
+"dingdong77 78 7A 79                                       \n"+
+"",
+
+"<div class='hexy'>\n"+
+"<div class='00000000 even'>00000000: 3031 3233 3435 3637 3839 6162 6364 6566  0123456789abcdef</div>\n"+
+"<div class='00000010  odd'>00000010: 6768 696a 6b6c 6d6e 6f70 7172 7374 7576  ghijklmnopqrstuv</div>\n"+
+"<div class='00000020 even'>00000020: 7778 7a79 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; wxzy</div>\n"+
+"</div>\n",
+
+"0000000a: 6162 6364 6566 6768 696a 6b6c 6d6e 6f70  abcdefghijklmnop\n"+
+"0000001a: 7172 7374 7576 7778 7a79                 qrstuvwxzy\n",
+
+"0000000a: 6162 6364 6566 6768 696a                 abcdefghij\n",
+
+"<div class='hexy'>\n"+
+"<div class='0000000a even'>0000000a: 6162 6364 6566 6768 696a &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; abcdefghij</div>\n"+
+"</div>\n",
+
+"0000000a: 3031 3233 3435 3637 3839 6162 6364 6566  0123456789abcdef\n"+
+"0000001a: 6768 696a 6b6c 6d6e 6f70 7172 7374 7576  ghijklmnopqrstuv\n"+
+"0000002a: 7778 7a79                                wxzy\n",
+
+"00000014: 6162 6364 6566 6768 696a                 abcdefghij\n",
+];
+
+const testcases = [
+// #0
+  { input: str, params: {}, result: results[0] }, // historic first testcase will always remain #0
+  { inputs: bundle, params: {}, result: results[0] },
+  { inputs: bundle, params: {caps:"upper"}, result: results[1] },
+  { inputs: bundle, params: {width:8}, result: results[2] },
+  { inputs: bundle, params: {width:8, caps:"upper"}, result: results[3] },
+  { inputs: bundle, params: {numbering:"none"}, result: results[4] },
+  { inputs: bundle, params: {format:"twos"}, result: results[5] },
+  { inputs: bundle, params: {format:"eights"}, result: results[6] },
+  { inputs: bundle, params: {format:"none"}, result: results[7] },
+  { inputs: bundle, params: {annotate:"none"}, result: results[8] },
+// #10
+  { inputs: bundle, params: {prefix:"-"}, result: results[9] },
+  { inputs: bundle, params: {indent:"5"}, result: results[10] },
+  { inputs: bundle, params: {caps:"upper", numbering:"none", annotate:"none", prefix:"dingdong", format:"twos"}, result: results[11] },
+  { inputs: bundle, params: {html:true}, result: results[12] },
+  { inputs: bundle, params: {offset:10}, result: results[13] },
+  { inputs: bundle, params: {offset:10, length:10}, result: results[14] },
+  { inputs: bundle, params: {offset:10, length:10, html:true}, result: results[15] },
+  { inputs: bundle, params: {display_offset:10}, result: results[16] },
+  { inputs: bundle, params: {display_offset:10, offset:10, length:10}, result: results[17] },
+  { input: _00 + _00 + _08 + _40 + _53 + _00 + _0000 + _5100 + _0000 + _5100 + _0000, params: {}, result: "00000000: 0000 0840 5300 0000 5100 0000 5100 0000  ...@S...Q...Q...\n" },
+// #20
+  { input: str3, params: {}, result: "00000000: 2369 6e63 6c75 6465 3c73 7464 696f 2e68  #include<stdio.h\n00000010: 3e0a                                     >.\n" },
+  { input: str3, params: {html:true}, result: "<div class='hexy'>\n"+
+                                              "<div class='00000000 even'>00000000: 2369 6e63 6c75 6465 3c73 7464 696f 2e68  #include&lt;stdio.h</div>\n"+
+                                              "<div class='00000010  odd'>00000010: 3e0a &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &gt;.</div>\n"+
+                                              "</div>\n" },
+  // empties
+  { input: "", params: {}, result: "" },
+  // Number arrays with bytes work, arrays containing values larger that 0xff are truncated ( val & 0xff )
+  { input: arr, params: {}, result: arr_e },
+   // non numerical width
+  { input: arr, params: {width: "something"}, result: arr_e },
+  { input: arr, params: {width: "2"}, result: "00000000: 0102  ..\n00000002: 030f  ..\n" },
+  { input: arr, params: {width: 1}, result: "00000000: 01  .\n00000001: 02  .\n00000002: 03  .\n00000003: 0f  .\n" },
+  // endianness
+  { input: arr, params: {littleEndian: true}, result: "00000000: 0201 0f03                                ....\n" },
+  // alternative radix
+  { input: arr, params: {radix: 10, format: "twos"}, result: "00000000: 001 002 003 015                                                    ....\n" },
+  // suppression of non-printable characters
+  { input: [ 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xd2, 0x77, 0x6f, 0x72, 0x6c, 0x64 ], params: {format: "twos", html: true, extendedChs: true}, result: "<div class='hexy'>\n"+
+                                                                                                                                                  "<div class='00000000 even'>00000000: 68 65 6c 6c 6f d2 77 6f 72 6c 64 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; hello&#xd2;world</div>\n"+
+                                                                                                                                                  "</div>\n" },
+// #30
+  { input: [ 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xd2, 0x77, 0x6f, 0x72, 0x6c, 0x64 ], params: {format: "twos"}, result: "00000000: 68 65 6c 6c 6f d2 77 6f 72 6c 64                   hello.world\n" },
+  { input: [ 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xd2, 0x77, 0x6f, 0x72, 0x6c, 0x64 ], params: {format: "twos", extendedChs:true}, result: "00000000: 68 65 6c 6c 6f d2 77 6f 72 6c 64                   hello" + "\u00d2" + "world\n" },
+];
+if (typeof window === 'undefined') {
+  module.exports = testcases;
+}