cborg 1.7.0 → 1.9.0

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

@@ -0,0 +1,55 @@
+import chai from 'chai';
+import { garbage } from 'ipld-garbage';
+import { uintBoundaries } from '../lib/0uint.js';
+import { encode } from '../cborg.js';
+import { encodedLength } from '../lib/length.js';
+import { dateEncoder } from './common.js';
+const {assert} = chai;
+function verifyLength(object, options) {
+  const len = encodedLength(object, options);
+  const encoded = 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(uintBoundaries[ii]);
+      verifyLength(uintBoundaries[ii] - 1);
+      verifyLength(uintBoundaries[ii] + 1);
+      verifyLength(-1 * uintBoundaries[ii]);
+      verifyLength(-1 * uintBoundaries[ii] - 1);
+      verifyLength(-1 * uintBoundaries[ii] + 1);
+    }
+  });
+  it('tags', () => {
+    verifyLength({ date: new Date('2013-03-21T20:04:00Z') }, { typeEncoders: { Date: 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 = garbage(1 << 6, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+  it('medium garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 100; ii++) {
+      const gbg = garbage(1 << 16, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+  it('large garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 10; ii++) {
+      const gbg = garbage(1 << 20, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+});

package/esm/lib/3string.js

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

package/esm/lib/4array.js

@@ -35,4 +35,7 @@ export function decodeArrayIndefinite(data, pos, _minor, options) {
 export function encodeArray(buf, token) {
   uint.encodeUintValue(buf, Type.array.majorEncoded, token.value);
 }
-encodeArray.compareTokens = uint.encodeUint.compareTokens;
+encodeArray.compareTokens = uint.encodeUint.compareTokens;
+encodeArray.encodedSize = function encodedSize(token) {
+  return uint.encodeUintValue.encodedSize(token.value);
+};

package/esm/lib/5map.js

@@ -35,4 +35,7 @@ export function decodeMapIndefinite(data, pos, _minor, options) {
 export function encodeMap(buf, token) {
   uint.encodeUintValue(buf, Type.map.majorEncoded, token.value);
 }
-encodeMap.compareTokens = uint.encodeUint.compareTokens;
+encodeMap.compareTokens = uint.encodeUint.compareTokens;
+encodeMap.encodedSize = function encodedSize(token) {
+  return uint.encodeUintValue.encodedSize(token.value);
+};

package/esm/lib/6tag.js

@@ -21,4 +21,7 @@ export function decodeTag64(data, pos, _minor, options) {
 export function encodeTag(buf, token) {
   uint.encodeUintValue(buf, Type.tag.majorEncoded, token.value);
 }
-encodeTag.compareTokens = uint.encodeUint.compareTokens;
+encodeTag.compareTokens = uint.encodeUint.compareTokens;
+encodeTag.encodedSize = function encodedSize(token) {
+  return uint.encodeUintValue.encodedSize(token.value);
+};

package/esm/lib/7float.js

@@ -85,10 +85,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/esm/lib/bl.js

@@ -13,9 +13,11 @@ export 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/esm/lib/diagnostic.js

@@ -7,7 +7,7 @@ import { uintBoundaries } from './0uint.js';
 const utf8Encoder = new TextEncoder();
 const utf8Decoder = new TextDecoder();
 function* tokensToDiagnostic(inp, width = 100) {
-  const tokeniser = new Tokeniser(inp);
+  const tokeniser = new Tokeniser(inp, { retainStringBytes: true });
   let pos = 0;
   const indent = [];
   const slc = (start, length) => {
@@ -57,15 +57,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/esm/lib/encode.js

@@ -20,15 +20,19 @@ const defaultEncodeOptions = {
   mapSorter,
   quickEncodeToken
 };
-const cborEncoders = [];
-cborEncoders[Type.uint.major] = encodeUint;
-cborEncoders[Type.negint.major] = encodeNegint;
-cborEncoders[Type.bytes.major] = encodeBytes;
-cborEncoders[Type.string.major] = encodeString;
-cborEncoders[Type.array.major] = encodeArray;
-cborEncoders[Type.map.major] = encodeMap;
-cborEncoders[Type.tag.major] = encodeTag;
-cborEncoders[Type.float.major] = encodeFloat;
+export function makeCborEncoders() {
+  const encoders = [];
+  encoders[Type.uint.major] = encodeUint;
+  encoders[Type.negint.major] = encodeNegint;
+  encoders[Type.bytes.major] = encodeBytes;
+  encoders[Type.string.major] = encodeString;
+  encoders[Type.array.major] = encodeArray;
+  encoders[Type.map.major] = encodeMap;
+  encoders[Type.tag.major] = encodeTag;
+  encoders[Type.float.major] = encodeFloat;
+  return encoders;
+}
+const cborEncoders = makeCborEncoders();
 const buf = new Bl();
 class Ref {
   constructor(obj, parent) {
@@ -226,6 +230,7 @@ function encodeCustom(data, encoders, options) {
       return asU8A(buf.chunks[0]);
     }
   }
+  buf.reset();
   tokensToEncoded(buf, tokens, encoders, options);
   return buf.toBytes(true);
 }

package/esm/lib/length.js

@@ -0,0 +1,31 @@
+import {
+  makeCborEncoders,
+  objectToTokens
+} from './encode.js';
+import { quickEncodeToken } from './jump.js';
+const cborEncoders = makeCborEncoders();
+const defaultEncodeOptions = {
+  float64: false,
+  quickEncodeToken
+};
+export function encodedLength(data, options) {
+  options = Object.assign({}, defaultEncodeOptions, options);
+  options.mapSorter = undefined;
+  const tokens = objectToTokens(data, options);
+  return tokensToLength(tokens, cborEncoders, options);
+}
+export 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);
+  }
+}

package/esm/lib/token.js

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

package/esm/node-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/node-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/node-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');

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

@@ -0,0 +1,55 @@
+import chai from 'chai';
+import { garbage } from 'ipld-garbage';
+import { uintBoundaries } from '../lib/0uint.js';
+import { encode } from '../cborg.js';
+import { encodedLength } from '../lib/length.js';
+import { dateEncoder } from './common.js';
+const {assert} = chai;
+function verifyLength(object, options) {
+  const len = encodedLength(object, options);
+  const encoded = 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(uintBoundaries[ii]);
+      verifyLength(uintBoundaries[ii] - 1);
+      verifyLength(uintBoundaries[ii] + 1);
+      verifyLength(-1 * uintBoundaries[ii]);
+      verifyLength(-1 * uintBoundaries[ii] - 1);
+      verifyLength(-1 * uintBoundaries[ii] + 1);
+    }
+  });
+  it('tags', () => {
+    verifyLength({ date: new Date('2013-03-21T20:04:00Z') }, { typeEncoders: { Date: 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 = garbage(1 << 6, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+  it('medium garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 100; ii++) {
+      const gbg = garbage(1 << 16, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+  it('large garbage', function () {
+    this.timeout(10000);
+    for (let ii = 0; ii < 10; ii++) {
+      const gbg = garbage(1 << 20, { weights: { CID: 0 } });
+      verifyLength(gbg);
+    }
+  });
+});

package/interface.ts

@@ -16,6 +16,7 @@ export type StrictTypeEncoder = (data: any, typ: string, options: EncodeOptions,
 export type TokenTypeEncoder = {
   (buf: Bl, token: Token, options?: EncodeOptions): void;
   compareTokens(t1: Token, t2: Token): number;
+  // TODO: make this non-optional as a breaking change and remove the throw in length.js
   encodedSize?(token: Token, options?: EncodeOptions): number;
 }
 
@@ -39,6 +40,7 @@ export interface DecodeOptions {
   allowBigInt?: boolean
   strict?: boolean
   useMaps?: boolean
+  retainStringBytes?: boolean
   tags?: TagDecoder[],
   tokenizer?: DecodeTokenizer
 }

package/length

@@ -0,0 +1 @@
+module.exports = require('./cjs/lib/length.js')

package/lib/3string.js

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

package/lib/4array.js

@@ -103,3 +103,11 @@ export function encodeArray (buf, token) {
 // using an array as a map key, are you sure about this? we can only sort
 // by map length here, it's up to the encoder to decide to look deeper
 encodeArray.compareTokens = uint.encodeUint.compareTokens
+
+/**
+ * @param {Token} token
+ * @returns {number}
+ */
+encodeArray.encodedSize = function encodedSize (token) {
+  return uint.encodeUintValue.encodedSize(token.value)
+}

package/lib/5map.js

@@ -103,3 +103,11 @@ export function encodeMap (buf, token) {
 // using a map as a map key, are you sure about this? we can only sort
 // by map length here, it's up to the encoder to decide to look deeper
 encodeMap.compareTokens = uint.encodeUint.compareTokens
+
+/**
+ * @param {Token} token
+ * @returns {number}
+ */
+encodeMap.encodedSize = function encodedSize (token) {
+  return uint.encodeUintValue.encodedSize(token.value)
+}

package/lib/6tag.js

@@ -70,3 +70,11 @@ export function encodeTag (buf, token) {
 }
 
 encodeTag.compareTokens = uint.encodeUint.compareTokens
+
+/**
+ * @param {Token} token
+ * @returns {number}
+ */
+encodeTag.encodedSize = function encodedSize (token) {
+  return uint.encodeUintValue.encodedSize(token.value)
+}

package/lib/7float.js

@@ -154,10 +154,9 @@ encodeFloat.encodedSize = function encodedSize (token, options) {
     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/lib/bl.js

@@ -42,9 +42,11 @@ export class Bl {
   }
 
   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/lib/diagnostic.js

@@ -10,7 +10,7 @@ const utf8Decoder = new TextDecoder()
  * @param {number} [width]
  */
 function * tokensToDiagnostic (inp, width = 100) {
-  const tokeniser = new Tokeniser(inp)
+  const tokeniser = new Tokeniser(inp, { retainStringBytes: true })
   let pos = 0
   const indent = []
 
@@ -77,19 +77,26 @@ 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) {
+          // bail on printing this as a string, it's probably not utf8, so treat it as bytes
+          // (you can probably blame a Go programmer for this)
+          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
-        // the assumption that we can utf8 a byte-sliced version is a stretch,
-        // we could be slicing in the middle of a multi-byte character
-        const st = token.type.name === 'string'
+        const st = asString
           ? utf8Decoder.decode(piece)
           : piece.reduce((/** @type {string} */ p, /** @type {number} */ c) => {
-            if (c < 0x20 || c === 0x7f) {
+            if (c < 0x20 || (c >= 0x7f && c < 0xa1) || c === 0xad) {
               return `${p}\\x${c.toString(16).padStart(2, '0')}`
             }
             return `${p}${String.fromCharCode(c)}`

package/lib/encode.js

@@ -30,16 +30,21 @@ const defaultEncodeOptions = {
   quickEncodeToken
 }
 
-/** @type {TokenTypeEncoder[]} */
-const cborEncoders = []
-cborEncoders[Type.uint.major] = encodeUint
-cborEncoders[Type.negint.major] = encodeNegint
-cborEncoders[Type.bytes.major] = encodeBytes
-cborEncoders[Type.string.major] = encodeString
-cborEncoders[Type.array.major] = encodeArray
-cborEncoders[Type.map.major] = encodeMap
-cborEncoders[Type.tag.major] = encodeTag
-cborEncoders[Type.float.major] = encodeFloat
+/** @returns {TokenTypeEncoder[]} */
+export function makeCborEncoders () {
+  const encoders = []
+  encoders[Type.uint.major] = encodeUint
+  encoders[Type.negint.major] = encodeNegint
+  encoders[Type.bytes.major] = encodeBytes
+  encoders[Type.string.major] = encodeString
+  encoders[Type.array.major] = encodeArray
+  encoders[Type.map.major] = encodeMap
+  encoders[Type.tag.major] = encodeTag
+  encoders[Type.float.major] = encodeFloat
+  return encoders
+}
+
+const cborEncoders = makeCborEncoders()
 
 const buf = new Bl()
 
@@ -441,6 +446,7 @@ function encodeCustom (data, encoders, options) {
       return asU8A(buf.chunks[0])
     }
   }
+  buf.reset()
   tokensToEncoded(buf, tokens, encoders, options)
   return buf.toBytes(true)
 }