@fireproof/vendor 1.0.4 → 1.1.0-dev

package/src/cborg/test/test-decode-errors.js

@@ -1,65 +0,0 @@
-/* eslint-env mocha */
-
-import * as chai from 'chai'
-
-import { decode } from "@fireproof/vendor/cborg"
-import { fromHex } from "@fireproof/vendor/cborg/utils"
-
-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)', () => {
-    // last value missing
-    assert.throws(() => decode(fromHex('a2616f016174')), /map.*not enough entries.*value/)
-  })
-
-  it('not enough map entries (key)', () => {
-    // last key & value missing
-    assert.throws(() => decode(fromHex('a2616f01')), /map.*not enough entries.*key/)
-  })
-
-  it('break in lengthed map', () => {
-    // 0xff (break) in the middle
-    assert.throws(() => decode(fromHex('a2616f01ff740f')), /unexpected break to lengthed map/)
-  })
-
-  it('not enough array entries', () => {
-    // last value missing
-    assert.throws(() => decode(fromHex('82616f')), /array.*not enough entries/)
-  })
-
-  it('break in lengthed array', () => {
-    // last value missing
-    assert.throws(() => decode(fromHex('82ff')), /unexpected break to lengthed array/)
-  })
-
-  it('no such decoder', () => {
-    // last value missing
-    assert.throws(() => decode(fromHex('82ff')), /unexpected break to lengthed array/)
-  })
-
-  it('too many terminals', () => {
-    // two '1's
-    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/src/cborg/test/test-fuzz.js

@@ -1,42 +0,0 @@
-/* eslint-env mocha */
-
-import { garbage } from 'ipld-garbage'
-import { decode, encode } from "@fireproof/vendor/cborg"
-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/test/test-json.js

@@ -1,219 +0,0 @@
-/* eslint-env mocha,es2020 */
-
-import { assert } from 'chai'
-import { decode, decodeFirst, encode } from "@fireproof/vendor/cborg/json"
-
-const toBytes = (str) => new TextEncoder().encode(str)
-
-function verifyRoundTrip (obj, sorting) {
-  const encoded = new TextDecoder().decode(encode(obj, sorting === false ? { mapSorter: null } : undefined))
-  const json = JSON.stringify(obj)
-  assert.strictEqual(encoded, json)
-  const decoded = decode(toBytes(JSON.stringify(obj)))
-  assert.deepStrictEqual(decoded, obj)
-}
-
-function verifyEncodedForm (testCase) {
-  // round trip the original object
-  const obj = JSON.parse(testCase)
-  const encoded = encode(obj)
-  assert.strictEqual(new TextDecoder().decode(encoded), JSON.stringify(obj))
-  const decoded = decode(encoded)
-  assert.deepStrictEqual(decoded, obj)
-  // now look at the original form
-  const decoded2 = decode(toBytes(testCase))
-  assert.deepStrictEqual(decoded2, obj)
-}
-
-describe('json basics', () => {
-  it('can round-trip basic literals', () => {
-    const testCases = [
-      'null',
-      'true',
-      'false',
-      '0',
-      '9007199254740991',
-      '-9007199254740991',
-      JSON.stringify(Number.MAX_VALUE),
-      JSON.stringify(Number.MIN_VALUE)
-    ]
-
-    for (const testCase of testCases) {
-      verifyEncodedForm(testCase)
-    }
-    assert.strictEqual(decode(toBytes('1E1')), 10)
-    assert.strictEqual(decode(toBytes('0.1e1')), 1)
-    assert.strictEqual(decode(toBytes('1e-1')), 0.1)
-    assert.strictEqual(decode(toBytes('1e+00')), 1)
-    assert.strictEqual(decode(toBytes('10.0')), 10)
-    assert.deepStrictEqual(decode(toBytes('[-10.0,1.0,0.0,100.0]')), [-10, 1, 0, 100])
-    verifyRoundTrip(true)
-    verifyRoundTrip(false)
-    verifyRoundTrip(null)
-    verifyRoundTrip(100)
-    verifyRoundTrip(-100)
-    verifyRoundTrip(1.11)
-    verifyRoundTrip(-100.11111)
-    verifyRoundTrip(1.11e10)
-    verifyRoundTrip(1.0011111e-18)
-  })
-
-  it('handles large integers as BigInt', () => {
-    const verify = (inp, str) => {
-      if (str === undefined) {
-        str = String(inp)
-      }
-      assert.strictEqual(decode(toBytes(str), { allowBigInt: true }), inp)
-      assert.strictEqual(decode(toBytes(str)), parseFloat(str)) // no BigInt for you
-    }
-    verify(Number.MAX_SAFE_INTEGER)
-    verify(-Number.MAX_SAFE_INTEGER)
-    verify(BigInt('9007199254740992')) // Number.MAX_SAFE_INTEGER+1
-    verify(BigInt('9007199254740993'))
-    verify(BigInt('11959030306112471731'))
-    verify(BigInt('18446744073709551615')) // max uint64
-    verify(BigInt('9223372036854775807')) // max int64
-    verify(BigInt('-9007199254740992'))
-    verify(BigInt('-9007199254740993'))
-    verify(BigInt('-9223372036854776000')) // min int64
-    verify(BigInt('-11959030306112471732'))
-    verify(BigInt('-18446744073709551616')) // min -uint64
-
-    // these are "floats", distinct from "ints" which wouldn't have the `.` in them
-    verify(-9007199254740992, '-9007199254740992.0')
-    verify(-9223372036854776000, '-9223372036854776000.0')
-    verify(-18446744073709551616, '-18446744073709551616.0')
-  })
-
-  it('can round-trip string literals', () => {
-    const testCases = [
-      JSON.stringify(''),
-      JSON.stringify(' '),
-      JSON.stringify('"'),
-      JSON.stringify('\\'),
-      JSON.stringify('\b\f\n\r\t'),
-      JSON.stringify('\u0022'),
-      JSON.stringify('" %22 0x22 034 "'),
-      '"😀"'
-    ]
-
-    for (const testCase of testCases) {
-      verifyEncodedForm(testCase)
-    }
-    assert.strictEqual(decode(toBytes('"/ & \\/"')), '/ & /')
-    verifyRoundTrip('this is a string')
-    verifyRoundTrip('this 𝄞 is a ☺☺ ♣ string ̐ ̀\n\r') // accents like  ̀ and  ̐ use two-byte utf8
-    verifyRoundTrip('')
-    verifyRoundTrip('foo\\bar\nbaz\tbop\rbing"bip\'bang')
-  })
-
-  it('can round-trip array literals', () => {
-    const testCases = [
-      '[]',
-      '[null]',
-      '[true, false]',
-      '[ \n 0,1, 2\n ,  3,\n4] \n ',
-      '[-10.0, 1.0, 0.0, 100.0]',
-      '[["2 deep"]]'
-    ]
-    for (const testCase of testCases) {
-      verifyEncodedForm(testCase)
-    }
-    verifyRoundTrip([1, 2, 3, 'string', true, 4])
-    verifyRoundTrip([1, 2, 3, 'string', true, ['and', 'a', 'nested', 'array', true], 4])
-  })
-
-  it('can round-trip object literals', () => {
-    const testCases = [
-      '{}',
-      '\n {\n "\\b"\n :\n""\n }\n ',
-      '{"":""}',
-      '{"1":{"2":0,"3":"deep"}}'
-    ]
-    for (const testCase of testCases) {
-      verifyEncodedForm(testCase)
-    }
-  })
-
-  it('will sort map keys', () => {
-    const unsorted = { one: 1, two: 2, three: 3.1, str: 'string', bool: true, four: 4 }
-    verifyRoundTrip(unsorted, false)
-    assert.strictEqual(
-      new TextDecoder().decode(encode(unsorted)),
-      '{"bool":true,"four":4,"one":1,"str":"string","three":3.1,"two":2}')
-  })
-
-  it('can handle novel cases', () => {
-    assert.strictEqual(decode(toBytes('"this \\uD834\\uDD1E is a \\u263a\\u263a string"')), 'this 𝄞 is a ☺☺ string')
-    verifyRoundTrip({ one: 1, two: 2, three: 3.1, str: 'string', arr: ['and', 'a', 'nested', [], 'array', [true, 1], false], bool: true, obj: { nested: 'object', a: [], o: {} }, four: 4 }, false)
-    verifyRoundTrip([false, [{ '#nFzU': {}, '\\w>': -0.9441451951197325, "\t'": "'JB+2Wg\tw\"IrM*#e^L/d&4rrzUuwq(1mH6aVRredB&Bfs]S\"KqK(Tz1Q\"URBAfw", '\n@FrfM': 'M[D]q&' }, "J4>'Xdc+u2$%", 4227406737130333]], false)
-    verifyRoundTrip([0.12995619865708727, -4973404279772543, { drG2: [true], ';#K^Qf>V': null, '`2=': 'ecc<e/$+-.;U>Gr5RdZDJ\n5+:{=QHNN.tVVN~dX$FWFwu`6>"&=tW!*1*^☺)JFM1p|}&X.B|${*\\f@!w2☺+' }], false)
-    assert.strictEqual(`${decode(encode(9007199254740991))}`, '9007199254740991')
-    assert.strictEqual(`${decode(encode(9007199254740992))}`, '9007199254740992')
-    assert.strictEqual(`${decode(encode(900719925474099100n))}`, '900719925474099100')
-  })
-
-  it('should throw on bad types', () => {
-    assert.throws(() => encode(new Uint8Array([1, 2])), /JSON encode error: unsupported type: Uint8Array/)
-    assert.throws(() => encode({ boop: new Uint8Array([1, 2]) }), /JSON encode error: unsupported type: Uint8Array/)
-    assert.throws(() => encode(undefined), /JSON encode error: unsupported type: undefined/)
-    assert.throws(() => encode(new Map([[1, 2], [2, 3]])), /JSON encode error: non-string map keys are not supported/)
-    assert.throws(() => encode(new Map([[['foo', 'bar'], 2], [['bar', 'foo'], 3]])), /JSON encode error: complex map keys are not supported/)
-  })
-
-  it('should throw on bad decode failure modes', () => {
-    assert.throws(() => decode(toBytes('{"a":1 & "b":2}')), 'JSON decode error: unexpected character at position 7, was expecting object delimiter but found \'&\'')
-    assert.throws(() => decode(toBytes('{"a":1,"b"!2}')), 'JSON decode error: unexpected character at position 10, was expecting key/value delimiter \':\' but found \'!\'')
-    assert.throws(() => decode(toBytes('[1,2&3]')), 'JSON decode error: unexpected character at position 4, was expecting array delimiter but found \'&\'')
-    assert.throws(() => decode(toBytes('{"a":!}')), 'JSON decode error: unexpected character at position 5')
-    assert.throws(() => decode(toBytes('"abc')), 'JSON decode error: unexpected end of string at position 4')
-    assert.throws(() => decode(toBytes('"ab\\xc"')), 'JSON decode error: unexpected string escape character at position 5')
-    assert.throws(() => decode(toBytes('"ab\x1Ec"')), 'JSON decode error: invalid control character at position 3')
-    assert.throws(() => decode(toBytes('"ab\\')), 'JSON decode error: unexpected string termination at position 4')
-    // begining of a quoted string with 3-byte unicode sequence with the last one truncated
-    assert.throws(() => decode(toBytes('"☺').subarray(0, 3)), 'JSON decode error: unexpected unicode sequence at position 1')
-    assert.throws(() => decode(toBytes('"\\uxyza"')), 'JSON decode error: unexpected unicode escape character at position 3')
-    assert.throws(() => decode(toBytes('"\\u11"')), 'JSON decode error: unexpected end of unicode escape sequence at position 3')
-    assert.throws(() => decode(toBytes('-boop')), 'JSON decode error: unexpected token at position 1')
-    assert.throws(() => decode(toBytes('{"v":nope}')), 'JSON decode error: unexpected token at position 7, expected to find \'null\'')
-    assert.throws(() => decode(toBytes('[n]')), 'JSON decode error: unexpected end of input at position 1')
-    assert.throws(() => decode(toBytes('{"v":truu}')), 'JSON decode error: unexpected token at position 9, expected to find \'true\'')
-    assert.throws(() => decode(toBytes('[tr]')), 'JSON decode error: unexpected end of input at position 1')
-    assert.throws(() => decode(toBytes('{"v":flase}')), 'JSON decode error: unexpected token at position 7, expected to find \'false\'')
-    assert.throws(() => decode(toBytes('[fa]')), 'JSON decode error: unexpected end of input at position 1')
-    assert.throws(() => decode(toBytes('-0..1')), 'JSON decode error: unexpected token at position 3')
-  })
-
-  it('should throw when rejectDuplicateMapKeys enabled on duplicate keys', () => {
-    assert.deepStrictEqual(decode(toBytes('{"foo":1,"foo":2}')), { foo: 2 })
-    assert.throws(() => decode(toBytes('{"foo":1,"foo":2}'), { rejectDuplicateMapKeys: true }), /JSON decode error: found repeat map key "foo"/)
-  })
-
-  it('decodeFirst', () => {
-    /*
-    const encoded = new TextDecoder().decode(encode(obj, sorting === false ? { mapSorter: null } : undefined))
-    const json = JSON.stringify(obj)
-    assert.strictEqual(encoded, json)
-    const decoded = decode(toBytes(JSON.stringify(obj)))
-    assert.deepStrictEqual(decoded, obj)
-    */
-    let buf = new TextEncoder().encode('{"foo":1,"bar":2}1"ping"2null3[1,2,3]""[[],[],{"boop":true}]')
-    const expected = [
-      { foo: 1, bar: 2 },
-      1,
-      'ping',
-      2,
-      null,
-      3,
-      [1, 2, 3],
-      '',
-      [[], [], { boop: true }]
-    ]
-    for (const exp of expected) {
-      const [obj, rest] = decodeFirst(buf)
-      assert.deepStrictEqual(exp, obj)
-      buf = rest
-    }
-    assert.strictEqual(buf.length, 0)
-  })
-})

package/src/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 "@fireproof/vendor/cborg/utils"
-import { encode } from "@fireproof/vendor/cborg"
-import { encodedLength } from "@fireproof/vendor/cborg/length"
-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/test/test-partial.js

@@ -1,111 +0,0 @@
-/* eslint-env mocha */
-
-import * as chai from 'chai'
-import { garbage } from 'ipld-garbage'
-import { uintBoundaries } from "@fireproof/vendor/cborg/utils"
-import { encode, decodeFirst } from "@fireproof/vendor/cborg"
-import { dateDecoder, dateEncoder } from './common.js'
-
-const { assert } = chai
-
-function verifyPartial (objects, options) {
-  const encoded = []
-  const lengths = []
-  let length = 0
-  for (const object of Array.isArray(objects) ? objects : [objects]) {
-    encoded.push(encode(object, options))
-    const l = encoded[encoded.length - 1].length
-    length += l
-    lengths.push(l)
-  }
-  const buf = new Uint8Array(length)
-  let offset = 0
-  for (const enc of encoded) {
-    buf.set(enc, offset)
-    offset += enc.length
-  }
-  let partial = buf
-  for (let ii = 0; ii < encoded.length; ii++) {
-    const [decoded, remainder] = decodeFirst(partial, options)
-    assert.deepEqual(decoded, objects[ii])
-    assert.equal(remainder.length, partial.length - lengths[ii])
-    partial = remainder
-  }
-  assert.equal(partial.length, 0) // just to be sure
-}
-
-describe('decodePartial', () => {
-  describe('multiple', () => {
-    it('simple', () => {
-      verifyPartial([1, 2, 3])
-      verifyPartial([8.940696716308594e-08, 1])
-      verifyPartial([
-        [],
-        [1, 2, { obj: 1.5 }, null, new Uint8Array([1, 2, 3])],
-        { boop: true, bop: 1 },
-        'nope',
-        { o: 'nope' },
-        new Uint8Array([1, 2, 3]),
-        true,
-        null
-      ])
-    })
-
-    it('options', () => {
-      const m = new Map()
-      m.set('a', 1)
-      m.set('b', null)
-      m.set('c', 'grok')
-      m.set('date', new Date('2013-03-21T20:04:00Z'))
-      verifyPartial(
-        [8.940696716308594e-08, 1, null, 'grok', new Date('2013-03-21T20:04:00Z'),
-          [8.940696716308594e-08, 1, null, 'grok', new Date('2013-03-21T20:04:00Z')],
-          m
-        ],
-        { typeEncoders: { Date: dateEncoder }, useMaps: true, tags: { 0: dateDecoder } })
-    })
-
-    it('garbage', function () {
-      this.timeout(10000)
-      for (let ii = 0; ii < 10; ii++) {
-        const gbg = []
-        for (let ii = 0; ii < 100; ii++) {
-          gbg.push(garbage(1 << 6, { weights: { CID: 0 } }))
-        }
-        verifyPartial(gbg)
-      }
-    })
-  })
-
-  it('singular', () => {
-    it('int boundaries', () => {
-      for (let ii = 0; ii < 4; ii++) {
-        verifyPartial(uintBoundaries[ii])
-        verifyPartial(uintBoundaries[ii] - 1)
-        verifyPartial(uintBoundaries[ii] + 1)
-        verifyPartial(-1 * uintBoundaries[ii])
-        verifyPartial(-1 * uintBoundaries[ii] - 1)
-        verifyPartial(-1 * uintBoundaries[ii] + 1)
-      }
-    })
-
-    it('tags', () => {
-      verifyPartial({ date: new Date('2013-03-21T20:04:00Z') }, { typeEncoders: { Date: dateEncoder } })
-    })
-
-    it('floats', () => {
-      verifyPartial(0.5)
-      verifyPartial(0.5, { float64: true })
-      verifyPartial(8.940696716308594e-08)
-      verifyPartial(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 } })
-        verifyPartial(gbg)
-      }
-    })
-  })
-})

package/src/cborg/tsconfig.json

@@ -1,48 +0,0 @@
-{
-  "compilerOptions": {
-    "allowJs": true,
-    "checkJs": true,
-    "forceConsistentCasingInFileNames": true,
-    "noImplicitReturns": false,
-    "noImplicitAny": true,
-    "noImplicitThis": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "strictFunctionTypes": false,
-    "strictNullChecks": true,
-    "strictPropertyInitialization": true,
-    "strictBindCallApply": true,
-    "strict": true,
-    "alwaysStrict": true,
-    "esModuleInterop": true,
-    "target": "ES2018",
-    "moduleResolution": "node",
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "types",
-    "skipLibCheck": true,
-    "stripInternal": true,
-    "resolveJsonModule": true,
-    "baseUrl": ".",
-    "emitDeclarationOnly": true,
-    "paths": {
-      "cborg": [
-        "cborg/index.js"
-      ],
-      "cborg/utils": [
-        "./utils/index.js"
-      ]
-    }
-  },
-  "include": [
-    "cborg.js",
-    "example.js",
-    "taglib.js",
-    "lib/"
-, "utils/byte-utils.js", "utils/jump.js", "utils/0uint.js", "utils/1negint.js", "utils/2bytes.js", "utils/3string.js", "utils/4array.js", "utils/5map.js", "utils/6tag.js", "utils/7float.js", "json"  ],
-  "exclude": [
-    "node_modules"
-  ],
-  "compileOnSave": false
-}

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

@@ -1,43 +0,0 @@
-export type Token = import("cborg/utils").Token;
-export type DecodeOptions = import("../interface").DecodeOptions;
-export type DecodeTokenizer = import("../interface").DecodeTokenizer;
-export type DecodeFunction = import("../interface").DecodeFunction;
-/**
- * @implements {DecodeTokenizer}
- */
-export class Tokeniser implements DecodeTokenizer {
-    /**
-     * @param {Uint8Array} data
-     * @param {DecodeOptions} options
-     */
-    constructor(data: Uint8Array, options: DecodeOptions);
-    _pos: number;
-    data: Uint8Array<ArrayBufferLike>;
-    options: import("../interface").DecodeOptions;
-    jump: import("../interface").DecodeFunction[];
-    pos(): number;
-    done(): boolean;
-    next(): import("cborg/utils").Token;
-}
-/**
- * @param {DecodeTokenizer} tokeniser
- * @param {DecodeOptions} options
- * @returns {any|BREAK|DONE}
- */
-export function tokensToObject(tokeniser: DecodeTokenizer, options: DecodeOptions): any | typeof BREAK | typeof DONE;
-/**
- * @param {Uint8Array} data
- * @param {DecodeOptions} [options]
- * @returns {any}
- */
-export function decode(data: Uint8Array, options?: DecodeOptions): any;
-/**
- * @param {Uint8Array} data
- * @param {DecodeOptions} [options]
- * @returns {[any, Uint8Array]}
- */
-export function decodeFirst(data: Uint8Array, options?: DecodeOptions): [any, Uint8Array];
-declare const BREAK: unique symbol;
-declare const DONE: unique symbol;
-export {};
-//# sourceMappingURL=decode.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../cborg/decode.js"],"names":[],"mappings":"oBAGa,OAAO,aAAa,EAAE,KAAK;4BAC3B,OAAO,cAAc,EAAE,aAAa;8BACpC,OAAO,cAAc,EAAE,eAAe;6BACtC,OAAO,cAAc,EAAE,cAAc;AAWlD;;GAEG;AACH,kCAFgB,eAAe;IAG7B;;;OAGG;IACH,kBAHW,UAAU,WACV,aAAa,EAOvB;IAJC,aAAa;IACb,kCAAgB;IAChB,8CAAsB;IACtB,8CAAyC;IAG3C,cAEC;IAED,gBAEC;IAED,oCAgBC;CACF;AA6ED;;;;GAIG;AACH,0CAJW,eAAe,WACf,aAAa,GACX,GAAG,6BAAW,CAoC1B;AAuBD;;;;GAIG;AACH,6BAJW,UAAU,YACV,aAAa,GACX,GAAG,CASf;AAjCD;;;;GAIG;AACH,kCAJW,UAAU,YACV,aAAa,GACX,CAAC,GAAG,EAAE,UAAU,CAAC,CAgB7B;AAtID,mCAAiC;AADjC,kCAA+B"}

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

@@ -1,51 +0,0 @@
-/** @returns {TokenTypeEncoder[]} */
-export function makeCborEncoders(): TokenTypeEncoder[];
-export type EncodeOptions = import("../interface").EncodeOptions;
-export type OptionalTypeEncoder = import("../interface").OptionalTypeEncoder;
-export type Reference = import("../interface").Reference;
-export type StrictTypeEncoder = import("../interface").StrictTypeEncoder;
-export type TokenTypeEncoder = import("../interface").TokenTypeEncoder;
-export type TokenOrNestedTokens = import("../interface").TokenOrNestedTokens;
-/**
- * @param {any} obj
- * @param {EncodeOptions} options
- * @param {Reference} [refStack]
- * @returns {TokenOrNestedTokens}
- */
-export function objectToTokens(obj: any, options: EncodeOptions, refStack?: Reference): TokenOrNestedTokens;
-/**
- * @param {any} data
- * @param {EncodeOptions} [options]
- * @returns {Uint8Array}
- */
-export function encode(data: any, options?: EncodeOptions): Uint8Array;
-/**
- * @param {any} data
- * @param {TokenTypeEncoder[]} encoders
- * @param {EncodeOptions} options
- * @returns {Uint8Array}
- */
-export function encodeCustom(data: any, encoders: TokenTypeEncoder[], options: EncodeOptions): Uint8Array;
-/** @implements {Reference} */
-export class Ref implements Reference {
-    /**
-     * @param {Reference|undefined} stack
-     * @param {object|any[]} obj
-     * @param {EncodeOptions} options
-     * @returns {Reference}
-     */
-    static createCheck(stack: Reference | undefined, obj: object | any[], { encodeErrPrefix }: EncodeOptions): Reference;
-    /**
-     * @param {object|any[]} obj
-     * @param {Reference|undefined} parent
-     */
-    constructor(obj: object | any[], parent: Reference | undefined);
-    obj: object | any[];
-    parent: import("../interface").Reference | undefined;
-    /**
-     * @param {object|any[]} obj
-     * @returns {boolean}
-     */
-    includes(obj: object | any[]): boolean;
-}
-//# sourceMappingURL=encode.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../cborg/encode.js"],"names":[],"mappings":"AAiCA,oCAAoC;AACpC,oCADc,gBAAgB,EAAE,CAY/B;4BA7BY,OAAO,cAAc,EAAE,aAAa;kCACpC,OAAO,cAAc,EAAE,mBAAmB;wBAC1C,OAAO,cAAc,EAAE,SAAS;gCAChC,OAAO,cAAc,EAAE,iBAAiB;+BACxC,OAAO,cAAc,EAAE,gBAAgB;kCACvC,OAAO,cAAc,EAAE,mBAAmB;AAmQvD;;;;;GAKG;AACH,oCALW,GAAG,WACH,aAAa,aACb,SAAS,GACP,mBAAmB,CAgB/B;AA2JD;;;;GAIG;AACH,6BAJW,GAAG,YACH,aAAa,GACX,UAAU,CAKtB;AAvCD;;;;;GAKG;AACH,mCALW,GAAG,YACH,gBAAgB,EAAE,WAClB,aAAa,GACX,UAAU,CAyBtB;AAlZD,8BAA8B;AAC9B,4BADiB,SAAS;IA0BxB;;;;;OAKG;IACH,0BALW,SAAS,GAAC,SAAS,OACnB,MAAM,GAAC,GAAG,EAAE,uBACZ,aAAa,GACX,SAAS,CAOrB;IAnCD;;;OAGG;IACH,iBAHW,MAAM,GAAC,GAAG,EAAE,UACZ,SAAS,GAAC,SAAS,EAK7B;IAFC,oBAAc;IACd,qDAAoB;IAGtB;;;OAGG;IACH,cAHW,MAAM,GAAC,GAAG,EAAE,GACV,OAAO,CAWnB;CAcF"}