@fireproof/vendor 0.0.0-smoke → 1.0.1

package/src/cborg/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/src/cborg/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/src/cborg/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/src/cborg/cborg/test/test-fuzz.js

@@ -1,42 +0,0 @@
-/* eslint-env mocha */
-
-import { garbage } from 'ipld-garbage'
-import { decode, encode } from '../cborg.js'
-import * as chai from 'chai'
-
-const { assert } = chai
-
-describe('Fuzz round-trip', () => {
-  it('random objects', function () {
-    this.timeout(5000)
-    for (let i = 0; i < 1000; i++) {
-      const obj = garbage(300, { weights: { CID: 0 } })
-      const byts = encode(obj)
-      const decoded = decode(byts)
-      assert.deepEqual(decoded, obj)
-    }
-  })
-
-  it('circular references error', () => {
-    let obj = {}
-    obj.obj = obj
-    assert.throws(() => encode(obj), /circular references/)
-
-    obj = { blip: [1, 2, { blop: {} }] }
-    obj.blip[2].blop.boop = obj
-    assert.throws(() => encode(obj), /circular references/)
-
-    obj = { blip: [1, 2, { blop: {} }] }
-    obj.blip[2].blop.boop = obj.blip
-    assert.throws(() => encode(obj), /circular references/)
-
-    // not circular but a naive check might decide it is
-    obj = { blip: {}, bloop: {} }
-    obj.bloop = obj.blip
-    assert.doesNotThrow(() => encode(obj))
-
-    const arr = []
-    arr[0] = arr
-    assert.throws(() => encode(arr), /circular references/)
-  })
-})

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

@@ -1,65 +0,0 @@
-/* eslint-env mocha */
-
-import * as 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-08)
-    verifyLength(8.940696716308594e-08, { 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/src/cborg/cborg/types/cborg.d.ts

@@ -1,28 +0,0 @@
-export { encodeCustom } from "./lib/encode.js";
-/**
- * There was originally just `TypeEncoder` so don't break types by renaming or not exporting
- */
-export type TagDecoder = import("./interface").TagDecoder;
-/**
- * Export the types that were present in the original manual cborg.d.ts
- */
-export type TypeEncoder = import("./interface").OptionalTypeEncoder;
-/**
- * Export the types that were present in the original manual cborg.d.ts
- */
-export type DecodeOptions = import("./interface").DecodeOptions;
-/**
- * Export the types that were present in the original manual cborg.d.ts
- */
-export type EncodeOptions = import("./interface").EncodeOptions;
-import { decode } from './lib/decode.js';
-import { decodeFirst } from './lib/decode.js';
-import { Tokeniser } from './lib/decode.js';
-import { tokensToObject } from './lib/decode.js';
-import { encode } from './lib/encode.js';
-import { Token } from './lib/token.js';
-import { Type } from './lib/token.js';
-export { decode, decodeFirst, Tokeniser as Tokenizer, tokensToObject, encode, Token, Type };
-export { encodeErrPrefix, decodeErrPrefix } from "./lib/common.js";
-export { asU8A, fromString, decodeCodePointsArray } from "./lib/byte-utils.js";
-//# sourceMappingURL=cborg.d.ts.map

package/src/cborg/cborg/types/cborg.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cborg.d.ts","sourceRoot":"","sources":["../cborg.js"],"names":[],"mappings":";;;;yBAWa,OAAO,aAAa,EAAE,UAAU;;;;0BAEhC,OAAO,aAAa,EAAE,mBAAmB;;;;4BACzC,OAAO,aAAa,EAAE,aAAa;;;;4BACnC,OAAO,aAAa,EAAE,aAAa;uBAde,iBAAiB;4BAAjB,iBAAiB;0BAAjB,iBAAiB;+BAAjB,iBAAiB;uBADzD,iBAAiB;sBAEZ,gBAAgB;qBAAhB,gBAAgB"}

package/src/cborg/cborg/types/example.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=example.d.ts.map

package/src/cborg/cborg/types/example.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"example.d.ts","sourceRoot":"","sources":["../example.js"],"names":[],"mappings":""}

package/src/cborg/cborg/types/interface.d.ts.map

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