cborg 2.0.5 → 3.0.0

package/esm/node-test/test-6tag.js

@@ -1,78 +0,0 @@
-import 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');
-    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');
-    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());
-    };
-    verify('c874323031332d30332d32315432303a30343a30305a', true);
-    verify('d80874323031332d30332d32315432303a30343a30305a', false);
-    verify('d9000874323031332d30332d32315432303a30343a30305a', false);
-    verify('da0000000874323031332d30332d32315432303a30343a30305a', false);
-    verify('db000000000000000874323031332d30332d32315432303a30343a30305a', false);
-  });
-});

package/esm/node-test/test-7float.js

@@ -1,250 +0,0 @@
-import 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-8,
-    type: 'float32'
-  },
-  {
-    data: 'fab3c00000',
-    expected: -8.940696716308594e-8,
-    type: 'float32'
-  },
-  {
-    data: 'fb3ff199999999999a',
-    expected: 1.1,
-    type: 'float64'
-  },
-  {
-    data: 'fbbff199999999999a',
-    expected: -1.1,
-    type: 'float64'
-  },
-  {
-    data: 'fb3ff1c71c71c71c72',
-    expected: 1.1111111111111112,
-    type: 'float64'
-  },
-  {
-    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'
-  },
-  {
-    data: 'fb7ff0000000000000',
-    expected: Infinity,
-    type: 'Infinity',
-    strict: false
-  },
-  {
-    data: 'f9fc00',
-    expected: -Infinity,
-    type: '-Infinity'
-  },
-  {
-    data: 'fbfff0000000000000',
-    expected: -Infinity,
-    type: '-Infinity',
-    strict: false
-  },
-  {
-    data: 'f97e00',
-    expected: NaN,
-    type: 'NaN'
-  },
-  {
-    data: 'f97ff8',
-    expected: NaN,
-    type: 'NaN',
-    strict: false
-  },
-  {
-    data: 'fa7ff80000',
-    expected: NaN,
-    type: 'NaN',
-    strict: false
-  },
-  {
-    data: 'fb7ff8000000000000',
-    expected: NaN,
-    type: 'NaN',
-    strict: false
-  },
-  {
-    data: 'fb7ff8cafedeadbeef',
-    expected: NaN,
-    type: 'NaN',
-    strict: false
-  },
-  {
-    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', () => {
-    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);
-          assert.strictEqual(encoded[0], 251);
-          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', () => {
-    it('indefinite length switch fails on BREAK', () => {
-      assert.throws(() => decode(Uint8Array.from([
-        131,
-        1,
-        2,
-        255
-      ])), /unexpected break to lengthed array/);
-      assert.throws(() => decode(Uint8Array.from([
-        131,
-        1,
-        2,
-        255
-      ]), { 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/esm/node-test/test-bl.js

@@ -1,84 +0,0 @@
-import 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/esm/node-test/test-cbor-vectors.js

@@ -1,95 +0,0 @@
-import chai from 'chai';
-import {
-  decode,
-  encode
-} from '../cborg.js';
-import * as taglib from '../taglib.js';
-import {
-  fromHex,
-  toHex
-} from '../lib/byte-utils.js';
-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) {
-  if (!(obj instanceof Uint8Array)) {
-    throw new Error('expected byte array for tag 23');
-  }
-  return `23(h'${ toHex(obj) }')`;
-};
-tags[24] = function (obj) {
-  return tags[23](obj).replace(/^23/, '24');
-};
-tags[32] = function (obj) {
-  if (typeof obj !== 'string') {
-    throw new Error('expected string for tag 32');
-  }
-  ;
-  (() => new URL(obj))();
-  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);
-}

package/esm/node-test/test-decode-errors.js

@@ -1,69 +0,0 @@
-import chai from 'chai';
-import { decode } from '../cborg.js';
-import { fromHex } from '../lib/byte-utils.js';
-const {assert} = chai;
-describe('decode errors', () => {
-  it('not Uint8Array', () => {
-    for (const arg of [
-        true,
-        false,
-        null,
-        undefined,
-        'string',
-        { obj: 'ect' },
-        {},
-        ['array'],
-        [],
-        [
-          1,
-          2,
-          3
-        ],
-        0,
-        100,
-        1.1,
-        -1,
-        Symbol.for('nope')
-      ]) {
-      assert.throws(() => decode(arg), /CBOR decode error.*must be a Uint8Array/);
-    }
-  });
-  it('no data', () => {
-    assert.throws(() => decode(new Uint8Array('')), /CBOR decode error.*content/);
-  });
-  it('break only', () => {
-    assert.throws(() => decode(new Uint8Array([255])), /CBOR decode error.*break/);
-  });
-  it('not enough map entries (value)', () => {
-    assert.throws(() => decode(fromHex('a2616f016174')), /map.*not enough entries.*value/);
-  });
-  it('not enough map entries (key)', () => {
-    assert.throws(() => decode(fromHex('a2616f01')), /map.*not enough entries.*key/);
-  });
-  it('break in lengthed map', () => {
-    assert.throws(() => decode(fromHex('a2616f01ff740f')), /unexpected break to lengthed map/);
-  });
-  it('not enough array entries', () => {
-    assert.throws(() => decode(fromHex('82616f')), /array.*not enough entries/);
-  });
-  it('break in lengthed array', () => {
-    assert.throws(() => decode(fromHex('82ff')), /unexpected break to lengthed array/);
-  });
-  it('no such decoder', () => {
-    assert.throws(() => decode(fromHex('82ff')), /unexpected break to lengthed array/);
-  });
-  it('too many terminals', () => {
-    assert.throws(() => decode(fromHex('0101')), /too many terminals/);
-  });
-  it('rejectDuplicateMapKeys enabled on duplicate keys', () => {
-    assert.deepStrictEqual(decode(fromHex('a3636261720363666f6f0163666f6f02')), {
-      foo: 2,
-      bar: 3
-    });
-    assert.throws(() => decode(fromHex('a3636261720363666f6f0163666f6f02'), { rejectDuplicateMapKeys: true }), /CBOR decode error: found repeat map key "foo"/);
-    assert.throws(() => decode(fromHex('a3636261720363666f6f0163666f6f02'), {
-      useMaps: true,
-      rejectDuplicateMapKeys: true
-    }), /CBOR decode error: found repeat map key "foo"/);
-  });
-});

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

@@ -1,50 +0,0 @@
-import { garbage } from 'ipld-garbage';
-import {
-  decode,
-  encode
-} from '../cborg.js';
-import 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/);
-    obj = {
-      blip: {},
-      bloop: {}
-    };
-    obj.bloop = obj.blip;
-    assert.doesNotThrow(() => encode(obj));
-    const arr = [];
-    arr[0] = arr;
-    assert.throws(() => encode(arr), /circular references/);
-  });
-});