@fireproof/vendor 0.0.0-smoke → 1.0.0

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

@@ -1,291 +0,0 @@
-/* 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

@@ -1,290 +0,0 @@
-/* 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

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

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

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

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

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

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