@fireproof/vendor 0.0.0-smoke → 0.0.2-dev-test

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

@@ -1,284 +0,0 @@
-/* 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/patched/cborg/test/test-6tag.js

@@ -1,85 +0,0 @@
-/* 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/patched/cborg/test/test-7float.js

@@ -1,131 +0,0 @@
-/* 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/patched/cborg/test/test-bl.js

@@ -1,37 +0,0 @@
-/* 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/patched/cborg/test/test-cbor-vectors.js

@@ -1,107 +0,0 @@
-/* eslint-env mocha,es2020 */
-
-import * as chai from 'chai'
-
-import { decode, encode } from '../cborg.js'
-import * as taglib from '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)
-}