cborg 1.6.2 → 1.8.1

package/esm/node-test/node-test-bin.js

@@ -2,9 +2,56 @@ import chai from 'chai';
 import { exec } from 'child_process';
 import process from 'process';
 import path from 'path';
+import { platform } from 'os';
 import { fileURLToPath } from 'url';
 import bin from '../lib/bin.js';
 const {assert} = chai;
+const fixture1JsonString = '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}';
+const fixture1JsonPrettyString = `{
+  "a": 1,
+  "b": [
+    2,
+    3
+  ],
+  "smile": "😀"
+}
+`;
+const fixture1HexString = 'a3616101616282020365736d696c6564f09f9880';
+const fixture1Bin = fromHex(fixture1HexString);
+const fixture1BinString = new TextDecoder().decode(fixture1Bin);
+const fixture1DiagnosticString = `a3                                                # map(3)
+  61                                              #   string(1)
+    61                                            #     "a"
+  01                                              #   uint(1)
+  61                                              #   string(1)
+    62                                            #     "b"
+  82                                              #   array(2)
+    02                                            #     uint(2)
+    03                                            #     uint(3)
+  65                                              #   string(5)
+    736d696c65                                    #     "smile"
+  64                                              #   string(2)
+    f09f9880                                      #     "😀"
+`;
+const fixture2HexString = 'a4616101616282020363627566440102036165736d696c6564f09f9880';
+const fixture2DiagnosticString = `a4                                                # map(4)
+  61                                              #   string(1)
+    61                                            #     "a"
+  01                                              #   uint(1)
+  61                                              #   string(1)
+    62                                            #     "b"
+  82                                              #   array(2)
+    02                                            #     uint(2)
+    03                                            #     uint(3)
+  63                                              #   string(3)
+    627566                                        #     "buf"
+  44                                              #   bytes(4)
+    01020361                                      #     "\\x01\\x02\\x03a"
+  65                                              #   string(5)
+    736d696c65                                    #     "smile"
+  64                                              #   string(2)
+    f09f9880                                      #     "😀"
+`;
 const binPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '../lib/bin.js');
 function fromHex(hex) {
   return new Uint8Array(hex.split('').map((c, i, d) => i % 2 === 0 ? `0x${ c }${ d[i + 1] }` : '').filter(Boolean).map(e => parseInt(e, 16)));
@@ -39,15 +86,18 @@ describe('Bin', () => {
       assert.strictEqual(e.stdout, '');
       assert.strictEqual(e.stderr, `Usage: cborg <command> <args>
 Valid commands:
-\thex2diag [hex input]
-\thex2bin [hex input]
-\thex2json [--pretty] [hex input]
-\tbin2hex [binary input]
 \tbin2diag [binary input]
+\tbin2hex [binary input]
 \tbin2json [--pretty] [binary input]
-\tjson2hex '[json input]'
-\tjson2diag '[json input]'
+\tdiag2bin [diagnostic input]
+\tdiag2hex [diagnostic input]
+\tdiag2json [--pretty] [diagnostic input]
+\thex2bin [hex input]
+\thex2diag [hex input]
+\thex2json [--pretty] [hex input]
 \tjson2bin '[json input]'
+\tjson2diag '[json input]'
+\tjson2hex '[json input]'
 Input may either be supplied as an argument or piped via stdin
 `);
     }
@@ -61,15 +111,18 @@ Input may either be supplied as an argument or piped via stdin
       assert.strictEqual(e.stderr, `Unknown command: 'blip'
 Usage: cborg <command> <args>
 Valid commands:
-\thex2diag [hex input]
-\thex2bin [hex input]
-\thex2json [--pretty] [hex input]
-\tbin2hex [binary input]
 \tbin2diag [binary input]
+\tbin2hex [binary input]
 \tbin2json [--pretty] [binary input]
-\tjson2hex '[json input]'
-\tjson2diag '[json input]'
+\tdiag2bin [diagnostic input]
+\tdiag2hex [diagnostic input]
+\tdiag2json [--pretty] [diagnostic input]
+\thex2bin [hex input]
+\thex2diag [hex input]
+\thex2json [--pretty] [hex input]
 \tjson2bin '[json input]'
+\tjson2diag '[json input]'
+\tjson2hex '[json input]'
 Input may either be supplied as an argument or piped via stdin
 `);
     }
@@ -79,137 +132,103 @@ Input may either be supplied as an argument or piped via stdin
     assert.strictEqual(stdout, '');
     assert.strictEqual(stderr, `Usage: cborg <command> <args>
 Valid commands:
-\thex2diag [hex input]
-\thex2bin [hex input]
-\thex2json [--pretty] [hex input]
-\tbin2hex [binary input]
 \tbin2diag [binary input]
+\tbin2hex [binary input]
 \tbin2json [--pretty] [binary input]
-\tjson2hex '[json input]'
-\tjson2diag '[json input]'
+\tdiag2bin [diagnostic input]
+\tdiag2hex [diagnostic input]
+\tdiag2json [--pretty] [diagnostic input]
+\thex2bin [hex input]
+\thex2diag [hex input]
+\thex2json [--pretty] [hex input]
 \tjson2bin '[json input]'
+\tjson2diag '[json input]'
+\tjson2hex '[json input]'
 Input may either be supplied as an argument or piped via stdin
 `);
   });
+  it('bin2diag (stdin)', async () => {
+    const {stdout, stderr} = await execBin('bin2diag', fixture1Bin);
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, fixture1DiagnosticString);
+  });
+  it('bin2hex (stdin)', async () => {
+    const {stdout, stderr} = await execBin('bin2hex', fixture1Bin);
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, `${ fixture1HexString }\n`);
+  });
+  it('bin2json (stdin)', async () => {
+    const {stdout, stderr} = await execBin('bin2json', fixture1Bin);
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, `${ fixture1JsonString }\n`);
+  });
+  it('bin2json pretty (stdin)', async () => {
+    const {stdout, stderr} = await execBin('bin2json --pretty', fixture1Bin);
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, fixture1JsonPrettyString);
+  });
   for (const stdin of [
       true,
       false
     ]) {
-    it(`hex2json${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = stdin ? await execBin('hex2json a3616101616282020365736d696c6564f09f9880') : await execBin('hex2json', 'a3616101616282020365736d696c6564f09f9880');
-      assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}\n');
-    });
-    it(`hex2json pretty${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = stdin ? await execBin('hex2json --pretty a3616101616282020365736d696c6564f09f9880') : await execBin('hex2json --pretty', 'a3616101616282020365736d696c6564f09f9880');
+    if (platform() !== 'win32' || stdin) {
+      it(`diag2bin${ stdin ? ' (stdin)' : '' }`, async () => {
+        const {stdout, stderr} = !stdin ? await execBin(`diag2bin '${ fixture1DiagnosticString }'`) : await execBin('diag2bin', fixture1DiagnosticString);
+        assert.strictEqual(stderr, '');
+        assert.strictEqual(stdout, fixture1BinString);
+      });
+      it(`diag2hex${ stdin ? ' (stdin)' : '' }`, async () => {
+        const {stdout, stderr} = !stdin ? await execBin(`diag2hex '${ fixture1DiagnosticString }'`) : await execBin('diag2hex', fixture1DiagnosticString);
+        assert.strictEqual(stderr, '');
+        assert.strictEqual(stdout, `${ fixture1HexString }\n`);
+      });
+      it(`diag2json${ stdin ? ' (stdin)' : '' }`, async () => {
+        const {stdout, stderr} = !stdin ? await execBin(`diag2json '${ fixture1DiagnosticString }'`) : await execBin('diag2json', fixture1DiagnosticString);
+        assert.strictEqual(stderr, '');
+        assert.strictEqual(stdout, `${ fixture1JsonString }\n`);
+      });
+      it(`diag2json pretty${ stdin ? ' (stdin)' : '' }`, async () => {
+        const {stdout, stderr} = !stdin ? await execBin(`diag2json --pretty '${ fixture1DiagnosticString }'`) : await execBin('diag2json --pretty', fixture1DiagnosticString);
+        assert.strictEqual(stderr, '');
+        assert.strictEqual(stdout, fixture1JsonPrettyString);
+      });
+    }
+    it(`hex2bin${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = !stdin ? await execBin(`hex2bin ${ fixture1HexString }`) : await execBin('hex2bin', fixture1HexString);
       assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, `{
-  "a": 1,
-  "b": [
-    2,
-    3
-  ],
-  "smile": "😀"
-}
-`);
+      assert.strictEqual(stdout, fixture1BinString);
     });
     it(`hex2diag${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = stdin ? await execBin('hex2diag a4616101616282020363627566440102036165736d696c6564f09f9880') : await execBin('hex2diag', 'a4616101616282020363627566440102036165736d696c6564f09f9880');
+      const {stdout, stderr} = !stdin ? await execBin(`hex2diag ${ fixture2HexString }`) : await execBin('hex2diag', fixture2HexString);
       assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, `a4                                                # map(4)
-  61                                              #   string(1)
-    61                                            #     "a"
-  01                                              #   uint(1)
-  61                                              #   string(1)
-    62                                            #     "b"
-  82                                              #   array(2)
-    02                                            #     uint(2)
-    03                                            #     uint(3)
-  63                                              #   string(3)
-    627566                                        #     "buf"
-  44                                              #   bytes(4)
-    01020361                                      #     "\\x01\\x02\\x03a"
-  65                                              #   string(5)
-    736d696c65                                    #     "smile"
-  64 f09f                                         #   string(2)
-    f09f9880                                      #     "😀"
-`);
+      assert.strictEqual(stdout, fixture2DiagnosticString);
     });
-    it(`hex2bin${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = stdin ? await execBin('hex2bin a3616101616282020365736d696c6564f09f9880') : await execBin('hex2bin', 'a3616101616282020365736d696c6564f09f9880');
+    it(`hex2json${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = !stdin ? await execBin(`hex2json ${ fixture1HexString }`) : await execBin('hex2json', fixture1HexString);
       assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, new TextDecoder().decode(fromHex('a3616101616282020365736d696c6564f09f9880')));
+      assert.strictEqual(stdout, `${ fixture1JsonString }\n`);
     });
-    it(`json2hex${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = stdin ? await execBin('json2hex "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2hex', '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}');
+    it(`hex2json pretty${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = !stdin ? await execBin(`hex2json --pretty ${ fixture1HexString }`) : await execBin('hex2json --pretty', fixture1HexString);
       assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, 'a3616101616282020365736d696c6564f09f9880\n');
+      assert.strictEqual(stdout, fixture1JsonPrettyString);
     });
     it(`json2bin${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = stdin ? await execBin('json2bin "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2bin', '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}');
+      const {stdout, stderr} = !stdin ? await execBin('json2bin "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2bin', fixture1JsonString);
       assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, new TextDecoder().decode(fromHex('a3616101616282020365736d696c6564f09f9880')));
+      assert.strictEqual(stdout, fixture1BinString);
     });
     it(`json2diag${ stdin ? ' (stdin)' : '' }`, async () => {
-      const {stdout, stderr} = stdin ? await execBin('json2diag "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2diag', '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}');
+      const {stdout, stderr} = !stdin ? await execBin('json2diag "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2diag', fixture1JsonString);
       assert.strictEqual(stderr, '');
-      assert.strictEqual(stdout, `a3                                                # map(3)
-  61                                              #   string(1)
-    61                                            #     "a"
-  01                                              #   uint(1)
-  61                                              #   string(1)
-    62                                            #     "b"
-  82                                              #   array(2)
-    02                                            #     uint(2)
-    03                                            #     uint(3)
-  65                                              #   string(5)
-    736d696c65                                    #     "smile"
-  64 f09f                                         #   string(2)
-    f09f9880                                      #     "😀"
-`);
+      assert.strictEqual(stdout, fixture1DiagnosticString);
+    });
+    it(`json2hex${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = !stdin ? await execBin(`json2hex "${ fixture1JsonString.replace(/"/g, '\\"') }"`) : await execBin('json2hex', fixture1JsonString);
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, `${ fixture1HexString }\n`);
     });
   }
-  it('bin2diag (stdin)', async () => {
-    const {stdout, stderr} = await execBin('bin2diag', fromHex('a3616101616282020365736d696c6564f09f9880'));
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, `a3                                                # map(3)
-  61                                              #   string(1)
-    61                                            #     "a"
-  01                                              #   uint(1)
-  61                                              #   string(1)
-    62                                            #     "b"
-  82                                              #   array(2)
-    02                                            #     uint(2)
-    03                                            #     uint(3)
-  65                                              #   string(5)
-    736d696c65                                    #     "smile"
-  64 f09f                                         #   string(2)
-    f09f9880                                      #     "😀"
-`);
-  });
-  it('bin2json (stdin)', async () => {
-    const {stdout, stderr} = await execBin('bin2json', fromHex('a3616101616282020365736d696c6564f09f9880'));
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}\n');
-  });
-  it('bin2json pretty (stdin)', async () => {
-    const {stdout, stderr} = await execBin('bin2json --pretty', fromHex('a3616101616282020365736d696c6564f09f9880'));
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, `{
-  "a": 1,
-  "b": [
-    2,
-    3
-  ],
-  "smile": "😀"
-}
-`);
-  });
-  it('bin2hex (stdin)', async () => {
-    const {stdout, stderr} = await execBin('bin2hex', fromHex('a3616101616282020365736d696c6564f09f9880'));
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, 'a3616101616282020365736d696c6564f09f9880\n');
-  });
   it('diag indenting', async () => {
     const {stdout, stderr} = await execBin('json2diag', '{"a":[],"b":{},"c":{"a":1,"b":{"a":{"a":{}}}},"d":{"a":{"a":{"a":1},"b":2,"c":[]}},"e":[[[[{"a":{}}]]]],"f":1}');
     assert.strictEqual(stderr, '');
@@ -268,4 +287,54 @@ Input may either be supplied as an argument or piped via stdin
   01                                              #   uint(1)
 `);
   });
+  describe('diag length bytes', () => {
+    it('compact', async () => {
+      const {stdout, stderr} = await execBin('json2diag', '"aaaaaaaaaaaaaaaaaaaaaaa"');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, `77                                                # string(23)
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+`);
+    });
+    it('1-byte', async () => {
+      const {stdout, stderr} = await execBin('json2diag', '"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, `78 23                                             # string(35)
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  616161616161616161616161                        #   "aaaaaaaaaaaa"
+`);
+    });
+    it('2-byte', async () => {
+      const {stdout, stderr} = await execBin('json2diag', '"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, `79 0100                                           # string(256)
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  6161616161616161616161616161616161616161616161  #   "aaaaaaaaaaaaaaaaaaaaaaa"
+  616161                                          #   "aaa"
+`);
+    });
+  });
+  it('diag non-utf8 and non-printable ascii', async () => {
+    const input = '7864f55ff8f12508b63ef2bfeca7557ae90df6311a5ec1631b4a1fa843310bd9c3a710eaace5a1bdd72ad0bfe049771c11e756338bd93865e645f1adec9b9c99ef407fbd4fc6859e7904c5ad7dc9bd10a5cc16973d5b28ec1a6dd43d9f82f9f18c3d03418e35';
+    let {stdout, stderr} = await execBin(`hex2diag ${ input }`);
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, `78 64                                             # string(86)
+  f55ff8f12508b63ef2bfeca7557ae90df6311a5ec1631b  #   "õ_øñ%\\x08¶>ò¿ì§Uzé\\x0dö1\\x1a^Ác\\x1b"
+  4a1fa843310bd9c3a710eaace5a1bdd72ad0bfe049771c  #   "J\\x1f¨C1\\x0bÙç\\x10ê¬å¡½×*пàIw\\x1c"
+  11e756338bd93865e645f1adec9b9c99ef407fbd4fc685  #   "\\x11çV3\\x8bÙ8eæEñ\\xadì\\x9b\\x9c\\x99ï@\\x7f½OÆ\\x85"
+  9e7904c5ad7dc9bd10a5cc16973d5b28ec1a6dd43d9f82  #   "\\x9ey\\x04Å\\xad}ɽ\\x10¥Ì\\x16\\x97=[(ì\\x1amÔ=\\x9f\\x82"
+  f9f18c3d03418e35                                #   "ùñ\\x8c=\\x03A\\x8e5"
+`);
+    ({stdout, stderr} = await execBin('diag2hex', stdout));
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, `${ input }\n`);
+  });
 });

package/interface.ts

@@ -39,6 +39,7 @@ export interface DecodeOptions {
   allowBigInt?: boolean
   strict?: boolean
   useMaps?: boolean
+  retainStringBytes?: boolean
   tags?: TagDecoder[],
   tokenizer?: DecodeTokenizer
 }

package/lib/3string.js

@@ -2,7 +2,7 @@ import { Token, Type } from './token.js'
 import { assertEnoughData, decodeErrPrefix } from './common.js'
 import * as uint from './0uint.js'
 import { encodeBytes } from './2bytes.js'
-import { toString } from './byte-utils.js'
+import { toString, slice } from './byte-utils.js'
 
 /**
  * @typedef {import('./bl.js').Bl} Bl
@@ -14,23 +14,28 @@ import { toString } from './byte-utils.js'
  * @param {number} pos
  * @param {number} prefix
  * @param {number} length
+ * @param {DecodeOptions} options
  * @returns {Token}
  */
-function toToken (data, pos, prefix, length) {
+function toToken (data, pos, prefix, length, options) {
   const totLength = prefix + length
   assertEnoughData(data, pos, totLength)
-  return new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength)
+  const tok = new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength)
+  if (options.retainStringBytes === true) {
+    tok.byteValue = slice(data, pos + prefix, pos + totLength)
+  }
+  return tok
 }
 
 /**
  * @param {Uint8Array} data
  * @param {number} pos
  * @param {number} minor
- * @param {DecodeOptions} _options
+ * @param {DecodeOptions} options
  * @returns {Token}
  */
-export function decodeStringCompact (data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor)
+export function decodeStringCompact (data, pos, minor, options) {
+  return toToken(data, pos, 1, minor, options)
 }
 
 /**
@@ -41,7 +46,7 @@ export function decodeStringCompact (data, pos, minor, _options) {
  * @returns {Token}
  */
 export function decodeString8 (data, pos, _minor, options) {
-  return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options))
+  return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options), options)
 }
 
 /**
@@ -52,7 +57,7 @@ export function decodeString8 (data, pos, _minor, options) {
  * @returns {Token}
  */
 export function decodeString16 (data, pos, _minor, options) {
-  return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options))
+  return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options), options)
 }
 
 /**
@@ -63,7 +68,7 @@ export function decodeString16 (data, pos, _minor, options) {
  * @returns {Token}
  */
 export function decodeString32 (data, pos, _minor, options) {
-  return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options))
+  return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options), options)
 }
 
 // TODO: maybe we shouldn't support this ..
@@ -79,7 +84,7 @@ export function decodeString64 (data, pos, _minor, options) {
   if (typeof l === 'bigint') {
     throw new Error(`${decodeErrPrefix} 64-bit integer string lengths not supported`)
   }
-  return toToken(data, pos, 9, l)
+  return toToken(data, pos, 9, l, options)
 }
 
 export const encodeString = encodeBytes

package/lib/bin.js

@@ -2,7 +2,7 @@
 
 import process from 'process'
 import { decode, encode } from '../cborg.js'
-import { tokensToDiagnostic } from './diagnostic.js'
+import { tokensToDiagnostic, fromDiag } from './diagnostic.js'
 import { fromHex as _fromHex, toHex } from './byte-utils.js'
 
 /**
@@ -11,15 +11,18 @@ import { fromHex as _fromHex, toHex } from './byte-utils.js'
 function usage (code) {
   console.error('Usage: cborg <command> <args>')
   console.error('Valid commands:')
-  console.error('\thex2diag [hex input]')
-  console.error('\thex2bin [hex input]')
-  console.error('\thex2json [--pretty] [hex input]')
-  console.error('\tbin2hex [binary input]')
   console.error('\tbin2diag [binary input]')
+  console.error('\tbin2hex [binary input]')
   console.error('\tbin2json [--pretty] [binary input]')
-  console.error('\tjson2hex \'[json input]\'')
-  console.error('\tjson2diag \'[json input]\'')
+  console.error('\tdiag2bin [diagnostic input]')
+  console.error('\tdiag2hex [diagnostic input]')
+  console.error('\tdiag2json [--pretty] [diagnostic input]')
+  console.error('\thex2bin [hex input]')
+  console.error('\thex2diag [hex input]')
+  console.error('\thex2json [--pretty] [hex input]')
   console.error('\tjson2bin \'[json input]\'')
+  console.error('\tjson2diag \'[json input]\'')
+  console.error('\tjson2hex \'[json input]\'')
   console.error('Input may either be supplied as an argument or piped via stdin')
   process.exit(code || 0)
 }
@@ -59,26 +62,15 @@ async function run () {
       return usage(0)
     }
 
-    case 'hex2json': {
-      const { argv, pretty } = argvPretty()
-      const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
-      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
-    }
-
-    case 'hex2diag': {
-      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+    case 'bin2diag': {
+      /* c8 ignore next 1 */
+      const bin = process.argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(process.argv[3])
       for (const line of tokensToDiagnostic(bin)) {
         console.log(line)
       }
       return
     }
 
-    case 'hex2bin': {
-      // this is really nothing to do with cbor.. just handy
-      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
-      return process.stdout.write(bin)
-    }
-
     case 'bin2hex': {
       // this is really nothing to do with cbor.. just handy
       /* c8 ignore next 1 */
@@ -93,19 +85,52 @@ async function run () {
       return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
     }
 
-    case 'bin2diag': {
+    case 'diag2bin': {
+      // no coverage on windows for non-stdin input
       /* c8 ignore next 1 */
-      const bin = process.argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(process.argv[3])
+      const bin = fromDiag(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+      return process.stdout.write(bin)
+    }
+
+    case 'diag2hex': {
+      // no coverage on windows for non-stdin input
+      /* c8 ignore next 1 */
+      const bin = fromDiag(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+      return console.log(toHex(bin))
+    }
+
+    case 'diag2json': {
+      const { argv, pretty } = argvPretty()
+      // no coverage on windows for non-stdin input
+      /* c8 ignore next 1 */
+      const bin = fromDiag(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
+      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
+    }
+
+    case 'hex2bin': {
+      // this is really nothing to do with cbor.. just handy
+      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+      return process.stdout.write(bin)
+    }
+
+    case 'hex2diag': {
+      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
       for (const line of tokensToDiagnostic(bin)) {
         console.log(line)
       }
       return
     }
 
-    case 'json2hex': {
+    case 'hex2json': {
+      const { argv, pretty } = argvPretty()
+      const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
+      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
+    }
+
+    case 'json2bin': {
       const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]
       const obj = JSON.parse(inp)
-      return console.log(toHex(encode(obj)))
+      return process.stdout.write(encode(obj))
     }
 
     case 'json2diag': {
@@ -117,10 +142,10 @@ async function run () {
       return
     }
 
-    case 'json2bin': {
+    case 'json2hex': {
       const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]
       const obj = JSON.parse(inp)
-      return process.stdout.write(encode(obj))
+      return console.log(toHex(encode(obj)))
     }
 
     default: { // no, or unknown cmd