cborg 1.7.0 → 1.9.0

package/README.md

@@ -27,6 +27,7 @@
     * [Options](#options)
   * [`decode(data[, options])`](#decodedata-options)
     * [Options](#options-1)
+  * [`encodedLength(data[, options])`](#encodedlengthdata-options)
   * [Type encoders](#type-encoders)
   * [Tag decoders](#tag-decoders)
 * [Deterministic encoding recommendations](#deterministic-encoding-recommendations)
@@ -246,9 +247,24 @@ Decode valid CBOR bytes from a `Uint8Array` (or `Buffer`) and return a JavaScrip
 * `strict` (boolean, default `false`): when decoding integers, including for lengths (arrays, maps, strings, bytes), values will be checked to see whether they were encoded in their smallest possible form. If not, an error will be thrown.
   * Currently, this form of deterministic strictness cannot be enforced for float representations, or map key ordering (pull requests _very_ welcome).
 * `useMaps` (boolean, default `false`): when decoding major 5 (map) entries, use a `Map` rather than a plain `Object`. This will nest for any encountered map. During encode, a `Map` will be interpreted as an `Object` and will round-trip as such unless `useMaps` is supplied, in which case, all `Map`s and `Object`s will round-trip as `Map`s. There is no way to retain the distinction during round-trip without using a custom tag.
+* `retainStringBytes` (boolean, default `false`): when decoding strings, retain the original bytes on the `Token` object as `byteValue`. Since it is possible to encode non-UTF-8 characters in strings in CBOR, and JavaScript doesn't properly handle non-UTF-8 in its conversion from bytes (`TextEncoder` or `Buffer`), this can result in a loss of data (and an inability to round-trip). Where this is important, a token stream should be consumed instead of a plain `decode()` and the `byteValue` property on string tokens can be inspected (see [lib/diagnostic.js](lib/diagnostic.js) for an example of its use.)
 * `tags` (array): a mapping of tag number to tag decoder function. By default no tags are supported. See [Tag decoders](#tag-decoders).
 * `tokenizer` (object): an object with two methods, `next()` which returns a `Token` and `done()` which returns a `boolean`. Can be used to implement custom input decoding. See the source code for examples.
 
+### `encodedLength(data[, options])`
+
+```js
+import { encodedLength } from 'cborg/length'
+```
+
+```js
+const { encodedLength } = require('cborg/length')
+```
+
+Calculate the byte length of the given data when encoded as CBOR with the options provided. The options are the same as for an `encode()` call. This calculation will be accurate if the same options are used as when performing a normal `encode()`. Some encode options can change the encoding output length.
+
+A `tokensToLength()` function is available which deals directly with a tokenized form of the object, but this only recommended for advanced users.
+
 ### Type encoders
 
 The `typeEncoders` property to the `options` argument to `encode()` allows you to add additional functionality to cborg, or override existing functionality.

package/cjs/browser-test/common.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var token = require('../lib/token.js');
+
+function dateDecoder(obj) {
+  if (typeof obj !== 'string') {
+    throw new Error('expected string for tag 1');
+  }
+  return new Date(obj);
+}
+function dateEncoder(obj) {
+  if (!(obj instanceof Date)) {
+    throw new Error('expected Date for "Date" encoder');
+  }
+  return [
+    new token.Token(token.Type.tag, 0),
+    new token.Token(token.Type.string, obj.toISOString().replace(/\.000Z$/, 'Z'))
+  ];
+}
+
+exports.dateDecoder = dateDecoder;
+exports.dateEncoder = dateEncoder;

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

@@ -331,4 +331,19 @@ Input may either be supplied as an argument or piped via stdin
 `);
     });
   });
+  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/cjs/browser-test/test-6tag.js

@@ -4,6 +4,7 @@ var chai = require('chai');
 var token = require('../lib/token.js');
 require('../cborg.js');
 var byteUtils = require('../lib/byte-utils.js');
+var common = require('./common.js');
 var encode = require('../lib/encode.js');
 var decode = require('../lib/decode.js');
 
@@ -12,21 +13,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var chai__default = /*#__PURE__*/_interopDefaultLegacy(chai);
 
 const {assert} = chai__default["default"];
-function dateDecoder(obj) {
-  if (typeof obj !== 'string') {
-    throw new Error('expected string for tag 1');
-  }
-  return new Date(obj);
-}
-function dateEncoder(obj) {
-  if (!(obj instanceof Date)) {
-    throw new Error('expected Date for "Date" encoder');
-  }
-  return [
-    new token.Token(token.Type.tag, 0),
-    new token.Token(token.Type.string, obj.toISOString().replace(/\.000Z$/, 'Z'))
-  ];
-}
 function Uint16ArrayDecoder(obj) {
   if (typeof obj !== 'string') {
     throw new Error('expected string for tag 23');
@@ -46,8 +32,8 @@ function Uint16ArrayEncoder(obj) {
 describe('tag', () => {
   it('date', () => {
     assert.throws(() => encode.encode({ d: new Date() }), /unsupported type: Date/);
-    assert.equal(byteUtils.toHex(encode.encode(new Date('2013-03-21T20:04:00Z'), { typeEncoders: { Date: dateEncoder } })), 'c074323031332d30332d32315432303a30343a30305a');
-    const decodedDate = decode.decode(byteUtils.fromHex('c074323031332d30332d32315432303a30343a30305a'), { tags: { 0: dateDecoder } });
+    assert.equal(byteUtils.toHex(encode.encode(new Date('2013-03-21T20:04:00Z'), { typeEncoders: { Date: common.dateEncoder } })), 'c074323031332d30332d32315432303a30343a30305a');
+    const decodedDate = decode.decode(byteUtils.fromHex('c074323031332d30332d32315432303a30343a30305a'), { tags: { 0: common.dateDecoder } });
     assert.instanceOf(decodedDate, Date);
     assert.equal(decodedDate.toISOString(), new Date('2013-03-21T20:04:00Z').toISOString());
   });
@@ -69,12 +55,12 @@ describe('tag', () => {
     const verify = (hex, strict) => {
       if (!strict) {
         assert.throws(() => decode.decode(byteUtils.fromHex(hex), {
-          tags: { 8: dateDecoder },
+          tags: { 8: common.dateDecoder },
           strict: true
         }), /integer encoded in more bytes than necessary/);
       }
       const decodedDate = decode.decode(byteUtils.fromHex(hex), {
-        tags: { 8: dateDecoder },
+        tags: { 8: common.dateDecoder },
         strict
       });
       assert.instanceOf(decodedDate, Date);

package/cjs/browser-test/test-length.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var chai = require('chai');
+var ipldGarbage = require('ipld-garbage');
+var _0uint = require('../lib/0uint.js');
+require('../cborg.js');
+var length = require('../lib/length.js');
+var common = require('./common.js');
+var encode = require('../lib/encode.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var chai__default = /*#__PURE__*/_interopDefaultLegacy(chai);
+
+const {assert} = chai__default["default"];
+function verifyLength(object, options) {
+  const len = length.encodedLength(object, options);
+  const encoded = encode.encode(object, options);
+  const actual = encoded.length;
+  assert.strictEqual(actual, len, JSON.stringify(object));
+}
+describe('encodedLength', () => {
+  it('int boundaries', () => {
+    for (let ii = 0; ii < 4; ii++) {
+      verifyLength(_0uint.uintBoundaries[ii]);
+      verifyLength(_0uint.uintBoundaries[ii] - 1);
+      verifyLength(_0uint.uintBoundaries[ii] + 1);
+      verifyLength(-1 * _0uint.uintBoundaries[ii]);
+      verifyLength(-1 * _0uint.uintBoundaries[ii] - 1);
+      verifyLength(-1 * _0uint.uintBoundaries[ii] + 1);
+    }
+  });
+  it('tags', () => {
+    verifyLength({ date: new Date('2013-03-21T20:04:00Z') }, { typeEncoders: { Date: common.dateEncoder } });
+  });
+  it('floats', () => {
+    verifyLength(0.5);
+    verifyLength(0.5, { float64: true });
+    verifyLength(8.940696716308594e-8);
+    verifyLength(8.940696716308594e-8, { float64: true });
+  });
+  it('small garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 1000; ii++) {
+      const gbg = ipldGarbage.garbage(1 << 6, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+  it('medium garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 100; ii++) {
+      const gbg = ipldGarbage.garbage(1 << 16, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+  it('large garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 10; ii++) {
+      const gbg = ipldGarbage.garbage(1 << 20, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+});

package/cjs/lib/3string.js

@@ -8,29 +8,33 @@ var _0uint = require('./0uint.js');
 var _2bytes = require('./2bytes.js');
 var byteUtils = require('./byte-utils.js');
 
-function toToken(data, pos, prefix, length) {
+function toToken(data, pos, prefix, length, options) {
   const totLength = prefix + length;
   common.assertEnoughData(data, pos, totLength);
-  return new token.Token(token.Type.string, byteUtils.toString(data, pos + prefix, pos + totLength), totLength);
+  const tok = new token.Token(token.Type.string, byteUtils.toString(data, pos + prefix, pos + totLength), totLength);
+  if (options.retainStringBytes === true) {
+    tok.byteValue = byteUtils.slice(data, pos + prefix, pos + totLength);
+  }
+  return tok;
 }
-function decodeStringCompact(data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor);
+function decodeStringCompact(data, pos, minor, options) {
+  return toToken(data, pos, 1, minor, options);
 }
 function decodeString8(data, pos, _minor, options) {
-  return toToken(data, pos, 2, _0uint.readUint8(data, pos + 1, options));
+  return toToken(data, pos, 2, _0uint.readUint8(data, pos + 1, options), options);
 }
 function decodeString16(data, pos, _minor, options) {
-  return toToken(data, pos, 3, _0uint.readUint16(data, pos + 1, options));
+  return toToken(data, pos, 3, _0uint.readUint16(data, pos + 1, options), options);
 }
 function decodeString32(data, pos, _minor, options) {
-  return toToken(data, pos, 5, _0uint.readUint32(data, pos + 1, options));
+  return toToken(data, pos, 5, _0uint.readUint32(data, pos + 1, options), options);
 }
 function decodeString64(data, pos, _minor, options) {
   const l = _0uint.readUint64(data, pos + 1, options);
   if (typeof l === 'bigint') {
     throw new Error(`${ common.decodeErrPrefix } 64-bit integer string lengths not supported`);
   }
-  return toToken(data, pos, 9, l);
+  return toToken(data, pos, 9, l, options);
 }
 const encodeString = _2bytes.encodeBytes;
 

package/cjs/lib/4array.js

@@ -38,6 +38,9 @@ function encodeArray(buf, token$1) {
   _0uint.encodeUintValue(buf, token.Type.array.majorEncoded, token$1.value);
 }
 encodeArray.compareTokens = _0uint.encodeUint.compareTokens;
+encodeArray.encodedSize = function encodedSize(token) {
+  return _0uint.encodeUintValue.encodedSize(token.value);
+};
 
 exports.decodeArray16 = decodeArray16;
 exports.decodeArray32 = decodeArray32;

package/cjs/lib/5map.js

@@ -38,6 +38,9 @@ function encodeMap(buf, token$1) {
   _0uint.encodeUintValue(buf, token.Type.map.majorEncoded, token$1.value);
 }
 encodeMap.compareTokens = _0uint.encodeUint.compareTokens;
+encodeMap.encodedSize = function encodedSize(token) {
+  return _0uint.encodeUintValue.encodedSize(token.value);
+};
 
 exports.decodeMap16 = decodeMap16;
 exports.decodeMap32 = decodeMap32;

package/cjs/lib/6tag.js

@@ -24,6 +24,9 @@ function encodeTag(buf, token$1) {
   _0uint.encodeUintValue(buf, token.Type.tag.majorEncoded, token$1.value);
 }
 encodeTag.compareTokens = _0uint.encodeUint.compareTokens;
+encodeTag.encodedSize = function encodedSize(token) {
+  return _0uint.encodeUintValue.encodedSize(token.value);
+};
 
 exports.decodeTag16 = decodeTag16;
 exports.decodeTag32 = decodeTag32;

package/cjs/lib/7float.js

@@ -87,10 +87,9 @@ encodeFloat.encodedSize = function encodedSize(token, options) {
   if (float === false || float === true || float === null || float === undefined) {
     return 1;
   }
-  let decoded;
   if (!options || options.float64 !== true) {
     encodeFloat16(float);
-    decoded = readFloat16(ui8a, 1);
+    let decoded = readFloat16(ui8a, 1);
     if (float === decoded || Number.isNaN(float)) {
       return 3;
     }

package/cjs/lib/bl.js

@@ -14,9 +14,11 @@ class Bl {
     this._initReuseChunk = null;
   }
   reset() {
-    this.chunks = [];
     this.cursor = 0;
     this.maxCursor = -1;
+    if (this.chunks.length) {
+      this.chunks = [];
+    }
     if (this._initReuseChunk !== null) {
       this.chunks.push(this._initReuseChunk);
       this.maxCursor = this._initReuseChunk.length - 1;

package/cjs/lib/diagnostic.js

@@ -9,7 +9,7 @@ var _0uint = require('./0uint.js');
 const utf8Encoder = new TextEncoder();
 const utf8Decoder = new TextDecoder();
 function* tokensToDiagnostic(inp, width = 100) {
-  const tokeniser = new decode.Tokeniser(inp);
+  const tokeniser = new decode.Tokeniser(inp, { retainStringBytes: true });
   let pos = 0;
   const indent = [];
   const slc = (start, length) => {
@@ -59,15 +59,22 @@ function* tokensToDiagnostic(inp, width = 100) {
     }
     yield outp;
     if (str) {
+      let asString = token.type.name === 'string';
       margin += '  ';
-      const repr = token.type.name === 'bytes' ? token.value : utf8Encoder.encode(token.value);
+      let repr = asString ? utf8Encoder.encode(token.value) : token.value;
+      if (asString && token.byteValue !== undefined) {
+        if (repr.length !== token.byteValue.length) {
+          repr = token.byteValue;
+          asString = false;
+        }
+      }
       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' ? utf8Decoder.decode(piece) : piece.reduce((p, c) => {
-          if (c < 32 || c === 127) {
+        const st = asString ? utf8Decoder.decode(piece) : piece.reduce((p, c) => {
+          if (c < 32 || c >= 127 && c < 161 || c === 173) {
             return `${ p }\\x${ c.toString(16).padStart(2, '0') }`;
           }
           return `${ p }${ String.fromCharCode(c) }`;

package/cjs/lib/encode.js

@@ -22,15 +22,19 @@ const defaultEncodeOptions = {
   mapSorter,
   quickEncodeToken: jump.quickEncodeToken
 };
-const cborEncoders = [];
-cborEncoders[token.Type.uint.major] = _0uint.encodeUint;
-cborEncoders[token.Type.negint.major] = _1negint.encodeNegint;
-cborEncoders[token.Type.bytes.major] = _2bytes.encodeBytes;
-cborEncoders[token.Type.string.major] = _3string.encodeString;
-cborEncoders[token.Type.array.major] = _4array.encodeArray;
-cborEncoders[token.Type.map.major] = _5map.encodeMap;
-cborEncoders[token.Type.tag.major] = _6tag.encodeTag;
-cborEncoders[token.Type.float.major] = _7float.encodeFloat;
+function makeCborEncoders() {
+  const encoders = [];
+  encoders[token.Type.uint.major] = _0uint.encodeUint;
+  encoders[token.Type.negint.major] = _1negint.encodeNegint;
+  encoders[token.Type.bytes.major] = _2bytes.encodeBytes;
+  encoders[token.Type.string.major] = _3string.encodeString;
+  encoders[token.Type.array.major] = _4array.encodeArray;
+  encoders[token.Type.map.major] = _5map.encodeMap;
+  encoders[token.Type.tag.major] = _6tag.encodeTag;
+  encoders[token.Type.float.major] = _7float.encodeFloat;
+  return encoders;
+}
+const cborEncoders = makeCborEncoders();
 const buf = new bl.Bl();
 class Ref {
   constructor(obj, parent) {
@@ -228,6 +232,7 @@ function encodeCustom(data, encoders, options) {
       return byteUtils.asU8A(buf.chunks[0]);
     }
   }
+  buf.reset();
   tokensToEncoded(buf, tokens, encoders, options);
   return buf.toBytes(true);
 }
@@ -239,4 +244,5 @@ function encode(data, options) {
 exports.Ref = Ref;
 exports.encode = encode;
 exports.encodeCustom = encodeCustom;
+exports.makeCborEncoders = makeCborEncoders;
 exports.objectToTokens = objectToTokens;

package/cjs/lib/length.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var encode = require('./encode.js');
+var jump = require('./jump.js');
+
+const cborEncoders = encode.makeCborEncoders();
+const defaultEncodeOptions = {
+  float64: false,
+  quickEncodeToken: jump.quickEncodeToken
+};
+function encodedLength(data, options) {
+  options = Object.assign({}, defaultEncodeOptions, options);
+  options.mapSorter = undefined;
+  const tokens = encode.objectToTokens(data, options);
+  return tokensToLength(tokens, cborEncoders, options);
+}
+function tokensToLength(tokens, encoders = cborEncoders, options = defaultEncodeOptions) {
+  if (Array.isArray(tokens)) {
+    let len = 0;
+    for (const token of tokens) {
+      len += tokensToLength(token, encoders, options);
+    }
+    return len;
+  } else {
+    const encoder = encoders[tokens.type.major];
+    if (encoder.encodedSize === undefined || typeof encoder.encodedSize !== 'function') {
+      throw new Error(`Encoder for ${ tokens.type.name } does not have an encodedSize()`);
+    }
+    return encoder.encodedSize(tokens, options);
+  }
+}
+
+exports.encodedLength = encodedLength;
+exports.tokensToLength = tokensToLength;

package/cjs/lib/token.js

@@ -35,6 +35,7 @@ class Token {
     this.value = value;
     this.encodedLength = encodedLength;
     this.encodedBytes = undefined;
+    this.byteValue = undefined;
   }
   toString() {
     return `Token[${ this.type }].${ this.value }`;

package/cjs/node-test/common.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var token = require('../lib/token.js');
+
+function dateDecoder(obj) {
+  if (typeof obj !== 'string') {
+    throw new Error('expected string for tag 1');
+  }
+  return new Date(obj);
+}
+function dateEncoder(obj) {
+  if (!(obj instanceof Date)) {
+    throw new Error('expected Date for "Date" encoder');
+  }
+  return [
+    new token.Token(token.Type.tag, 0),
+    new token.Token(token.Type.string, obj.toISOString().replace(/\.000Z$/, 'Z'))
+  ];
+}
+
+exports.dateDecoder = dateDecoder;
+exports.dateEncoder = dateEncoder;

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

@@ -331,4 +331,19 @@ Input may either be supplied as an argument or piped via stdin
 `);
     });
   });
+  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/cjs/node-test/test-6tag.js

@@ -4,6 +4,7 @@ var chai = require('chai');
 var token = require('../lib/token.js');
 require('../cborg.js');
 var byteUtils = require('../lib/byte-utils.js');
+var common = require('./common.js');
 var encode = require('../lib/encode.js');
 var decode = require('../lib/decode.js');
 
@@ -12,21 +13,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var chai__default = /*#__PURE__*/_interopDefaultLegacy(chai);
 
 const {assert} = chai__default["default"];
-function dateDecoder(obj) {
-  if (typeof obj !== 'string') {
-    throw new Error('expected string for tag 1');
-  }
-  return new Date(obj);
-}
-function dateEncoder(obj) {
-  if (!(obj instanceof Date)) {
-    throw new Error('expected Date for "Date" encoder');
-  }
-  return [
-    new token.Token(token.Type.tag, 0),
-    new token.Token(token.Type.string, obj.toISOString().replace(/\.000Z$/, 'Z'))
-  ];
-}
 function Uint16ArrayDecoder(obj) {
   if (typeof obj !== 'string') {
     throw new Error('expected string for tag 23');
@@ -46,8 +32,8 @@ function Uint16ArrayEncoder(obj) {
 describe('tag', () => {
   it('date', () => {
     assert.throws(() => encode.encode({ d: new Date() }), /unsupported type: Date/);
-    assert.equal(byteUtils.toHex(encode.encode(new Date('2013-03-21T20:04:00Z'), { typeEncoders: { Date: dateEncoder } })), 'c074323031332d30332d32315432303a30343a30305a');
-    const decodedDate = decode.decode(byteUtils.fromHex('c074323031332d30332d32315432303a30343a30305a'), { tags: { 0: dateDecoder } });
+    assert.equal(byteUtils.toHex(encode.encode(new Date('2013-03-21T20:04:00Z'), { typeEncoders: { Date: common.dateEncoder } })), 'c074323031332d30332d32315432303a30343a30305a');
+    const decodedDate = decode.decode(byteUtils.fromHex('c074323031332d30332d32315432303a30343a30305a'), { tags: { 0: common.dateDecoder } });
     assert.instanceOf(decodedDate, Date);
     assert.equal(decodedDate.toISOString(), new Date('2013-03-21T20:04:00Z').toISOString());
   });
@@ -69,12 +55,12 @@ describe('tag', () => {
     const verify = (hex, strict) => {
       if (!strict) {
         assert.throws(() => decode.decode(byteUtils.fromHex(hex), {
-          tags: { 8: dateDecoder },
+          tags: { 8: common.dateDecoder },
           strict: true
         }), /integer encoded in more bytes than necessary/);
       }
       const decodedDate = decode.decode(byteUtils.fromHex(hex), {
-        tags: { 8: dateDecoder },
+        tags: { 8: common.dateDecoder },
         strict
       });
       assert.instanceOf(decodedDate, Date);

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

@@ -0,0 +1,63 @@
+'use strict';
+
+var chai = require('chai');
+var ipldGarbage = require('ipld-garbage');
+var _0uint = require('../lib/0uint.js');
+require('../cborg.js');
+var length = require('../lib/length.js');
+var common = require('./common.js');
+var encode = require('../lib/encode.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var chai__default = /*#__PURE__*/_interopDefaultLegacy(chai);
+
+const {assert} = chai__default["default"];
+function verifyLength(object, options) {
+  const len = length.encodedLength(object, options);
+  const encoded = encode.encode(object, options);
+  const actual = encoded.length;
+  assert.strictEqual(actual, len, JSON.stringify(object));
+}
+describe('encodedLength', () => {
+  it('int boundaries', () => {
+    for (let ii = 0; ii < 4; ii++) {
+      verifyLength(_0uint.uintBoundaries[ii]);
+      verifyLength(_0uint.uintBoundaries[ii] - 1);
+      verifyLength(_0uint.uintBoundaries[ii] + 1);
+      verifyLength(-1 * _0uint.uintBoundaries[ii]);
+      verifyLength(-1 * _0uint.uintBoundaries[ii] - 1);
+      verifyLength(-1 * _0uint.uintBoundaries[ii] + 1);
+    }
+  });
+  it('tags', () => {
+    verifyLength({ date: new Date('2013-03-21T20:04:00Z') }, { typeEncoders: { Date: common.dateEncoder } });
+  });
+  it('floats', () => {
+    verifyLength(0.5);
+    verifyLength(0.5, { float64: true });
+    verifyLength(8.940696716308594e-8);
+    verifyLength(8.940696716308594e-8, { float64: true });
+  });
+  it('small garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 1000; ii++) {
+      const gbg = ipldGarbage.garbage(1 << 6, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+  it('medium garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 100; ii++) {
+      const gbg = ipldGarbage.garbage(1 << 16, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+  it('large garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 10; ii++) {
+      const gbg = ipldGarbage.garbage(1 << 20, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+});

package/esm/browser-test/common.js

@@ -0,0 +1,19 @@
+import {
+  Token,
+  Type
+} from '../lib/token.js';
+export function dateDecoder(obj) {
+  if (typeof obj !== 'string') {
+    throw new Error('expected string for tag 1');
+  }
+  return new Date(obj);
+}
+export function dateEncoder(obj) {
+  if (!(obj instanceof Date)) {
+    throw new Error('expected Date for "Date" encoder');
+  }
+  return [
+    new Token(Type.tag, 0),
+    new Token(Type.string, obj.toISOString().replace(/\.000Z$/, 'Z'))
+  ];
+}

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

@@ -322,4 +322,19 @@ Input may either be supplied as an argument or piped via stdin
 `);
     });
   });
+  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/esm/browser-test/test-6tag.js

@@ -11,22 +11,11 @@ import {
   fromHex,
   toHex
 } from '../lib/byte-utils.js';
+import {
+  dateDecoder,
+  dateEncoder
+} from './common.js';
 const {assert} = chai;
-function dateDecoder(obj) {
-  if (typeof obj !== 'string') {
-    throw new Error('expected string for tag 1');
-  }
-  return new Date(obj);
-}
-function dateEncoder(obj) {
-  if (!(obj instanceof Date)) {
-    throw new Error('expected Date for "Date" encoder');
-  }
-  return [
-    new Token(Type.tag, 0),
-    new Token(Type.string, obj.toISOString().replace(/\.000Z$/, 'Z'))
-  ];
-}
 function Uint16ArrayDecoder(obj) {
   if (typeof obj !== 'string') {
     throw new Error('expected string for tag 23');