@fireproof/vendor 0.0.0-smoke

package/patched/@ipld/dag-json/src/index.js

@@ -0,0 +1,291 @@
+/* eslint max-depth: ["error", 7] */
+import { Token, Type } from 'cborg'
+import * as cborgJson from 'cborg/json'
+import { CID } from 'multiformats'
+import { base64 } from 'multiformats/bases/base64'
+
+/**
+ * @template T
+ * @typedef {import('multiformats/codecs/interface').ByteView<T>} ByteView
+ */
+/**
+ * @template T
+ * @typedef {import('multiformats/codecs/interface').ArrayBufferView<T>} ArrayBufferView
+ */
+/**
+ * @template T
+ * @typedef {import('multiformats').ToString<T>} ToString
+ */
+/**
+ * @typedef {import('cborg/interface').DecodeTokenizer} DecodeTokenizer
+ */
+
+/**
+ * @template T
+ * @param {ByteView<T> | ArrayBufferView<T>} buf
+ * @returns {ByteView<T>}
+ */
+function toByteView (buf) {
+  if (buf instanceof ArrayBuffer) {
+    return new Uint8Array(buf, 0, buf.byteLength)
+  }
+
+  return buf
+}
+
+/**
+ * cidEncoder will receive all Objects during encode, it needs to filter out
+ * anything that's not a CID and return `null` for that so it's encoded as
+ * normal. Encoding a CID means replacing it with a `{"/":"<CidString>}`
+ * object as per the DAG-JSON spec.
+ *
+ * @param {any} obj
+ * @returns {Token[]|null}
+ */
+function cidEncoder (obj) {
+  if (obj.asCID !== obj && obj['/'] !== obj.bytes) {
+    return null // any other kind of object
+  }
+  const cid = CID.asCID(obj)
+  /* c8 ignore next 4 */
+  // very unlikely case, and it'll probably throw a recursion error in cborg
+  if (!cid) {
+    return null
+  }
+  const cidString = cid.toString()
+
+  return [
+    new Token(Type.map, Infinity, 1),
+    new Token(Type.string, '/', 1), // key
+    new Token(Type.string, cidString, cidString.length), // value
+    new Token(Type.break, undefined, 1)
+  ]
+}
+
+/**
+ * bytesEncoder will receive all Uint8Arrays (and friends) during encode, it
+ * needs to replace it with a `{"/":{"bytes":"Base64ByteString"}}` object as
+ * per the DAG-JSON spec.
+ *
+ * @param {Uint8Array} bytes
+ * @returns {Token[]|null}
+ */
+function bytesEncoder (bytes) {
+  const bytesString = base64.encode(bytes).slice(1) // no mbase prefix
+  return [
+    new Token(Type.map, Infinity, 1),
+    new Token(Type.string, '/', 1), // key
+    new Token(Type.map, Infinity, 1), // value
+    new Token(Type.string, 'bytes', 5), // inner key
+    new Token(Type.string, bytesString, bytesString.length), // inner value
+    new Token(Type.break, undefined, 1),
+    new Token(Type.break, undefined, 1)
+  ]
+}
+
+/**
+ * taBytesEncoder wraps bytesEncoder() but for the more exotic typed arrays so
+ * that we access the underlying ArrayBuffer data
+ *
+ * @param {Int8Array|Uint16Array|Int16Array|Uint32Array|Int32Array|Float32Array|Float64Array|Uint8ClampedArray|BigInt64Array|BigUint64Array} obj
+ * @returns {Token[]|null}
+ */
+function taBytesEncoder (obj) {
+  return bytesEncoder(new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength))
+}
+
+/**
+ * abBytesEncoder wraps bytesEncoder() but for plain ArrayBuffers
+ *
+ * @param {ArrayBuffer} ab
+ * @returns {Token[]|null}
+ */
+function abBytesEncoder (ab) {
+  return bytesEncoder(new Uint8Array(ab))
+}
+
+// eslint-disable-next-line jsdoc/require-returns-check
+/**
+ * Intercept all `undefined` values from an object walk and reject the entire
+ * object if we find one.
+ *
+ * @returns {null}
+ */
+function undefinedEncoder () {
+  throw new Error('`undefined` is not supported by the IPLD Data Model and cannot be encoded')
+}
+
+/**
+ * Intercept all `number` values from an object walk and reject the entire
+ * object if we find something that doesn't fit the IPLD data model (NaN &
+ * Infinity).
+ *
+ * @param {number} num
+ * @returns {null}
+ */
+function numberEncoder (num) {
+  if (Number.isNaN(num)) {
+    throw new Error('`NaN` is not supported by the IPLD Data Model and cannot be encoded')
+  }
+  if (num === Infinity || num === -Infinity) {
+    throw new Error('`Infinity` and `-Infinity` is not supported by the IPLD Data Model and cannot be encoded')
+  }
+  return null // process with standard number encoder
+}
+
+const encodeOptions = {
+  typeEncoders: {
+    Object: cidEncoder,
+    Buffer: bytesEncoder,
+    Uint8Array: bytesEncoder,
+    Int8Array: taBytesEncoder,
+    Uint16Array: taBytesEncoder,
+    Int16Array: taBytesEncoder,
+    Uint32Array: taBytesEncoder,
+    Int32Array: taBytesEncoder,
+    Float32Array: taBytesEncoder,
+    Float64Array: taBytesEncoder,
+    Uint8ClampedArray: taBytesEncoder,
+    BigInt64Array: taBytesEncoder,
+    BigUint64Array: taBytesEncoder,
+    DataView: taBytesEncoder,
+    ArrayBuffer: abBytesEncoder,
+    undefined: undefinedEncoder,
+    number: numberEncoder
+  }
+}
+
+/**
+ * @implements {DecodeTokenizer}
+ */
+class DagJsonTokenizer extends cborgJson.Tokenizer {
+  /**
+   * @param {Uint8Array} data
+   * @param {object} [options]
+   */
+  constructor (data, options) {
+    super(data, options)
+    /** @type {Token[]} */
+    this.tokenBuffer = []
+  }
+
+  /**
+   * @returns {boolean}
+   */
+  done () {
+    return this.tokenBuffer.length === 0 && super.done()
+  }
+
+  /**
+   * @returns {Token}
+   */
+  _next () {
+    if (this.tokenBuffer.length > 0) {
+      // @ts-ignore https://github.com/Microsoft/TypeScript/issues/30406
+      return this.tokenBuffer.pop()
+    }
+    return super.next()
+  }
+
+  /**
+   * Implements rules outlined in https://github.com/ipld/specs/pull/356
+   *
+   * @returns {Token}
+   */
+  next () {
+    const token = this._next()
+
+    if (token.type.compare(Type.map) === 0) {
+      const keyToken = this._next()
+      if (keyToken.type.compare(Type.string) === 0 && keyToken.value === '/') {
+        const valueToken = this._next()
+        if (valueToken.type.compare(Type.string) === 0) { // *must* be a CID
+          const breakToken = this._next() // swallow the end-of-map token
+          if (breakToken.type.compare(Type.break)) {
+            throw new Error('Invalid encoded CID form')
+          }
+          this.tokenBuffer.push(valueToken) // CID.parse will pick this up after our tag token
+          return new Token(Type.tag, 42, 0)
+        }
+        if (valueToken.type.compare(Type.map) === 0) {
+          const innerKeyToken = this._next()
+          if (innerKeyToken.type.compare(Type.string) === 0 && innerKeyToken.value === 'bytes') {
+            const innerValueToken = this._next()
+            if (innerValueToken.type.compare(Type.string) === 0) { // *must* be Bytes
+              for (let i = 0; i < 2; i++) {
+                const breakToken = this._next() // swallow two end-of-map tokens
+                if (breakToken.type.compare(Type.break)) {
+                  throw new Error('Invalid encoded Bytes form')
+                }
+              }
+              const bytes = base64.decode(`m${innerValueToken.value}`)
+              return new Token(Type.bytes, bytes, innerValueToken.value.length)
+            }
+            this.tokenBuffer.push(innerValueToken) // bail
+          }
+          this.tokenBuffer.push(innerKeyToken) // bail
+        }
+        this.tokenBuffer.push(valueToken) // bail
+      }
+      this.tokenBuffer.push(keyToken) // bail
+    }
+    return token
+  }
+}
+
+const decodeOptions = {
+  allowIndefinite: false,
+  allowUndefined: false,
+  allowNaN: false,
+  allowInfinity: false,
+  allowBigInt: true, // this will lead to BigInt for ints outside of
+  // safe-integer range, which may surprise users
+  strict: true,
+  useMaps: false,
+  rejectDuplicateMapKeys: true,
+  /** @type {import('cborg').TagDecoder[]} */
+  tags: []
+}
+
+// we're going to get TAG(42)STRING("bafy...") from the tokenizer so we only need
+// to deal with the STRING("bafy...") at this point
+decodeOptions.tags[42] = CID.parse
+
+export const name = 'dag-json'
+export const code = 0x0129
+
+/**
+ * @template T
+ * @param {T} node
+ * @returns {ByteView<T>}
+ */
+export const encode = (node) => cborgJson.encode(node, encodeOptions)
+
+/**
+ * @template T
+ * @param {ByteView<T> | ArrayBufferView<T>} data
+ * @returns {T}
+ */
+export const decode = (data) => {
+  const buf = toByteView(data)
+  // the tokenizer is stateful so we need a single instance of it
+  const options = Object.assign(decodeOptions, { tokenizer: new DagJsonTokenizer(buf, decodeOptions) })
+  return cborgJson.decode(buf, options)
+}
+
+/**
+ * @template T
+ * @param {T} node
+ * @returns {ToString<T>}
+ */
+export const format = (node) => utf8Decoder.decode(encode(node))
+export { format as stringify }
+const utf8Decoder = new TextDecoder()
+
+/**
+ * @template T
+ * @param {ToString<T>} data
+ * @returns {T}
+ */
+export const parse = (data) => decode(utf8Encoder.encode(data))
+const utf8Encoder = new TextEncoder()

package/patched/@ipld/dag-json/test/test-basics.spec.js

@@ -0,0 +1,290 @@
+/* eslint-env mocha */
+import { garbage } from '@ipld/garbage'
+import { assert } from 'aegir/chai'
+import { bytes, CID } from 'multiformats'
+import { base64 } from 'multiformats/bases/base64'
+import { encode, decode, stringify, parse } from '../src/index.js'
+
+const same = assert.deepStrictEqual
+
+const recode = (/** @type {Uint8Array} */ byts) => encode(decode(byts))
+
+const link = CID.parse('bafyreifepiu23okq5zuyvyhsoiazv2icw2van3s7ko6d3ixl5jx2yj2yhu')
+
+describe('basic dag-json', () => {
+  it('encode decode', () => {
+    const byts = encode({ hello: 'world' })
+    same(JSON.parse(bytes.toString(recode(byts))), { hello: 'world' })
+    const o = { link, byts: bytes.fromString('asdf'), n: null, o: {} }
+    const byts2 = encode(o)
+    same(decode(byts2), o)
+    same(bytes.isBinary(decode(byts2).byts), true)
+  })
+
+  it('encode decode 2', () => {
+    // mirrors a go-ipld-prime test, but with sorted keys
+    const obj = { plain: 'olde string', bytes: utf8Encode('deadbeef') }
+    const expected = '{"bytes":{"/":{"bytes":"ZGVhZGJlZWY"}},"plain":"olde string"}'
+    const byts = encode(obj)
+    same(JSON.parse(bytes.toString(recode(byts))), JSON.parse(expected))
+    same(bytes.toString(recode(byts)), expected)
+  })
+
+  it('encode decode with ArrayBuffer', () => {
+    const byts = encode({ hello: 'world' })
+    same(JSON.parse(bytes.toString(recode(byts))), { hello: 'world' })
+    const o = { link, byts: bytes.fromString('asdf'), n: null, o: {} }
+    const byts2 = encode(o)
+    same(decode(byts2), o)
+    same(bytes.isBinary(decode(byts2).byts.buffer), true)
+  })
+
+  describe('reserved space', () => {
+    it('allow alternative types', () => {
+      //  wrong types
+      for (const obj of [true, false, null, 1, -1, 1.1, { blip: 'bop' }, ['foo']]) {
+        same(decode(encode({ '/': obj })), { '/': obj })
+        same(decode(encode({ '/': { bytes: obj } })), { '/': { bytes: obj } })
+      }
+    })
+
+    it('allow specials within reserved space', () => {
+      // can we put slash-objects within slashes?
+      same(decode(encode({ '/': bytes.fromString('asdf') })), { '/': bytes.fromString('asdf') })
+      same(new TextDecoder().decode(encode({ '/': bytes.fromString('asdf') })), '{"/":{"/":{"bytes":"YXNkZg"}}}')
+      same(decode(encode({ '/': link })), { '/': link })
+      same(new TextDecoder().decode(encode({ '/': link })), '{"/":{"/":"bafyreifepiu23okq5zuyvyhsoiazv2icw2van3s7ko6d3ixl5jx2yj2yhu"}}')
+    })
+
+    it('disallow extraneous tokens', () => {
+      // encode() shouldn't allow this but it currently does
+      // https://github.com/ipld/js-dag-json/issues/91 should change this test
+      // into two parts, encode and decode
+      assert.throws(() => decode(encode({ '/': link.toString(), x: 'bip' })))
+      assert.throws(() => decode(encode({ '/': { bytes: 'mS7ldeA', x: 'bip' } })))
+      assert.throws(() => decode(encode({ '/': { bytes: 'mS7ldeA' }, x: 'bip' })))
+      assert.throws(() => decode(encode({ '/': { bytes: 'mS7ldeA', x: 'bip' }, bop: 'bip' })))
+    })
+  })
+
+  it('native types', () => {
+    const flip = (/** @type {any} */ obj) => decode(encode(obj))
+    same(flip('test'), 'test')
+    same(flip(null), null)
+    same(flip(12), 12)
+    same(flip(-1), -1)
+    same(flip(1.2), 1.2)
+    same(flip(true), true)
+    same(flip(false), false)
+    same(flip([]), [])
+    same(flip(['asdf']), ['asdf'])
+    same(decode(utf8Encode('10.0')), 10)
+    same(decode(utf8Encode('[-10.0, 1.0, 0.0, 100.0]')), [-10, 1, 0, 100])
+  })
+
+  it('stable map key sorting', () => {
+    const s1 = bytes.toString(encode({ a: 1, b: 2, bb: 2.2, c: 3, c_: 3.3 }))
+    const s2 = bytes.toString(encode({ c_: 3.3, bb: 2.2, b: 2, c: 3, a: 1 }))
+    same('{"a":1,"b":2,"bb":2.2,"c":3,"c_":3.3}', s1)
+    same('{"a":1,"b":2,"bb":2.2,"c":3,"c_":3.3}', s2)
+  })
+
+  it('bigints', () => {
+    const verify = (/** @type {number | bigint} **/ inp) => {
+      assert.strictEqual(decode(utf8Encode(String(inp))), inp)
+    }
+
+    // plain Number objects
+    verify(0)
+    verify(1)
+    verify(-1)
+    verify(Math.pow(2, 50))
+    verify(-Math.pow(2, 50))
+    verify(Number.MAX_SAFE_INTEGER)
+    verify(-Number.MAX_SAFE_INTEGER)
+    // should round-trip as BigInts
+    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
+  })
+
+  it('error on circular references', () => {
+    const circularObj = {}
+    circularObj.a = circularObj
+    assert.throws(() => encode(circularObj), /object contains circular references/)
+    const circularArr = [circularObj]
+    circularObj.a = circularArr
+    assert.throws(() => encode(circularArr), /object contains circular references/)
+  })
+
+  it('error on encoding undefined', () => {
+    assert.throws(() => encode(undefined), /\Wundefined\W.*not supported/)
+    const objWithUndefined = { a: 'a', b: undefined }
+    assert.throws(() => encode(objWithUndefined), /\Wundefined\W.*not supported/)
+  })
+
+  it('error on encoding IEEE 754 specials', () => {
+    for (const special of [NaN, Infinity, -Infinity]) {
+      assert.throws(() => encode(special), new RegExp(`\\W${String(special)}\\W.*not supported`))
+      const objWithSpecial = { a: 'a', b: special }
+      assert.throws(() => encode(objWithSpecial), new RegExp(`\\W${String(special)}\\W.*not supported`))
+      const arrWithSpecial = [1, 1.1, -1, -1.1, Number.MAX_SAFE_INTEGER, special, Number.MIN_SAFE_INTEGER]
+      assert.throws(() => encode(arrWithSpecial), new RegExp(`\\W${String(special)}\\W.*not supported`))
+    }
+  })
+
+  it('fuzz serialize and deserialize with garbage', function () {
+    // filter out fuzz garbage for objects that are disqualified by DAG-JSON rules
+    /** @type {(obj: any) => boolean} */
+    const checkObj = (obj) => {
+      if (Array.isArray(obj)) {
+        return obj.every(checkObj)
+      }
+      if (obj && typeof obj === 'object') {
+        for (const [key, value] of Object.entries(obj)) {
+          if (key === '/') {
+            if (typeof value === 'string') {
+              return false
+            }
+            if (value && typeof value === 'object' && value.bytes !== undefined) {
+              return false
+            }
+          }
+          if (!checkObj(value)) {
+            return false
+          }
+        }
+      }
+      return true
+    }
+
+    this.timeout(5000)
+    for (let ii = 0; ii < 1000; ii++) {
+      const original = garbage(300)
+      if (!checkObj(original)) {
+        continue
+      }
+      const encoded = encode(original)
+      const decoded = decode(encoded)
+      same(decoded, original)
+    }
+  })
+
+  it('serialize', () => {
+    same(stringify({ hello: 'world' }), JSON.stringify({ hello: 'world' }))
+
+    const input = { link, bytes: bytes.fromString('asdf'), n: null, o: {} }
+    same(stringify(input), JSON.stringify({
+      bytes: { '/': { bytes: base64.baseEncode(input.bytes) } },
+      link: { '/': link.toString() },
+      n: null,
+      o: {}
+    }))
+
+    const output = parse(stringify(input))
+    same(input, output)
+    same(bytes.isBinary(output.bytes), true)
+    same(CID.asCID(output.link), output.link)
+  })
+
+  describe('typed arrays', () => {
+    // This mirrors what ships by default in dag-cbor: https://github.com/rvagg/cborg/blob/968fdac4af22c9b22fe5b40c2a6f9bb855780a4a/test/test-2bytes.js#L121
+    // It's an open question whether this should slip by without error or not,
+    // for now we silently convert them to plain bytes and they all round trip
+    // as Uint8Arrays.
+    const cases = /** @type {{obj: ArrayBufferView, expected: string}[]} */([
+      {
+        obj: Uint8Array.from([1, 2, 3]),
+        expected: '{"/":{"bytes":"AQID"}}'
+      },
+      {
+        obj: Uint8ClampedArray.from([1, 2, 3]),
+        expected: '{"/":{"bytes":"AQID"}}'
+      },
+      {
+        obj: Uint16Array.from([1, 2, 3]),
+        expected: '{"/":{"bytes":"AQACAAMA"}}'
+      },
+      {
+        obj: Uint32Array.from([1, 2, 3]),
+        expected: '{"/":{"bytes":"AQAAAAIAAAADAAAA"}}'
+      },
+      {
+        obj: Int8Array.from([1, 2, -3]),
+        expected: '{"/":{"bytes":"AQL9"}}'
+      },
+      {
+        obj: Int16Array.from([1, 2, -3]),
+        expected: '{"/":{"bytes":"AQACAP3/"}}'
+      },
+      {
+        obj: Int32Array.from([1, 2, -3]),
+        expected: '{"/":{"bytes":"AQAAAAIAAAD9////"}}'
+      },
+      {
+        obj: Float32Array.from([1, 2, -3]),
+        expected: '{"/":{"bytes":"AACAPwAAAEAAAEDA"}}'
+      },
+      {
+        obj: Float64Array.from([1, 2, -3]),
+        expected: '{"/":{"bytes":"AAAAAAAA8D8AAAAAAAAAQAAAAAAAAAjA"}}'
+      },
+      {
+        obj: BigUint64Array.from([BigInt(1), BigInt(2), BigInt(3)]),
+        expected: '{"/":{"bytes":"AQAAAAAAAAACAAAAAAAAAAMAAAAAAAAA"}}'
+      },
+      {
+        obj: BigInt64Array.from([BigInt(1), BigInt(2), BigInt(-3)]),
+        expected: '{"/":{"bytes":"AQAAAAAAAAACAAAAAAAAAP3/////////"}}'
+      },
+      {
+        obj: new DataView(Uint8Array.from([1, 2, 3]).buffer),
+        expected: '{"/":{"bytes":"AQID"}}'
+      },
+      {
+        obj: Uint8Array.from([1, 2, 3]).buffer,
+        expected: '{"/":{"bytes":"AQID"}}'
+      }
+    ])
+
+    for (const testCase of cases) {
+      it(testCase.obj.constructor.name, () => {
+        same(utf8Decode(encode(testCase.obj)), testCase.expected)
+        const decoded = decode(utf8Encode(testCase.expected))
+        assert.instanceOf(decoded, Uint8Array)
+        if (testCase.obj instanceof ArrayBuffer) {
+          same(decoded, new Uint8Array(testCase.obj))
+        } else {
+          same(decoded, new Uint8Array(testCase.obj.buffer, testCase.obj.byteOffset, testCase.obj.byteLength))
+        }
+      })
+    }
+  })
+
+  it('reject duplicate map keys', () => {
+    assert.throws(() => decode(utf8Encode('{"foo":1,"foo":2,"bar":3}')), /found repeat map key "foo"/)
+  })
+})
+
+/**
+ * @param {string} s
+ * @returns {Uint8Array}
+ */
+function utf8Encode (s) {
+  return new TextEncoder().encode(s)
+}
+
+/**
+ * @param {Uint8Array} b
+ * @returns {string}
+ */
+function utf8Decode (b) {
+  return new TextDecoder().decode(b)
+}

package/patched/@ipld/dag-json/test/ts-use/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "ts-use",
+  "private": true,
+  "dependencies": {
+    "@ipld/dag-json": "file:../../dist/",
+    "multiformats": "file:../../node_modules/multiformats"
+  },
+  "scripts": {
+    "test": "npm install && npx -p typescript tsc && node src/main.js"
+  }
+}

package/patched/@ipld/dag-json/test/ts-use/src/main.ts

@@ -0,0 +1,54 @@
+import { deepStrictEqual } from 'assert'
+
+import { BlockEncoder, BlockDecoder, BlockCodec } from 'multiformats/codecs/interface'
+import * as dagJson from '@ipld/dag-json'
+
+const main = () => {
+  // make sure we have a full CodecFeature
+  useCodecFeature(dagJson)
+}
+
+function useCodecFeature (codec: BlockCodec<297, any>) {
+  // use only as a BlockEncoder
+  useEncoder(codec)
+
+  // use only as a BlockDecoder
+  useDecoder(codec)
+
+  // use with ArrayBuffer input type
+  useDecoderWithArrayBuffer(codec)
+
+  // use as a full BlockCodec which does both BlockEncoder & BlockDecoder
+  useBlockCodec(codec)
+}
+
+function useEncoder<Codec extends number> (encoder: BlockEncoder<Codec, string>) {
+  deepStrictEqual(encoder.code, 297)
+  deepStrictEqual(encoder.name, 'dag-json')
+  deepStrictEqual(Array.from(encoder.encode('blip')), [34, 98, 108, 105, 112, 34])
+  console.log('[TS] ✓ { encoder: BlockEncoder }')
+}
+
+function useDecoder<Codec extends number> (decoder: BlockDecoder<Codec, Uint8Array>) {
+  deepStrictEqual(decoder.code, 297)
+  deepStrictEqual(decoder.decode(Uint8Array.from([34, 98, 108, 105, 112, 34 ])), 'blip')
+  console.log('[TS] ✓ { decoder: BlockDecoder }')
+}
+
+function useDecoderWithArrayBuffer<Codec extends number> (decoder: BlockDecoder<Codec, Uint8Array>) {
+  deepStrictEqual(decoder.code, 297)
+  deepStrictEqual(decoder.decode(Uint8Array.from([34, 98, 108, 105, 112, 34 ]).buffer), 'blip')
+  console.log('[TS] ✓ { decoder: BlockDecoder }')
+}
+
+function useBlockCodec<Codec extends number> (blockCodec: BlockCodec<Codec, string>) {
+  deepStrictEqual(blockCodec.code, 297)
+  deepStrictEqual(blockCodec.name, 'dag-json')
+  deepStrictEqual(Array.from(blockCodec.encode('blip')), [34, 98, 108, 105, 112, 34])
+  deepStrictEqual(blockCodec.decode(Uint8Array.from([34, 98, 108, 105, 112, 34])), 'blip')
+  console.log('[TS] ✓ {}:BlockCodec')
+}
+
+main()
+
+export default main

package/patched/@ipld/dag-json/test/ts-use/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "moduleResolution": "node",
+    "noImplicitAny": true,
+    "skipLibCheck": false,
+    "incremental": true
+  }
+}

package/patched/@ipld/dag-json/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "aegir/src/config/tsconfig.aegir.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "emitDeclarationOnly": true
+  },
+  "include": [
+    "src",
+    "test"
+  ],
+  "exclude": [
+    "test/ts-use"
+  ]
+}

package/patched/cborg/.github/dependabot.yml

@@ -0,0 +1,16 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'daily'
+    commit-message:
+      prefix: 'chore'
+      include: 'scope'
+  - package-ecosystem: 'npm'
+    directory: '/'
+    schedule:
+      interval: 'daily'
+    commit-message:
+      prefix: 'chore'
+      include: 'scope'