cborg 1.5.4 → 1.7.0

package/esm/lib/diagnostic.js

@@ -1,5 +1,11 @@
 import { Tokeniser } from './decode.js';
-import { toHex } from './byte-utils.js';
+import {
+  toHex,
+  fromHex
+} from './byte-utils.js';
+import { uintBoundaries } from './0uint.js';
+const utf8Encoder = new TextEncoder();
+const utf8Decoder = new TextDecoder();
 function* tokensToDiagnostic(inp, width = 100) {
   const tokeniser = new Tokeniser(inp);
   let pos = 0;
@@ -12,6 +18,7 @@ function* tokensToDiagnostic(inp, width = 100) {
     let margin = ''.padStart(indent.length * 2, ' ');
     let vLength = token.encodedLength - 1;
     let v = String(token.value);
+    let outp = `${ margin }${ slc(0, 1) }`;
     const str = token.type.name === 'bytes' || token.type.name === 'string';
     if (token.type.name === 'string') {
       v = v.length;
@@ -20,7 +27,29 @@ function* tokensToDiagnostic(inp, width = 100) {
       v = token.value.length;
       vLength -= v;
     }
-    let outp = `${ margin }${ slc(0, 1) } ${ slc(1, vLength) }`;
+    let multilen;
+    switch (token.type.name) {
+    case 'string':
+    case 'bytes':
+    case 'map':
+    case 'array':
+      multilen = token.type.name === 'string' ? utf8Encoder.encode(token.value).length : token.value.length;
+      if (multilen >= uintBoundaries[0]) {
+        if (multilen < uintBoundaries[1]) {
+          outp += ` ${ slc(1, 1) }`;
+        } else if (multilen < uintBoundaries[2]) {
+          outp += ` ${ slc(1, 2) }`;
+        } else if (multilen < uintBoundaries[3]) {
+          outp += ` ${ slc(1, 4) }`;
+        } else if (multilen < uintBoundaries[4]) {
+          outp += ` ${ slc(1, 8) }`;
+        }
+      }
+      break;
+    default:
+      outp += ` ${ slc(1, vLength) }`;
+      break;
+    }
     outp = outp.padEnd(width / 2, ' ');
     outp += `# ${ margin }${ token.type.name }`;
     if (token.type.name !== v) {
@@ -29,13 +58,13 @@ function* tokensToDiagnostic(inp, width = 100) {
     yield outp;
     if (str) {
       margin += '  ';
-      const repr = token.type.name === 'bytes' ? token.value : new TextEncoder().encode(token.value);
+      const repr = token.type.name === 'bytes' ? token.value : utf8Encoder.encode(token.value);
       const wh = (width / 2 - margin.length - 1) / 2;
       let snip = 0;
       while (repr.length - snip > 0) {
         const piece = repr.slice(snip, snip + wh);
         snip += piece.length;
-        const st = token.type.name === 'string' ? new TextDecoder().decode(piece) : piece.reduce((p, c) => {
+        const st = token.type.name === 'string' ? utf8Decoder.decode(piece) : piece.reduce((p, c) => {
           if (c < 32 || c === 127) {
             return `${ p }\\x${ c.toString(16).padStart(2, '0') }`;
           }
@@ -44,6 +73,9 @@ function* tokensToDiagnostic(inp, width = 100) {
         yield `${ margin }${ toHex(piece) }`.padEnd(width / 2, ' ') + `# ${ margin }"${ st }"`;
       }
     }
+    if (indent.length) {
+      indent[indent.length - 1]--;
+    }
     if (!token.type.terminal) {
       switch (token.type.name) {
       case 'map':
@@ -58,17 +90,24 @@ function* tokensToDiagnostic(inp, width = 100) {
       default:
         throw new Error(`Unknown token type '${ token.type.name }'`);
       }
-    } else {
-      if (indent.length) {
-        indent[indent.length - 1]--;
-        if (indent[indent.length - 1] === 0) {
-          indent.pop();
-        }
-      }
+    }
+    while (indent.length && indent[indent.length - 1] <= 0) {
+      indent.pop();
     }
     pos += token.encodedLength;
   }
 }
+function fromDiag(input) {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected string input');
+  }
+  input = input.replace(/#.*?$/mg, '').replace(/[\s\r\n]+/mg, '');
+  if (/[^a-f0-9]/i.test(input)) {
+    throw new TypeError('Input string was not CBOR diagnostic format');
+  }
+  return fromHex(input);
+}
 export {
-  tokensToDiagnostic
+  tokensToDiagnostic,
+  fromDiag
 };

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,135 +132,194 @@ 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'));
+  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, '');
-    assert.strictEqual(stdout, `a3                                                # map(3)
+    assert.strictEqual(stdout, `a6                                                # map(6)
   61                                              #   string(1)
     61                                            #     "a"
-  01                                              #   uint(1)
+  80                                              #   array(0)
   61                                              #   string(1)
     62                                            #     "b"
-  82                                              #   array(2)
-    02                                            #     uint(2)
-    03                                            #     uint(3)
-  65                                              #   string(5)
-    736d696c65                                    #     "smile"
-  64 f09f                                         #   string(2)
-    f09f9880                                      #     "😀"
+  a0                                              #   map(0)
+  61                                              #   string(1)
+    63                                            #     "c"
+  a2                                              #   map(2)
+    61                                            #     string(1)
+      61                                          #       "a"
+    01                                            #     uint(1)
+    61                                            #     string(1)
+      62                                          #       "b"
+    a1                                            #     map(1)
+      61                                          #       string(1)
+        61                                        #         "a"
+      a1                                          #       map(1)
+        61                                        #         string(1)
+          61                                      #           "a"
+        a0                                        #         map(0)
+  61                                              #   string(1)
+    64                                            #     "d"
+  a1                                              #   map(1)
+    61                                            #     string(1)
+      61                                          #       "a"
+    a3                                            #     map(3)
+      61                                          #       string(1)
+        61                                        #         "a"
+      a1                                          #       map(1)
+        61                                        #         string(1)
+          61                                      #           "a"
+        01                                        #         uint(1)
+      61                                          #       string(1)
+        62                                        #         "b"
+      02                                          #       uint(2)
+      61                                          #       string(1)
+        63                                        #         "c"
+      80                                          #       array(0)
+  61                                              #   string(1)
+    65                                            #     "e"
+  81                                              #   array(1)
+    81                                            #     array(1)
+      81                                          #       array(1)
+        81                                        #         array(1)
+          a1                                      #           map(1)
+            61                                    #             string(1)
+              61                                  #               "a"
+            a0                                    #             map(0)
+  61                                              #   string(1)
+    66                                            #     "f"
+  01                                              #   uint(1)
 `);
   });
-  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": "😀"
-}
+  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('bin2hex (stdin)', async () => {
-    const {stdout, stderr} = await execBin('bin2hex', fromHex('a3616101616282020365736d696c6564f09f9880'));
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, 'a3616101616282020365736d696c6564f09f9880\n');
+    });
+    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"
+`);
+    });
   });
 });

package/esm/node-test/test-7float.js

@@ -195,6 +195,8 @@ describe('float', () => {
       ]), { allowIndefinite: false }), /indefinite/);
     });
     it('can switch off undefined support', () => {
+      assert.deepStrictEqual(decode(fromHex('f7')), undefined);
+      assert.throws(() => decode(fromHex('f7'), { allowUndefined: false }), /undefined/);
       assert.deepStrictEqual(decode(fromHex('830102f7')), [
         1,
         2,
@@ -202,6 +204,20 @@ describe('float', () => {
       ]);
       assert.throws(() => decode(fromHex('830102f7'), { allowUndefined: false }), /undefined/);
     });
+    it('can coerce undefined to null', () => {
+      assert.deepStrictEqual(decode(fromHex('f7'), { coerceUndefinedToNull: false }), undefined);
+      assert.deepStrictEqual(decode(fromHex('f7'), { coerceUndefinedToNull: true }), null);
+      assert.deepStrictEqual(decode(fromHex('830102f7'), { coerceUndefinedToNull: false }), [
+        1,
+        2,
+        undefined
+      ]);
+      assert.deepStrictEqual(decode(fromHex('830102f7'), { coerceUndefinedToNull: true }), [
+        1,
+        2,
+        null
+      ]);
+    });
     it('can switch off Infinity support', () => {
       assert.deepStrictEqual(decode(fromHex('830102f97c00')), [
         1,

package/interface.ts

@@ -33,6 +33,7 @@ export type TagDecoder = (inner: any) => any
 export interface DecodeOptions {
   allowIndefinite?: boolean
   allowUndefined?: boolean
+  coerceUndefinedToNull?: boolean
   allowInfinity?: boolean
   allowNaN?: boolean
   allowBigInt?: boolean

package/lib/7float.js

@@ -26,6 +26,8 @@ const MINOR_UNDEFINED = 23
 export function decodeUndefined (_data, _pos, _minor, options) {
   if (options.allowUndefined === false) {
     throw new Error(`${decodeErrPrefix} undefined values are not supported`)
+  } else if (options.coerceUndefinedToNull === true) {
+    return new Token(Type.null, null, 1)
   }
   return new Token(Type.undefined, undefined, 1)
 }