@fireproof/vendor 0.0.0-smoke

package/src/cborg/cborg/test/test-5map.js

@@ -0,0 +1,284 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+
+import { decode, encode } from '../cborg.js'
+import { fromHex, toHex } from '../lib/byte-utils.js'
+
+const { assert } = chai
+
+// TODO: reject duplicate keys from encoded form
+
+const fixtures = [
+  { data: 'a0', expected: {}, type: 'map empty' },
+  { data: 'a0', expected: new Map(), type: 'map empty (useMaps)', useMaps: true },
+  { data: 'a1616101', expected: { a: 1 }, type: 'map 1 pair' },
+  { data: 'a161316161', expected: { 1: 'a' }, type: 'map 1 pair (rev)' },
+  {
+    data: 'a1016161',
+    expected: toMap([[1, 'a']]),
+    type: 'map 1 pair (int key as Map w/ useMaps)',
+    useMaps: true
+  },
+  {
+    data: 'a243010203633132334302030463323334',
+    expected: toMap([[Uint8Array.from([1, 2, 3]), '123'], [Uint8Array.from([2, 3, 4]), '234']]),
+    type: 'map 2 pair (bytes keys Map w/ useMaps)',
+    useMaps: true
+  },
+  {
+    data: 'a1666f626a656374a16477697468a26134666e6573746564676f626a65637473a161216121',
+    expected: { object: { with: { 4: 'nested', objects: { '!': '!' } } } },
+    type: 'map nested'
+  },
+  { // same as previous but as a Map and an int key
+    data: 'a1666f626a656374a16477697468a204666e6573746564676f626a65637473a161216121',
+    expected: toMap([['object', toMap([['with', toMap([[4, 'nested'], ['objects', toMap([['!', '!']])]])]])]]),
+    type: 'map nested w/ useMaps',
+    useMaps: true
+  },
+  {
+    data: 'ae636f6e651b0016db6db6db6db763736978206374656e3b0016db6db6db6db76374776f1a0001000064666976650064666f757202646e696e653aa5f702b365656967687438ff65736576656e226574687265651901f466656c6576656e426131667477656c76656fc48c6175657320c39f76c49b74652168666f75727465656ea4616664666f7572616f016174026274680368746869727465656e840203046466697665',
+    encode: {
+      one: Number.MAX_SAFE_INTEGER / 1.4,
+      two: 65536,
+      three: 500,
+      four: 2,
+      five: 0,
+      six: -1,
+      seven: -3,
+      eight: -256,
+      nine: -2784428724,
+      ten: Number.MIN_SAFE_INTEGER / 1.4 - 1,
+      eleven: new TextEncoder().encode('a1'),
+      twelve: 'Čaues ßvěte!',
+      thirteen: [2, 3, 4, 'five'],
+      fourteen: { o: 1, t: 2, th: 3, f: 'four' }
+    },
+    expected: {
+      one: Number.MAX_SAFE_INTEGER / 1.4,
+      six: -1,
+      ten: Number.MIN_SAFE_INTEGER / 1.4 - 1,
+      two: 65536,
+      five: 0,
+      four: 2,
+      nine: -2784428724,
+      eight: -256,
+      seven: -3,
+      three: 500,
+      eleven: new TextEncoder().encode('a1'),
+      twelve: 'Čaues ßvěte!',
+      fourteen: { f: 'four', o: 1, t: 2, th: 3 },
+      thirteen: [2, 3, 4, 'five']
+    },
+    type: 'map with complex entries',
+    label: '{}'
+  },
+  {
+    data: 'ad01636f6e65026374776f1901f46c666976652068756e647265641902586b7369782068756e647265641a00010000636269671b0016db6db6db6db76662696767657220696d696e7573206f6e6521696d696e75732074776f38ff781f6d696e75732074776f2068756e6472656420616e64206669667479207369783901f4781a6d696e757820666976652068756e6472656420616e64206f6e653901f5781a6d696e757820666976652068756e6472656420616e642074776f3aa5f702b367626967206e65673b0016db6db6db6db76a626967676572206e6567',
+    encode: toMap([
+      [2, 'two'],
+      [1, 'one'],
+      [-2, 'minus two'],
+      [-1, 'minus one'],
+      [600, 'six hundred'],
+      [500, 'five hundred'],
+      [-256, 'minus two hundred and fifty six'],
+      [-502, 'minux five hundred and two'],
+      [-501, 'minux five hundred and one'],
+      [65536, 'big'],
+      [-2784428724, 'big neg'],
+      [6433713753386423, 'bigger'],
+      [-6433713753386424, 'bigger neg']
+    ]),
+    expected: toMap([
+      [1, 'one'],
+      [2, 'two'],
+      [500, 'five hundred'],
+      [600, 'six hundred'],
+      [65536, 'big'],
+      [6433713753386423, 'bigger'],
+      [-1, 'minus one'],
+      [-2, 'minus two'],
+      [-256, 'minus two hundred and fifty six'],
+      [-501, 'minux five hundred and one'],
+      [-502, 'minux five hundred and two'],
+      [-2784428724, 'big neg'],
+      [-6433713753386424, 'bigger neg']
+    ]),
+    type: 'map with ints and negints',
+    useMaps: true
+  },
+  {
+    data: 'a44104636f6e65430102026374776f430102036574687265654301020464666f7572',
+    encode: toMap([
+      [Uint8Array.from([1, 2, 3]), 'three'],
+      [Uint8Array.from([4]), 'one'],
+      [Uint8Array.from([1, 2, 4]), 'four'],
+      [Uint8Array.from([1, 2, 2]), 'two']
+    ]),
+    expected: toMap([
+      [Uint8Array.from([4]), 'one'],
+      [Uint8Array.from([1, 2, 2]), 'two'],
+      [Uint8Array.from([1, 2, 3]), 'three'],
+      [Uint8Array.from([1, 2, 4]), 'four']
+    ]),
+    type: 'map with bytes keys',
+    useMaps: true
+  },
+  // testing lengths encoded as too-large ints
+  { data: 'b801616101', expected: { a: 1 }, type: 'map 1 pair, length8', strict: false },
+  { data: 'b90001616101', expected: { a: 1 }, type: 'map 1 pair, length16', strict: false },
+  { data: 'ba00000001616101', expected: { a: 1 }, type: 'map 1 pair, length32', strict: false },
+  { data: 'bb0000000000000001616101', expected: { a: 1 }, type: 'map 1 pair, length64', strict: false }
+]
+
+function toMap (arr) {
+  const m = new Map()
+  for (const [key, value] of arr) {
+    m.set(key, value)
+  }
+  return m
+}
+
+function entries (map) {
+  function nest (a) {
+    for (const e of a) {
+      e[0] = entries(e[0])
+      e[1] = entries(e[1])
+    }
+    return a
+  }
+
+  if (Object.getPrototypeOf(map) === Map.prototype) {
+    return nest([...map.entries()])
+  }
+  if (typeof map === 'object') {
+    return nest([...Object.entries(map)])
+  }
+  return map
+}
+
+describe('map', () => {
+  describe('decode', () => {
+    for (const fixture of fixtures) {
+      const data = fromHex(fixture.data)
+      it(`should decode ${fixture.type}=${fixture.label || JSON.stringify(fixture.expected)}`, () => {
+        let options = fixture.useMaps ? { useMaps: true } : undefined
+        const decoded = decode(data, options)
+
+        if (fixture.useMaps) {
+          assert.strictEqual(Object.getPrototypeOf(decoded), Map.prototype, 'is Map')
+        } else {
+          assert.isObject(decoded, 'is object')
+        }
+
+        assert.deepStrictEqual(entries(decoded), entries(fixture.expected), `decode ${fixture.type}`)
+
+        options = Object.assign({ strict: true }, options)
+        if (fixture.strict === false) {
+          assert.throws(() => decode(data, options), Error, 'CBOR decode error: integer encoded in more bytes than necessary (strict decode)')
+        } else {
+          assert.deepStrictEqual(
+            entries(decode(data, options)),
+            entries(fixture.expected),
+            `decode ${fixture.type}`)
+        }
+      })
+
+      it('should fail to decode very large length', () => {
+        assert.throws(
+          () => decode(fromHex('bba5f702b3a5f70201616101')),
+          /CBOR decode error: 64-bit integer map lengths not supported/)
+      })
+    }
+
+    it('errors', () => {
+      assert.throws(() => decode(fromHex('a1016161')), /non-string keys not supported \(got number\)/)
+    })
+  })
+
+  describe('encode', () => {
+    for (const fixture of fixtures) {
+      it(`should encode ${fixture.type}=${fixture.label || JSON.stringify(fixture.expected)}`, () => {
+        const toEncode = fixture.encode || fixture.expected
+        if (fixture.unsafe) {
+          assert.throws(encode.bind(null, toEncode), Error, /^CBOR encode error: number too large to encode \(\d+\)$/)
+        } else if (fixture.strict === false || fixture.roundtrip === false) {
+          assert.notDeepEqual(toHex(encode(toEncode)), fixture.data, `encode ${fixture.type} !strict`)
+        } else {
+          assert.strictEqual(toHex(encode(toEncode)), fixture.data, `encode ${fixture.type}`)
+        }
+      })
+    }
+  })
+
+  // mostly unnecessary, but feels good
+  describe('roundtrip', () => {
+    for (const fixture of fixtures) {
+      if (!fixture.unsafe && fixture.strict !== false && fixture.roundtrip !== false) {
+        it(`should roundtrip ${fixture.type}=${fixture.label || JSON.stringify(fixture.expected)}`, () => {
+          const toEncode = fixture.encode || fixture.expected
+          const options = fixture.useMaps ? { useMaps: true } : undefined
+          const rt = decode(encode(toEncode), options)
+
+          if (fixture.useMaps) {
+            assert.strictEqual(Object.getPrototypeOf(rt), Map.prototype, 'is Map')
+          } else {
+            assert.isObject(rt, 'is object')
+          }
+
+          assert.deepStrictEqual(entries(rt), entries(fixture.expected), `roundtrip ${fixture.type}`)
+        })
+      }
+    }
+  })
+
+  describe('specials', () => {
+    it('can decode indefinite length items', () => {
+      assert.deepStrictEqual(decode(fromHex('bf616f01617402ff')), { o: 1, t: 2 })
+    })
+
+    it('can switch off indefinite length support', () => {
+      assert.throws(() => decode(fromHex('bf616f01617402ff'), { allowIndefinite: false }), /indefinite/)
+    })
+  })
+
+  describe('sorting', () => {
+    it('sorts int map keys', () => {
+      assert.strictEqual(toHex(encode(new Map([[1, 1], [2, 2]]))), 'a201010202')
+      assert.strictEqual(toHex(encode(new Map([[2, 1], [1, 2]]))), 'a201020201')
+    })
+
+    it('sorts negint map keys', () => {
+      assert.strictEqual(toHex(encode(new Map([[-1, 1], [-2, 2]]))), 'a220012102')
+      assert.strictEqual(toHex(encode(new Map([[-2, 1], [-1, 2]]))), 'a220022101')
+    })
+
+    it('sorts bytes map keys', () => {
+      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([1, 2]), 1], [Uint8Array.from([2, 1]), 2]]))), 'a24201020142020102')
+      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([2, 1]), 1], [Uint8Array.from([1, 2]), 2]]))), 'a24201020242020101')
+      // shortest first
+      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([1, 2]), 1], [Uint8Array.from([2, 1]), 2], [Uint8Array.from([200]), 3]]))), 'a341c8034201020142020102')
+    })
+
+    it('sorts bytes map keys', () => {
+      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([1, 2]), 1], [Uint8Array.from([2, 1]), 2]]))), 'a24201020142020102')
+      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([2, 1]), 1], [Uint8Array.from([1, 2]), 2]]))), 'a24201020242020101')
+      // shortest first
+      assert.strictEqual(toHex(encode(new Map([[Uint8Array.from([1, 2]), 1], [Uint8Array.from([2, 1]), 2], [Uint8Array.from([200]), 3]]))), 'a341c8034201020142020102')
+    })
+
+    it('sorts array map keys (length only)', () => {
+      assert.strictEqual(toHex(encode(new Map([[[1], 1], [[1, 1], 2]]))), 'a281010182010102')
+      assert.strictEqual(toHex(encode(new Map([[[1, 1], 1], [[1], 2]]))), 'a281010282010101')
+    })
+
+    it('sorts map map keys (length only)', () => {
+      assert.strictEqual(toHex(encode(new Map([[{ a: 1 }, 1], [{ a: 1, b: 1 }, 2]]))), 'a2a161610101a261610161620102')
+      assert.strictEqual(toHex(encode(new Map([[{ a: 1, b: 1 }, 1], [{ a: 1 }, 2]]))), 'a2a161610102a261610161620101')
+    })
+
+    // TODO: tag keys .. but why would you do this!?
+  })
+})

package/src/cborg/cborg/test/test-6tag.js

@@ -0,0 +1,85 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+
+import { Token, Type } from '../lib/token.js'
+import { decode, encode } from '../cborg.js'
+import { fromHex, toHex } from '../lib/byte-utils.js'
+import { dateDecoder, dateEncoder } from './common.js'
+
+const { assert } = chai
+
+function Uint16ArrayDecoder (obj) {
+  if (typeof obj !== 'string') {
+    throw new Error('expected string for tag 23')
+  }
+  const u8a = fromHex(obj)
+  return new Uint16Array(u8a.buffer, u8a.byteOffset, u8a.length / 2)
+}
+
+function Uint16ArrayEncoder (obj) {
+  if (!(obj instanceof Uint16Array)) {
+    throw new Error('expected Uint16Array for "Uint16Array" encoder')
+  }
+  return [
+    new Token(Type.tag, 23),
+    new Token(Type.string, toHex(obj))
+  ]
+}
+
+describe('tag', () => {
+  it('date', () => {
+    assert.throws(() => encode({ d: new Date() }), /unsupported type: Date/)
+
+    assert.equal(
+      toHex(encode(new Date('2013-03-21T20:04:00Z'), { typeEncoders: { Date: dateEncoder } })),
+      'c074323031332d30332d32315432303a30343a30305a' // from appendix_a
+    )
+
+    const decodedDate = decode(fromHex('c074323031332d30332d32315432303a30343a30305a'), { tags: { 0: dateDecoder } })
+    assert.instanceOf(decodedDate, Date)
+    assert.equal(decodedDate.toISOString(), new Date('2013-03-21T20:04:00Z').toISOString())
+  })
+
+  it('Uint16Array as hex/23 (overide existing type)', () => {
+    assert.equal(
+      toHex(encode(Uint16Array.from([1, 2, 3]), { typeEncoders: { Uint16Array: Uint16ArrayEncoder } })),
+      'd76c303130303032303030333030' // tag(23) + string('010002000300')
+    )
+
+    const decoded = decode(fromHex('d76c303130303032303030333030'), { tags: { 23: Uint16ArrayDecoder } })
+    assert.instanceOf(decoded, Uint16Array)
+    assert.equal(toHex(decoded), toHex(Uint16Array.from([1, 2, 3])))
+  })
+
+  it('tag int too large', () => {
+    const verify = (hex, strict) => {
+      if (!strict) {
+        assert.throws(
+          () => decode(fromHex(hex), { tags: { 8: dateDecoder }, strict: true }),
+          /integer encoded in more bytes than necessary/)
+      }
+      const decodedDate = decode(fromHex(hex), { tags: { 8: dateDecoder }, strict })
+      assert.instanceOf(decodedDate, Date)
+      assert.equal(decodedDate.toISOString(), new Date('2013-03-21T20:04:00Z').toISOString())
+    }
+    // compact
+    verify('c874323031332d30332d32315432303a30343a30305a', true)
+    // int8
+    verify('d80874323031332d30332d32315432303a30343a30305a', false)
+    // int16
+    verify('d9000874323031332d30332d32315432303a30343a30305a', false)
+    // int32
+    verify('da0000000874323031332d30332d32315432303a30343a30305a', false)
+    // int64
+    verify('db000000000000000874323031332d30332d32315432303a30343a30305a', false)
+  })
+
+  /*
+  describe('taglib', () => {
+    it('bigint', () => {
+      const v = BigInt(2) ** BigInt(80)
+    })
+  })
+  */
+})

package/src/cborg/cborg/test/test-7float.js

@@ -0,0 +1,131 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+
+import { decode, encode } from '../cborg.js'
+import { fromHex, toHex } from '../lib/byte-utils.js'
+
+const { assert } = chai
+
+const fixtures = [
+  { data: '8601f5f4f6f720', expected: [1, true, false, null, undefined, -1], type: 'array of float specials' },
+  { data: 'f93800', expected: 0.5, type: 'float16' },
+  { data: 'f9b800', expected: -0.5, type: 'float16' },
+  { data: 'fa33c00000', expected: 8.940696716308594e-08, type: 'float32' },
+  { data: 'fab3c00000', expected: -8.940696716308594e-08, type: 'float32' },
+  { data: 'fb3ff199999999999a', expected: 1.1, type: 'float64' },
+  { data: 'fbbff199999999999a', expected: -1.1, type: 'float64' },
+  { data: 'fb3ff1c71c71c71c72', expected: 1.11111111111111111111111111111, type: 'float64' }, // eslint-disable-line
+  { data: 'fb0000000000000002', expected: 1e-323, type: 'float64' },
+  { data: 'fb8000000000000002', expected: -1e-323, type: 'float64' },
+  { data: 'fb3fefffffffffffff', expected: 0.9999999999999999, type: 'float64' },
+  { data: 'fbbfefffffffffffff', expected: -0.9999999999999999, type: 'float64' },
+  { data: 'f97c00', expected: Infinity, type: 'Infinity' }, // special CBOR token for -Infinity
+  { data: 'fb7ff0000000000000', expected: Infinity, type: 'Infinity', strict: false }, // an IEEE 754 representation of Infinity
+  { data: 'f9fc00', expected: -Infinity, type: '-Infinity' }, // special CBOR token for -Infinity
+  { data: 'fbfff0000000000000', expected: -Infinity, type: '-Infinity', strict: false }, // an IEEE 754 representation of Infinity
+  { data: 'f97e00', expected: NaN, type: 'NaN' }, // special CBOR token for NaN
+  { data: 'f97ff8', expected: NaN, type: 'NaN', strict: false }, // one of the many IEEE 754 representations of NaN
+  { data: 'fa7ff80000', expected: NaN, type: 'NaN', strict: false },
+  { data: 'fb7ff8000000000000', expected: NaN, type: 'NaN', strict: false },
+  { data: 'fb7ff8cafedeadbeef', expected: NaN, type: 'NaN', strict: false }, // yep, that's NaN too
+  { data: 'fb40f4241a31a5a515', expected: 82497.63712086187, type: 'float64' }
+]
+
+describe('float', () => {
+  describe('decode', () => {
+    for (const fixture of fixtures) {
+      const data = fromHex(fixture.data)
+      it(`should decode ${fixture.type}=${fixture.expected}`, () => {
+        assert.deepStrictEqual(decode(data), fixture.expected, `decode ${fixture.type}`)
+        assert.deepStrictEqual(decode(data, { strict: true }), fixture.expected, `decode ${fixture.type}`)
+      })
+    }
+  })
+
+  it('error', () => {
+    // minor number 28, too high for uint
+    assert.throws(() => decode(fromHex('f80000')), Error, 'simple values are not supported')
+    assert.throws(() => decode(fromHex('f900')), Error, 'not enough data for float16')
+    assert.throws(() => decode(fromHex('fa0000')), Error, 'not enough data for float32')
+    assert.throws(() => decode(fromHex('fb00000000')), Error, 'not enough data for float64')
+  })
+
+  describe('encode', () => {
+    for (const fixture of fixtures) {
+      if (fixture.strict !== false) {
+        it(`should encode ${fixture.type}=${fixture.expected}`, () => {
+          assert.strictEqual(toHex(encode(fixture.expected)), fixture.data, `encode ${fixture.type}`)
+        })
+      }
+    }
+  })
+
+  describe('encode float64', () => {
+    for (const fixture of fixtures) {
+      if (fixture.type.startsWith('float')) {
+        it(`should encode ${fixture.type}=${fixture.expected}`, () => {
+          const encoded = encode(fixture.expected, { float64: true })
+          assert.strictEqual(encoded.length, 9) // always encode as 9 bytes, regardless of size
+          assert.strictEqual(encoded[0], 0xfb)
+          assert.strictEqual(decode(encoded), fixture.expected, `encode float64 ${fixture.type}`)
+        })
+      }
+    }
+  })
+
+  describe('roundtrip', () => {
+    for (const fixture of fixtures) {
+      if (!fixture.unsafe && fixture.strict !== false) {
+        it(`should roundtrip ${fixture.type}=${fixture.expected}`, () => {
+          assert.deepStrictEqual(decode(encode(fixture.expected)), fixture.expected, `roundtrip ${fixture.type}`)
+        })
+      }
+    }
+  })
+
+  describe('specials', () => {
+    // This is a bit of a hack, the CBOR is invalid because it's a standard fixed-length array
+    // followed by a BREAK, which should normally error ("too many terminals"), but we want to
+    // exercise the allowIndefinite switch in the major-7 decode and it should error before it
+    // even gets to looking at terminals and whether the tokens make sense.
+    it('indefinite length switch fails on BREAK', () => {
+      // sanity check, BREAK doesn't belong there
+      assert.throws(() => decode(Uint8Array.from([131, 1, 2, 0xff])), /unexpected break to lengthed array/)
+      // throw earlier because we're disallowing BREAK entirely
+      assert.throws(() => decode(Uint8Array.from([131, 1, 2, 0xff]), { 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, 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])
+      assert.throws(() => decode(fromHex('830102f97c00'), { allowInfinity: false }), /Infinity/)
+      assert.throws(() => decode(fromHex('830102f9fc00'), { allowInfinity: false }), /Infinity/)
+      for (const fixture of fixtures.filter((f) => f.type.endsWith('Infinity'))) {
+        assert.throws(() => decode(fromHex(fixture.data), { allowInfinity: false }), /Infinity/)
+      }
+    })
+
+    it('can switch off NaN support', () => {
+      assert.deepStrictEqual(decode(fromHex('830102f97e00')), [1, 2, NaN])
+      assert.throws(() => decode(fromHex('830102f97e00'), { allowNaN: false }), /NaN/)
+      for (const fixture of fixtures.filter((f) => f.type === 'NaN')) {
+        assert.throws(() => decode(fromHex(fixture.data), { allowNaN: false }), /NaN/)
+      }
+    })
+  })
+})

package/src/cborg/cborg/test/test-bl.js

@@ -0,0 +1,37 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+import { Bl } from '../lib/bl.js'
+
+const { assert } = chai
+
+describe('Internal bytes list', () => {
+  describe('push', () => {
+    it('push bits', () => {
+      const bl = new Bl(10)
+      const expected = []
+      for (let i = 0; i < 25; i++) {
+        bl.push([i + 1])
+        expected.push(i + 1)
+      }
+      assert.deepEqual([...bl.toBytes()], expected)
+    })
+
+    for (let i = 4; i < 21; i++) {
+      it(`push Bl(${i})`, () => {
+        const bl = new Bl(i)
+        const expected = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 110, 120, 11, 12, 130, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]
+        for (let i = 0; i < 5; i++) {
+          bl.push([i + 1])
+        }
+        bl.push(Uint8Array.from([6, 7, 8, 9, 10]))
+        bl.push([100])
+        bl.push(Uint8Array.from([110, 120]))
+        bl.push(Uint8Array.from([11, 12]))
+        bl.push([130])
+        bl.push(Uint8Array.from([13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]))
+        assert.deepEqual([...bl.toBytes()], expected)
+      })
+    }
+  })
+})

package/src/cborg/cborg/test/test-cbor-vectors.js

@@ -0,0 +1,107 @@
+/* eslint-env mocha,es2020 */
+
+import * as chai from 'chai'
+
+import { decode, encode } from '../cborg.js'
+import * as taglib from "@fireproof/vendor/cborg/taglib"
+import { fromHex, toHex } from '../lib/byte-utils.js'
+// fixtures from https://github.com/cbor/test-vectors
+import { fixtures } from './appendix_a.js'
+
+const { assert } = chai
+
+const tags = []
+const typeEncoders = {}
+
+tags[0] = function (obj) {
+  if (typeof obj !== 'string') {
+    throw new Error('expected string for tag 1')
+  }
+  return `0("${new Date(obj).toISOString().replace(/\.000Z$/, 'Z')}")`;
+}
+
+tags[1] = function (obj) {
+  if (typeof obj !== 'number') {
+    throw new Error('expected number for tag 1')
+  }
+  return `1(${obj})`
+}
+
+tags[2] = taglib.bigIntDecoder
+typeEncoders.bigint = taglib.bigIntEncoder
+tags[3] = taglib.bigNegIntDecoder
+
+tags[23] = function (obj) {
+// expected conversion to base16
+  if (!(obj instanceof Uint8Array)) {
+    throw new Error('expected byte array for tag 23')
+  }
+  return `23(h'${toHex(obj)}')`
+}
+
+tags[24] = function (obj) { // embedded cbor, oh my
+  return tags[23](obj).replace(/^23/, '24');
+}
+
+tags[32] = function (obj) { // url
+  if (typeof obj !== 'string') {
+    throw new Error('expected string for tag 32')
+  }
+  ;(() => new URL(obj))() // will throw if not a url
+  return `32("${obj}")`
+}
+
+describe('cbor/test-vectors', () => {
+  let i = 0
+  for (const fixture of fixtures) {
+    const u8a = fromHex(fixture.hex)
+    let expected = fixture.decoded !== undefined ? fixture.decoded : fixture.diagnostic
+
+    if (typeof expected === 'string' && expected.startsWith('h\'')) {
+      expected = fromHex(expected.replace(/(^h)'|('$)/g, ''))
+    }
+
+    it(`test vector #${i}: ${inspect(expected).replace(/\n\s*/g, '')}`, () => {
+      if (fixture.error) {
+        assert.throws(() => decode(u8a, { tags }), fixture.error)
+      } else {
+        if (fixture.noTagDecodeError) {
+          assert.throws(() => decode(u8a), fixture.noTagDecodeError)
+        }
+        let actual = decode(u8a, { tags })
+        if (typeof actual === 'bigint') {
+          actual = inspect(actual)
+        }
+        if (typeof expected === 'bigint') {
+          expected = inspect(expected)
+        }
+        assert.deepEqual(actual, expected)
+
+        if (fixture.roundtrip) {
+          if (fixture.noTagEncodeError) {
+            assert.throws(() => encode(decode(u8a, { tags })), fixture.noTagEncodeError)
+          }
+          const reencoded = encode(decode(u8a, { tags }), { typeEncoders })
+          assert.equal(toHex(reencoded), fixture.hex)
+        }
+      }
+    })
+    i++
+  }
+
+  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)
+}