cborg 1.5.3 → 1.6.2

package/README.md

@@ -143,6 +143,7 @@ Decode valid CBOR bytes from a `Uint8Array` (or `Buffer`) and return a JavaScrip
 
 * `allowIndefinite` (boolean, default `true`): when the indefinite length additional information (`31`) is encountered for any type (arrays, maps, strings, bytes) _or_ a "break" is encountered, an error will be thrown.
 * `allowUndefined` (boolean, default `true`): when major 7, minor 23 (`undefined`) is encountered, an error will be thrown. To disallow `undefined` on encode, a custom [type encoder](#type-encoders) for `'undefined'` will need to be supplied.
+* `coerceUndefinedToNull` (boolean, default `false`): when both `allowUndefined` and `coerceUndefinedToNull` are set to `true`, all `undefined` tokens (major `7` minor `23`: `0xf7`) will be coerced to `null` tokens, such that `undefined` is an allowed token but will not appear in decoded values.
 * `allowInfinity` (boolean, default `true`): when an IEEE 754 `Infinity` or `-Infinity` value is encountered when decoding a major 7, an error will be thrown. To disallow `Infinity` and `-Infinity` on encode, a custom [type encoder](#type-encoders) for `'number'` will need to be supplied.
 * `allowNaN` (boolean, default `true`): when an IEEE 754 `NaN` value is encountered when decoding a major 7, an error will be thrown. To disallow `NaN` on encode, a custom [type encoder](#type-encoders) for `'number'` will need to be supplied.
 * `allowBigInt` (boolean, default `true`): when an integer outside of the safe integer range is encountered, an error will be thrown. To disallow `BigInt`s on encode, a custom [type encoder](#type-encoders) for `'bigint'` will need to be supplied.

package/cjs/browser-test/node-test-bin.js

@@ -219,4 +219,62 @@ Input may either be supplied as an argument or piped via stdin
     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, '');
+    assert.strictEqual(stdout, `a6                                                # map(6)
+  61                                              #   string(1)
+    61                                            #     "a"
+  80                                              #   array(0)
+  61                                              #   string(1)
+    62                                            #     "b"
+  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)
+`);
+  });
 });

package/cjs/browser-test/test-7float.js

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

package/cjs/browser-test/test-cbor-vectors.js

@@ -1,7 +1,6 @@
 'use strict';
 
 var chai = require('chai');
-var util = require('util');
 require('../cborg.js');
 var taglib = require('../taglib.js');
 var byteUtils = require('../lib/byte-utils.js');
@@ -56,7 +55,7 @@ describe('cbor/test-vectors', () => {
     if (typeof expected === 'string' && expected.startsWith('h\'')) {
       expected = byteUtils.fromHex(expected.replace(/(^h)'|('$)/g, ''));
     }
-    it(`test vector #${ i }: ${ util.inspect(expected).replace(/\n\s*/g, '') }`, () => {
+    it(`test vector #${ i }: ${ inspect(expected).replace(/\n\s*/g, '') }`, () => {
       if (fixture.error) {
         assert.throws(() => decode.decode(u8a, { tags }), fixture.error);
       } else {
@@ -65,10 +64,10 @@ describe('cbor/test-vectors', () => {
         }
         let actual = decode.decode(u8a, { tags });
         if (typeof actual === 'bigint') {
-          actual = util.inspect(actual);
+          actual = inspect(actual);
         }
         if (typeof expected === 'bigint') {
-          expected = util.inspect(expected);
+          expected = inspect(expected);
         }
         assert.deepEqual(actual, expected);
         if (fixture.roundtrip) {
@@ -85,3 +84,15 @@ describe('cbor/test-vectors', () => {
   it.skip('encode w/ tags', () => {
   });
 });
+function inspect(o) {
+  if (typeof o === 'string') {
+    return `'${ o }'`;
+  }
+  if (o instanceof Uint8Array) {
+    return `Uint8Array<${ o.join(',') }>`;
+  }
+  if (o == null || typeof o !== 'object') {
+    return String(o);
+  }
+  return JSON.stringify(o);
+}

package/cjs/lib/7float.js

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

package/cjs/lib/diagnostic.js

@@ -49,6 +49,9 @@ function* tokensToDiagnostic(inp, width = 100) {
         yield `${ margin }${ byteUtils.toHex(piece) }`.padEnd(width / 2, ' ') + `# ${ margin }"${ st }"`;
       }
     }
+    if (indent.length) {
+      indent[indent.length - 1]--;
+    }
     if (!token.type.terminal) {
       switch (token.type.name) {
       case 'map':
@@ -63,13 +66,9 @@ 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;
   }

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

@@ -219,4 +219,62 @@ Input may either be supplied as an argument or piped via stdin
     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, '');
+    assert.strictEqual(stdout, `a6                                                # map(6)
+  61                                              #   string(1)
+    61                                            #     "a"
+  80                                              #   array(0)
+  61                                              #   string(1)
+    62                                            #     "b"
+  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)
+`);
+  });
 });

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

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

package/cjs/node-test/test-cbor-vectors.js

@@ -1,7 +1,6 @@
 'use strict';
 
 var chai = require('chai');
-var util = require('util');
 require('../cborg.js');
 var taglib = require('../taglib.js');
 var byteUtils = require('../lib/byte-utils.js');
@@ -56,7 +55,7 @@ describe('cbor/test-vectors', () => {
     if (typeof expected === 'string' && expected.startsWith('h\'')) {
       expected = byteUtils.fromHex(expected.replace(/(^h)'|('$)/g, ''));
     }
-    it(`test vector #${ i }: ${ util.inspect(expected).replace(/\n\s*/g, '') }`, () => {
+    it(`test vector #${ i }: ${ inspect(expected).replace(/\n\s*/g, '') }`, () => {
       if (fixture.error) {
         assert.throws(() => decode.decode(u8a, { tags }), fixture.error);
       } else {
@@ -65,10 +64,10 @@ describe('cbor/test-vectors', () => {
         }
         let actual = decode.decode(u8a, { tags });
         if (typeof actual === 'bigint') {
-          actual = util.inspect(actual);
+          actual = inspect(actual);
         }
         if (typeof expected === 'bigint') {
-          expected = util.inspect(expected);
+          expected = inspect(expected);
         }
         assert.deepEqual(actual, expected);
         if (fixture.roundtrip) {
@@ -85,3 +84,15 @@ describe('cbor/test-vectors', () => {
   it.skip('encode w/ tags', () => {
   });
 });
+function inspect(o) {
+  if (typeof o === 'string') {
+    return `'${ o }'`;
+  }
+  if (o instanceof Uint8Array) {
+    return `Uint8Array<${ o.join(',') }>`;
+  }
+  if (o == null || typeof o !== 'object') {
+    return String(o);
+  }
+  return JSON.stringify(o);
+}

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

@@ -210,4 +210,62 @@ Input may either be supplied as an argument or piped via stdin
     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, '');
+    assert.strictEqual(stdout, `a6                                                # map(6)
+  61                                              #   string(1)
+    61                                            #     "a"
+  80                                              #   array(0)
+  61                                              #   string(1)
+    62                                            #     "b"
+  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)
+`);
+  });
 });

package/esm/browser-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/esm/browser-test/test-cbor-vectors.js

@@ -1,5 +1,4 @@
 import chai from 'chai';
-import { inspect } from 'util';
 import {
   decode,
   encode
@@ -81,4 +80,16 @@ describe('cbor/test-vectors', () => {
   }
   it.skip('encode w/ tags', () => {
   });
-});
+});
+function inspect(o) {
+  if (typeof o === 'string') {
+    return `'${ o }'`;
+  }
+  if (o instanceof Uint8Array) {
+    return `Uint8Array<${ o.join(',') }>`;
+  }
+  if (o == null || typeof o !== 'object') {
+    return String(o);
+  }
+  return JSON.stringify(o);
+}

package/esm/lib/7float.js

@@ -11,6 +11,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);
 }

package/esm/lib/diagnostic.js

@@ -44,6 +44,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,13 +61,9 @@ 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;
   }

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

@@ -210,4 +210,62 @@ Input may either be supplied as an argument or piped via stdin
     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, '');
+    assert.strictEqual(stdout, `a6                                                # map(6)
+  61                                              #   string(1)
+    61                                            #     "a"
+  80                                              #   array(0)
+  61                                              #   string(1)
+    62                                            #     "b"
+  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)
+`);
+  });
 });

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/esm/node-test/test-cbor-vectors.js

@@ -1,5 +1,4 @@
 import chai from 'chai';
-import { inspect } from 'util';
 import {
   decode,
   encode
@@ -81,4 +80,16 @@ describe('cbor/test-vectors', () => {
   }
   it.skip('encode w/ tags', () => {
   });
-});
+});
+function inspect(o) {
+  if (typeof o === 'string') {
+    return `'${ o }'`;
+  }
+  if (o instanceof Uint8Array) {
+    return `Uint8Array<${ o.join(',') }>`;
+  }
+  if (o == null || typeof o !== 'object') {
+    return String(o);
+  }
+  return JSON.stringify(o);
+}

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)
 }

package/lib/diagnostic.js

@@ -67,6 +67,9 @@ function * tokensToDiagnostic (inp, width = 100) {
       }
     }
 
+    if (indent.length) {
+      indent[indent.length - 1]--
+    }
     if (!token.type.terminal) {
       switch (token.type.name) {
         case 'map':
@@ -83,13 +86,9 @@ 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()
     }
     // @ts-ignore it should be set on a decode operation
     pos += token.encodedLength

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cborg",
-  "version": "1.5.3",
+  "version": "1.6.2",
   "description": "Fast CBOR with a focus on strictness",
   "main": "./cjs/cborg.js",
   "bin": {
@@ -13,9 +13,13 @@
     "build:copy": "mkdir -p dist/test && cp test/*.js dist/test/ && cp -a tsconfig.json *.js *.ts lib dist/",
     "build:types": "npm run build:copy && cd dist && tsc --build",
     "test:cjs": "npm run build && mocha dist/cjs/node-test/test-*.js dist/cjs/node-test/node-test-*.js",
+    "test:esm": "npm run build && mocha dist/esm/node-test/test-*.js dist/esm/node-test/node-test-*.js",
     "test:node": "c8 --check-coverage --branches 100 --functions 100 --lines 100 mocha test/test-*.js test/node-test-*.js",
-    "test:browser": "polendina --page --worker --serviceworker --cleanup dist/cjs/node-test/test-*.js",
-    "test": "npm run lint && npm run test:node && npm run test:cjs && npm run test:browser",
+    "test:browser:cjs": "polendina --page --worker --serviceworker --cleanup dist/cjs/browser-test/test-*.js",
+    "test:browser:esm": "polendina --page --worker --serviceworker --cleanup dist/esm/browser-test/test-*.js",
+    "test:browser": "npm run test:browser:cjs && npm run test:browser:cjs",
+    "test": "npm run lint && npm run test:node && npm run test:esm && npm run test:browser:esm",
+    "test:ci": "npm run lint && npm run test:node && npm run test:cjs && npm run test:esm && npm run test:browser",
     "coverage": "c8 --reporter=html mocha test/test-*.js && npx st -d coverage -p 8080"
   },
   "repository": {
@@ -28,14 +32,14 @@
   "author": "Rod <rod@vagg.org> (http://r.va.gg/)",
   "license": "Apache-2.0",
   "devDependencies": {
-    "c8": "^7.6.0",
-    "chai": "^4.3.3",
-    "ipjs": "^5.0.0",
-    "ipld-garbage": "^4.0.1",
-    "mocha": "^9.0.0",
-    "polendina": "^1.1.0",
-    "standard": "^16.0.3",
-    "typescript": "^4.2.4"
+    "c8": "^7.10.0",
+    "chai": "^4.3.4",
+    "ipjs": "^5.2.0",
+    "ipld-garbage": "^4.0.10",
+    "mocha": "^9.1.3",
+    "polendina": "~2.0.1",
+    "standard": "^16.0.4",
+    "typescript": "~4.5.3"
   },
   "exports": {
     ".": {

package/test/node-test-bin.js

@@ -250,4 +250,65 @@ Input may either be supplied as an argument or piped via stdin
     assert.strictEqual(stderr, '')
     assert.strictEqual(stdout, 'a3616101616282020365736d696c6564f09f9880\n')
   })
+
+  // complicated nesting to test indenting algorithm
+  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,
+`a6                                                # map(6)
+  61                                              #   string(1)
+    61                                            #     "a"
+  80                                              #   array(0)
+  61                                              #   string(1)
+    62                                            #     "b"
+  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)
+`)
+  })
 })

package/test/test-7float.js

@@ -97,10 +97,19 @@ describe('float', () => {
     })
 
     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, undefined])
       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, 2, Infinity])
       assert.deepStrictEqual(decode(fromHex('830102f9fc00')), [1, 2, -Infinity])

package/test/test-cbor-vectors.js

@@ -1,7 +1,6 @@
 /* eslint-env mocha,es2020 */
 
 import chai from 'chai'
-import { inspect } from 'util'
 
 import { decode, encode } from '../cborg.js'
 import * as taglib from 'cborg/taglib'
@@ -93,3 +92,16 @@ describe('cbor/test-vectors', () => {
   it.skip('encode w/ tags', () => {
   })
 })
+
+function inspect (o) {
+  if (typeof o === 'string') {
+    return `'${o}'`
+  }
+  if (o instanceof Uint8Array) {
+    return `Uint8Array<${o.join(',')}>`
+  }
+  if (o == null || typeof o !== 'object') {
+    return String(o)
+  }
+  return JSON.stringify(o)
+}

package/types/interface.d.ts

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

package/types/interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,EAAE,EAAE,EAAE,MAAM,UAAU,CAAA;AAE7B,oBAAY,mBAAmB,GAAG,KAAK,GAAG,KAAK,EAAE,GAAG,mBAAmB,EAAE,CAAA;AAEzE,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,SAAS,GAAG,SAAS,CAAA;IAC7B,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,CAAA;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,GAAG,OAAO,CAAA;CACvC;AAED,oBAAY,mBAAmB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,mBAAmB,GAAG,IAAI,CAAA;AAEtI,oBAAY,iBAAiB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,mBAAmB,CAAA;AAE7H,oBAAY,gBAAgB,GAAG;IAC7B,CAAC,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACvD,aAAa,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAAC;IAC5C,WAAW,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;CAC7D,CAAA;AAED,oBAAY,SAAS,GAAG,CAAC,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,EAAE,KAAK,MAAM,CAAA;AAEpF,oBAAY,gBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,UAAU,GAAG,SAAS,CAAA;AAEvE,MAAM,WAAW,eAAe;IAC9B,IAAI,IAAI,OAAO,CAAC;IAChB,IAAI,IAAI,KAAK,CAAA;CACd;AAED,oBAAY,UAAU,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAA;AAE5C,MAAM,WAAW,aAAa;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,eAAe,CAAA;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,YAAY,CAAC,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,CAAA;KAAE,CAAA;CAC3D"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,EAAE,EAAE,EAAE,MAAM,UAAU,CAAA;AAE7B,oBAAY,mBAAmB,GAAG,KAAK,GAAG,KAAK,EAAE,GAAG,mBAAmB,EAAE,CAAA;AAEzE,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,SAAS,GAAG,SAAS,CAAA;IAC7B,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,CAAA;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,GAAG,OAAO,CAAA;CACvC;AAED,oBAAY,mBAAmB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,mBAAmB,GAAG,IAAI,CAAA;AAEtI,oBAAY,iBAAiB,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,mBAAmB,CAAA;AAE7H,oBAAY,gBAAgB,GAAG;IAC7B,CAAC,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACvD,aAAa,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAAC;IAC5C,WAAW,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;CAC7D,CAAA;AAED,oBAAY,SAAS,GAAG,CAAC,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,EAAE,KAAK,MAAM,CAAA;AAEpF,oBAAY,gBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,UAAU,GAAG,SAAS,CAAA;AAEvE,MAAM,WAAW,eAAe;IAC9B,IAAI,IAAI,OAAO,CAAC;IAChB,IAAI,IAAI,KAAK,CAAA;CACd;AAED,oBAAY,UAAU,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAA;AAE5C,MAAM,WAAW,aAAa;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,eAAe,CAAA;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,YAAY,CAAC,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,CAAA;KAAE,CAAA;CAC3D"}

package/types/lib/7float.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"7float.d.ts","sourceRoot":"","sources":["../../lib/7float.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,uCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAOjB;AAED;;;;;;GAMG;AACH,mCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAOjB;AAoBD;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;GAIG;AACH,iCAJW,EAAE,SACF,KAAK,WACL,aAAa,QAwCvB;;IAED;;;;OAIG;IACH,0FAqBC;;;iBAhKY,OAAO,SAAS,EAAE,EAAE;4BACpB,OAAO,cAAc,EAAE,aAAa;4BACpC,OAAO,cAAc,EAAE,aAAa"}
+{"version":3,"file":"7float.d.ts","sourceRoot":"","sources":["../../lib/7float.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,uCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CASjB;AAED;;;;;;GAMG;AACH,mCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAOjB;AAoBD;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;GAIG;AACH,iCAJW,EAAE,SACF,KAAK,WACL,aAAa,QAwCvB;;IAED;;;;OAIG;IACH,0FAqBC;;;iBAlKY,OAAO,SAAS,EAAE,EAAE;4BACpB,OAAO,cAAc,EAAE,aAAa;4BACpC,OAAO,cAAc,EAAE,aAAa"}

package/types/lib/diagnostic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../lib/diagnostic.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wCAHW,UAAU,gEA4FpB"}
+{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../lib/diagnostic.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wCAHW,UAAU,gEA2FpB"}