@fireproof/vendor 0.0.0-smoke

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

@@ -0,0 +1,65 @@
+/* eslint-env mocha */
+
+import * as 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)', () => {
+    // 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/cborg/test/test-fuzz.js

@@ -0,0 +1,42 @@
+/* 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-json.js

@@ -0,0 +1,219 @@
+/* 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])), /CBOR encode error: unsupported type: Uint8Array/)
+    assert.throws(() => encode({ boop: new Uint8Array([1, 2]) }), /CBOR encode error: unsupported type: Uint8Array/)
+    assert.throws(() => encode(undefined), /CBOR encode error: unsupported type: undefined/)
+    assert.throws(() => encode(new Map([[1, 2], [2, 3]])), /CBOR encode error: non-string map keys are not supported/)
+    assert.throws(() => encode(new Map([[['foo', 'bar'], 2], [['bar', 'foo'], 3]])), /CBOR encode error: complex map keys are not supported/)
+  })
+
+  it('should throw on bad decode failure modes', () => {
+    assert.throws(() => decode(toBytes('{"a":1 & "b":2}')), 'CBOR decode error: unexpected character at position 7, was expecting object delimiter but found \'&\'')
+    assert.throws(() => decode(toBytes('{"a":1,"b"!2}')), 'CBOR decode error: unexpected character at position 10, was expecting key/value delimiter \':\' but found \'!\'')
+    assert.throws(() => decode(toBytes('[1,2&3]')), 'CBOR decode error: unexpected character at position 4, was expecting array delimiter but found \'&\'')
+    assert.throws(() => decode(toBytes('{"a":!}')), 'CBOR decode error: unexpected character at position 5')
+    assert.throws(() => decode(toBytes('"abc')), 'CBOR decode error: unexpected end of string at position 4')
+    assert.throws(() => decode(toBytes('"ab\\xc"')), 'CBOR decode error: unexpected string escape character at position 5')
+    assert.throws(() => decode(toBytes('"ab\x1Ec"')), 'CBOR decode error: invalid control character at position 3')
+    assert.throws(() => decode(toBytes('"ab\\')), 'CBOR 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)), 'CBOR decode error: unexpected unicode sequence at position 1')
+    assert.throws(() => decode(toBytes('"\\uxyza"')), 'CBOR decode error: unexpected unicode escape character at position 3')
+    assert.throws(() => decode(toBytes('"\\u11"')), 'CBOR decode error: unexpected end of unicode escape sequence at position 3')
+    assert.throws(() => decode(toBytes('-boop')), 'CBOR decode error: unexpected token at position 1')
+    assert.throws(() => decode(toBytes('{"v":nope}')), 'CBOR decode error: unexpected token at position 7, expected to find \'null\'')
+    assert.throws(() => decode(toBytes('[n]')), 'CBOR decode error: unexpected end of input at position 1')
+    assert.throws(() => decode(toBytes('{"v":truu}')), 'CBOR decode error: unexpected token at position 9, expected to find \'true\'')
+    assert.throws(() => decode(toBytes('[tr]')), 'CBOR decode error: unexpected end of input at position 1')
+    assert.throws(() => decode(toBytes('{"v":flase}')), 'CBOR decode error: unexpected token at position 7, expected to find \'false\'')
+    assert.throws(() => decode(toBytes('[fa]')), 'CBOR decode error: unexpected end of input at position 1')
+    assert.throws(() => decode(toBytes('-0..1')), 'CBOR 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 }), /CBOR 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/cborg/test/test-length.js

@@ -0,0 +1,65 @@
+/* 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/test/test-partial.js

@@ -0,0 +1,111 @@
+/* eslint-env mocha */
+
+import * as chai from 'chai'
+import { garbage } from 'ipld-garbage'
+import { uintBoundaries } from '../lib/0uint.js'
+import { encode, decodeFirst } from '../cborg.js'
+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/cborg/tsconfig.json

@@ -0,0 +1,45 @@
+{
+  "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.js"
+      ]
+    }
+  },
+  "include": [
+    "cborg.js",
+    "example.js",
+    "taglib.js",
+    "lib/"
+  ],
+  "exclude": [
+    "node_modules"
+  ],
+  "compileOnSave": false
+}

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1 @@
+{"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

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

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

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

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

@@ -0,0 +1,47 @@
+import { Token } from './lib/token';
+import { Bl } from './lib/bl';
+export type TokenOrNestedTokens = Token | Token[] | TokenOrNestedTokens[];
+export interface Reference {
+    parent: Reference | undefined;
+    obj: object | any[];
+    includes(obj: object | any[]): boolean;
+}
+export type OptionalTypeEncoder = (data: any, typ: string, options: EncodeOptions, refStack?: Reference) => TokenOrNestedTokens | null;
+export type StrictTypeEncoder = (data: any, typ: string, options: EncodeOptions, refStack?: Reference) => TokenOrNestedTokens;
+export type TokenTypeEncoder = {
+    (buf: Bl, token: Token, options?: EncodeOptions): void;
+    compareTokens(t1: Token, t2: Token): number;
+    encodedSize?(token: Token, options?: EncodeOptions): number;
+};
+export type MapSorter = (e1: (Token | Token[])[], e2: (Token | Token[])[]) => number;
+export type QuickEncodeToken = (token: Token) => Uint8Array | undefined;
+export interface DecodeTokenizer {
+    done(): boolean;
+    next(): Token;
+    pos(): number;
+}
+export type TagDecoder = (inner: any) => any;
+export interface DecodeOptions {
+    allowIndefinite?: boolean;
+    allowUndefined?: boolean;
+    coerceUndefinedToNull?: boolean;
+    allowInfinity?: boolean;
+    allowNaN?: boolean;
+    allowBigInt?: boolean;
+    strict?: boolean;
+    useMaps?: boolean;
+    rejectDuplicateMapKeys?: boolean;
+    retainStringBytes?: boolean;
+    tags?: TagDecoder[];
+    tokenizer?: DecodeTokenizer;
+}
+export interface EncodeOptions {
+    float64?: boolean;
+    addBreakTokens?: boolean;
+    mapSorter?: MapSorter;
+    quickEncodeToken?: QuickEncodeToken;
+    typeEncoders?: {
+        [typeName: string]: OptionalTypeEncoder;
+    };
+}
+//# sourceMappingURL=interface.d.ts.map

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

@@ -0,0 +1 @@
+{"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"}