@fireproof/vendor 0.0.0-smoke → 1.0.1

package/patched/cborg/taglib.js

@@ -1,73 +0,0 @@
-import { Token, Type } from './cborg.js'
-
-/*
-A collection of some standard CBOR tags.
-
-There are no tags included by default in the cborg encoder or decoder, you have
-to include them by passing options. `typeEncoders` for encode() and `tags` for
-decode().
-
-The encoders here can be included with these options (see the tests for how this
-can be done), or as examples for writing additional tags. Additional standard
-(and reasonable) tags may be added here by pull request.
-*/
-
-/* TAG(2) Bignums https://tools.ietf.org/html/rfc8949#section-3.4.3 */
-const neg1b = BigInt(-1)
-const pos1b = BigInt(1)
-const zerob = BigInt(0)
-// const twob = BigInt(2)
-const eightb = BigInt(8)
-
-/**
- * @param {Uint8Array} bytes
- * @returns {bigint}
- */
-export function bigIntDecoder (bytes) {
-  // TODO: assert that `bytes` is a `Uint8Array`
-  let bi = zerob
-  for (let ii = 0; ii < bytes.length; ii++) {
-    bi = (bi << eightb) + BigInt(bytes[ii])
-  }
-  return bi
-}
-
-/**
- * @param {bigint} bi
- * @returns {Uint8Array}
- */
-function fromBigInt (bi) {
-  const buf = []
-  while (bi > 0) {
-    buf.unshift(Number(bi) & 0xff)
-    bi >>= eightb
-  }
-  return Uint8Array.from(buf)
-}
-
-// assuming that we're receiving a BigInt here, it should be registered for
-// type 'bigint' for this to work.
-const maxSafeBigInt = BigInt('18446744073709551615') // (twob ** BigInt(64)) - pos1b
-const minSafeBigInt = BigInt('-18446744073709551616') // neg1b * (twob ** BigInt(64))
-/**
- * @param {bigint} obj
- * @returns {Token[]|null}
- */
-export function bigIntEncoder (obj) {
-  if (obj >= minSafeBigInt && obj <= maxSafeBigInt) {
-    return null // null = do it the standard way
-  }
-  return [
-    new Token(Type.tag, obj >= zerob ? 2 : 3),
-    new Token(Type.bytes, fromBigInt(obj >= zerob ? obj : obj * neg1b - pos1b))
-  ]
-}
-
-/**
- * TAG(3) Negative Bignums https://tools.ietf.org/html/rfc8949#section-3.4.3
- * @param {Uint8Array} bytes
- * @returns {bigint}
- */
-export function bigNegIntDecoder (bytes) {
-  return neg1b - bigIntDecoder(bytes)
-}

package/patched/cborg/test/common.js

@@ -1,18 +0,0 @@
-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/patched/cborg/test/test-1negint.js

@@ -1,96 +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
-
-// some from https://github.com/PJK/libcbor
-
-const fixtures = [
-  { data: '20', expected: -1, type: 'negint8' },
-  { data: '22', expected: -3, type: 'negint8' },
-  { data: '3863', expected: -100, type: 'negint8' },
-  { data: '38ff', expected: -256, type: 'negint8' },
-  { data: '3900ff', expected: -256, type: 'negint16', strict: false },
-  { data: '3901f4', expected: -501, type: 'negint16' },
-  { data: '3a000000ff', expected: -256, type: 'negint32', strict: false },
-  { data: '3aa5f702b3', expected: -2784428724, type: 'negint32' },
-  { data: '3b00000000000000ff', expected: -256, type: 'negint32', strict: false },
-  { data: '3b0016db6db6db6db7', expected: Number.MIN_SAFE_INTEGER / 1.4 - 1, type: 'negint64' },
-  { data: '3b001ffffffffffffe', expected: Number.MIN_SAFE_INTEGER, type: 'negint64' },
-  // kind of hard to assert on these (TODO: improve bignum handling)
-  { data: '3b001fffffffffffff', expected: BigInt('-9007199254740992') /* Number.MIN_SAFE_INTEGER - 1 */, type: 'negint64' },
-  { data: '3b0020000000000000', expected: BigInt('-9007199254740993') /* Number.MIN_SAFE_INTEGER - 2 */, type: 'negint64' },
-  { data: '3ba5f702b3a5f702b3', expected: BigInt('-11959030306112471732'), type: 'negint64' },
-  { data: '3bffffffffffffffff', expected: BigInt('-18446744073709551616'), type: 'negint64' }
-]
-
-describe('negint', () => {
-  describe('decode', () => {
-    for (const fixture of fixtures) {
-      const data = fromHex(fixture.data)
-      it(`should decode ${fixture.type}=${fixture.expected}`, () => {
-        assert.ok(decode(data) === fixture.expected, `decode ${fixture.type} (${decode(data)} != ${fixture.expected})`)
-        if (fixture.strict === false) {
-          assert.throws(() => decode(data, { strict: true }), Error, 'CBOR decode error: integer encoded in more bytes than necessary (strict decode)')
-        } else {
-          assert.strictEqual(decode(data, { strict: true }), fixture.expected, `decode ${fixture.type}`)
-        }
-      })
-    }
-  })
-
-  describe('encode', () => {
-    for (const fixture of fixtures) {
-      it(`should encode ${fixture.type}=${fixture.expected}`, () => {
-        if (fixture.strict === false) {
-          assert.notStrictEqual(toHex(encode(fixture.expected)), fixture.data, `encode ${fixture.type} !strict`)
-        } else {
-          assert.strictEqual(toHex(encode(fixture.expected)), fixture.data, `encode ${fixture.type}`)
-        }
-      })
-    }
-  })
-
-  // mostly unnecessary, but feels good
-  describe('roundtrip', () => {
-    for (const fixture of fixtures) {
-      it(`should roundtrip ${fixture.type}=${fixture.expected}`, () => {
-        assert.ok(decode(encode(fixture.expected)) === fixture.expected, `roundtrip ${fixture.type}`)
-      })
-    }
-  })
-
-  describe('toobig', () => {
-    it('bigger than 64-bit', () => {
-      // boundary condition is right below 64-bit negint
-      assert.doesNotThrow(() => encode(BigInt('-18446744073709551616') /* BigInt(-1) * BigInt(2) ** BigInt(64) */))
-      assert.throws(() => encode(BigInt('-18446744073709551617') /* BigInt(-1) * BigInt(2) ** BigInt(64) - BigInt(1) */), /BigInt larger than allowable range/)
-    })
-
-    it('disallow BigInt', () => {
-      for (const fixture of fixtures) {
-        const data = fromHex(fixture.data)
-        if (!Number.isSafeInteger(fixture.expected)) {
-          assert.throws(() => decode(data, { allowBigInt: false }), /safe integer range/)
-        } else {
-          assert.ok(decode(data, { allowBigInt: false }) === fixture.expected, `decode ${fixture.type}`)
-        }
-      }
-    })
-  })
-
-  describe('toosmall', () => {
-    for (const fixture of fixtures) {
-      if (fixture.strict !== false && typeof fixture.expected === 'number') {
-        const small = BigInt(fixture.expected)
-        it(`should encode ${small}n`, () => {
-          assert.strictEqual(toHex(encode(BigInt(small))), fixture.data, `encode ${small}`)
-        })
-      }
-    }
-  })
-})

package/patched/cborg/test/test-2bytes.js

@@ -1,198 +0,0 @@
-/* eslint-env mocha */
-
-import * as chai from 'chai'
-
-import { decode, encode } from '../cborg.js'
-import { useBuffer, fromHex, toHex } from '../lib/byte-utils.js'
-
-const { assert } = chai
-
-// some from https://github.com/PJK/libcbor
-
-const fixtures = [
-  { data: '40', expected: '', type: 'bytes' },
-  { data: '41a1', expected: 'a1', type: 'bytes' },
-  { data: '5801a1', expected: 'a1', type: 'bytes', strict: false },
-  {
-    data: '58ff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
-    expected: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
-    type: 'bytes',
-    label: 'long bytes, 8-bit length'
-  },
-  {
-    data: '5900ff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
-    expected: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
-    type: 'bytes',
-    label: 'long bytes, 16-bit length',
-    strict: false
-  },
-  {
-    data: '5a000000ff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
-    expected: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
-    type: 'bytes',
-    label: 'long bytes, 32-bit length',
-    strict: false
-  },
-  {
-    data: '5b00000000000000ff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
-    expected: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe',
-    type: 'bytes',
-    label: 'long bytes, 64-bit length',
-    strict: false
-  }
-]
-
-// fill up byte arrays we can validate in strict mode, the minimal size for each
-// excluding 64-bit because 4G is just too big
-;(() => {
-  function rnd (length) {
-    return new Uint8Array(Array.from({ length }, () => Math.floor(Math.random() * 255)))
-  }
-
-  const expected16 = rnd(256)
-  fixtures.push({
-    data: new Uint8Array([...fromHex('590100'), ...expected16]),
-    expected: expected16,
-    type: 'bytes',
-    label: 'long bytes, 16-bit length strict-compat'
-  })
-
-  const expected32 = rnd(65536)
-  fixtures.push({
-    data: new Uint8Array([...fromHex('5a00010000'), ...expected32]),
-    expected: expected32,
-    type: 'bytes',
-    label: 'long bytes, 32-bit length strict-compat'
-  })
-})()
-
-describe('bytes', () => {
-  describe('decode', () => {
-    for (const fixture of fixtures) {
-      const data = fromHex(fixture.data)
-      it(`should decode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
-        let actual = decode(data)
-        assert.strictEqual(
-          toHex(actual),
-          toHex(fromHex(fixture.expected)),
-          `decode ${fixture.type}`)
-
-        if (fixture.strict === false) {
-          assert.throws(() => decode(data, { strict: true }), Error, 'CBOR decode error: integer encoded in more bytes than necessary (strict decode)')
-        } else {
-          actual = decode(data, { strict: true })
-          assert.strictEqual(
-            toHex(actual),
-            toHex(fromHex(fixture.expected)),
-            `decode ${fixture.type} strict`)
-        }
-      })
-
-      it('should fail to decode very large length', () => {
-        assert.throws(
-          () => decode(fromHex('5ba5f702b3a5f702b3000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfe')),
-          /CBOR decode error: 64-bit integer bytes lengths not supported/)
-      })
-    }
-  })
-
-  describe('encode', () => {
-    for (const fixture of fixtures) {
-      if (fixture.data.length >= 100000000) {
-        it.skip(`(TODO) skipping encode of very large bytes ${fixture.type}=${fixture.label || fixture.expected}`, () => {})
-        continue
-      }
-
-      const data = fromHex(fixture.expected)
-      const expectedHex = toHex(fixture.data)
-
-      it(`should encode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
-        if (fixture.unsafe) {
-          assert.throws(() => encode(data), Error, /^CBOR encode error: number too large to encode \(-\d+\)$/)
-        } else if (fixture.strict === false) {
-          assert.notStrictEqual(toHex(encode(data)), expectedHex, `encode ${fixture.type} !strict`)
-        } else {
-          assert.strictEqual(toHex(encode(data)), expectedHex, `encode ${fixture.type}`)
-        }
-      })
-    }
-  })
-
-  describe('typedarrays', () => {
-    const cases = [
-      {
-        obj: Uint8Array.from([1, 2, 3]),
-        hex: '43010203'
-      },
-      {
-        obj: Uint8ClampedArray.from([1, 2, 3]),
-        hex: '43010203'
-      },
-      {
-        obj: Uint16Array.from([1, 2, 3]),
-        hex: '46010002000300'
-      },
-      {
-        obj: Uint32Array.from([1, 2, 3]),
-        hex: '4c010000000200000003000000'
-      },
-      {
-        obj: Int8Array.from([1, 2, -3]),
-        hex: '430102fd'
-      },
-      {
-        obj: Int16Array.from([1, 2, -3]),
-        hex: '4601000200fdff'
-      },
-      {
-        obj: Int32Array.from([1, 2, -3]),
-        hex: '4c0100000002000000fdffffff'
-      },
-      {
-        obj: Float32Array.from([1, 2, -3]),
-        hex: '4c0000803f00000040000040c0'
-      },
-      {
-        obj: Float64Array.from([1, 2, -3]),
-        hex: '5818000000000000f03f000000000000004000000000000008c0'
-      },
-      {
-        obj: BigUint64Array.from([BigInt(1), BigInt(2), BigInt(3)]),
-        hex: '5818010000000000000002000000000000000300000000000000'
-      },
-      {
-        obj: BigInt64Array.from([BigInt(1), BigInt(2), BigInt(-3)]),
-        hex: '581801000000000000000200000000000000fdffffffffffffff'
-      },
-      {
-        obj: new DataView(Uint8Array.from([1, 2, 3]).buffer),
-        hex: '43010203'
-      },
-      {
-        obj: Uint8Array.from([1, 2, 3]).buffer,
-        hex: '43010203'
-      }
-    ]
-
-    for (const testCase of cases) {
-      it(testCase.obj.constructor.name, () => {
-        assert.equal(toHex(encode(testCase.obj)), testCase.hex)
-        const decoded = decode(fromHex(testCase.hex))
-        assert.instanceOf(decoded, Uint8Array)
-        assert.equal(toHex(decoded), toHex(testCase.obj))
-      })
-    }
-  })
-
-  if (useBuffer) {
-    describe('buffer', () => {
-      it('can encode Node.js Buffers', () => {
-        const obj = global.Buffer.from([1, 2, 3])
-        assert.equal(toHex(encode(obj)), '43010203')
-        const decoded = decode(fromHex('43010203'))
-        assert.instanceOf(decoded, Uint8Array)
-        assert.equal(toHex(decoded), toHex(obj))
-      })
-    })
-  }
-})

package/patched/cborg/test/test-3string.js

@@ -1,136 +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
-
-// some from https://github.com/PJK/libcbor
-
-const fixtures = [
-  { data: '60', expected: '', type: 'string' },
-  { data: '6161', expected: 'a', type: 'string' },
-  { data: '780161', expected: 'a', type: 'string', strict: false },
-  {
-    data: '6c48656c6c6f20776f726c6421',
-    expected: 'Hello world!',
-    type: 'string'
-  },
-  {
-    data: '6fc48c6175657320c39f76c49b746521',
-    expected: 'Čaues ßvěte!',
-    type: 'string'
-  },
-  {
-    data: '78964c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e',
-    expected: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec mi tellus, iaculis nec vestibulum quis, fermentum non felis. Maecenas ut justo posuere.',
-    type: 'string',
-    label: 'long string, 8-bit length'
-  },
-  {
-    data: '7900964c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e',
-    expected: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec mi tellus, iaculis nec vestibulum quis, fermentum non felis. Maecenas ut justo posuere.',
-    type: 'string',
-    label: 'long string, 16-bit length',
-    strict: false
-  },
-  {
-    data: '7a000000964c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e',
-    expected: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec mi tellus, iaculis nec vestibulum quis, fermentum non felis. Maecenas ut justo posuere.',
-    type: 'string',
-    label: 'long string, 32-bit length',
-    strict: false
-  },
-  {
-    data: '7b00000000000000964c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e',
-    expected: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec mi tellus, iaculis nec vestibulum quis, fermentum non felis. Maecenas ut justo posuere.',
-    type: 'string',
-    label: 'long string, 64-bit length',
-    strict: false
-  }
-]
-
-// fill up byte arrays converted to strings so we can validate in strict mode,
-// the minimal size for each excluding 64-bit because 4G is just too big
-;(() => {
-  function rnd (length) {
-    const sa = []
-    let l = 0
-    while (l < length) {
-      // some unicode character, unless we're near the end and want to fill up exactly so
-      // we need to pad with ascii
-      const ascii = (length - l) < 3
-      const base = ascii ? 32 : 0x1f000
-      const max = ascii ? 126 : 0x1ff00
-      const cc = Math.floor(Math.random() * (max - base)) + base
-      const s = String.fromCharCode(cc)
-      l += (new TextEncoder().encode(s)).length
-      sa.push(s)
-    }
-    return sa.join('')
-  }
-
-  const expected16 = rnd(256)
-  fixtures.push({
-    data: new Uint8Array([...fromHex('790100'), ...(new TextEncoder().encode(expected16))]),
-    expected: expected16,
-    type: 'string',
-    label: 'long string, 16-bit length strict-compat'
-  })
-
-  const expected32 = rnd(65536)
-  fixtures.push({
-    data: new Uint8Array([...fromHex('7a00010000'), ...(new TextEncoder().encode(expected32))]),
-    expected: expected32,
-    type: 'string',
-    label: 'long string, 32-bit length strict-compat'
-  })
-})()
-
-describe('string', () => {
-  describe('decode', () => {
-    for (const fixture of fixtures) {
-      const data = fromHex(fixture.data)
-      it(`should decode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
-        let actual = decode(data)
-        assert.strictEqual(actual, fixture.expected, `decode ${fixture.type}`)
-        if (fixture.strict === false) {
-          assert.throws(() => decode(data, { strict: true }), Error, 'CBOR decode error: integer encoded in more bytes than necessary (strict decode)')
-        } else {
-          actual = decode(data, { strict: true })
-          assert.strictEqual(actual, fixture.expected, `decode ${fixture.type} strict`)
-        }
-      })
-
-      it('should fail to decode very large length', () => {
-        assert.throws(
-          () => decode(fromHex('7ba5f702b3a5f702b34c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e73656374657475722061646970697363696e6720656c69742e20446f6e6563206d692074656c6c75732c20696163756c6973206e656320766573746962756c756d20717569732c206665726d656e74756d206e6f6e2066656c69732e204d616563656e6173207574206a7573746f20706f73756572652e')),
-          /CBOR decode error: 64-bit integer string lengths not supported/)
-      })
-    }
-  })
-
-  describe('encode', () => {
-    for (const fixture of fixtures) {
-      if (fixture.data.length >= 100000000) {
-        it.skip(`(TODO) skipping encode of very large string ${fixture.type}=${fixture.label || fixture.expected}`, () => {})
-        continue
-      }
-
-      const data = fixture.expected
-      const expectedHex = toHex(fixture.data)
-
-      it(`should encode ${fixture.type}=${fixture.label || fixture.expected}`, () => {
-        if (fixture.unsafe) {
-          assert.throws(() => encode(data), Error, /^CBOR encode error: number too large to encode \(-\d+\)$/)
-        } else if (fixture.strict === false) {
-          assert.notStrictEqual(toHex(encode(data)), expectedHex, `encode ${fixture.type} !strict`)
-        } else {
-          assert.strictEqual(toHex(encode(data)), expectedHex, `encode ${fixture.type}`)
-        }
-      })
-    }
-  })
-})

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)
-    })
-  })
-  */
-})