@fireproof/vendor 0.0.0-smoke → 0.22.0-dev-preview

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

@@ -1,173 +0,0 @@
-{
-  "name": "@ipld/dag-json",
-  "version": "10.2.3",
-  "description": "JS implementation of DAG-JSON",
-  "author": "Rod <rod@vagg.org> (http://r.va.gg/)",
-  "license": "Apache-2.0 OR MIT",
-  "homepage": "https://github.com/ipld/js-dag-json#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ipld/js-dag-json.git"
-  },
-  "bugs": {
-    "url": "https://github.com/ipld/js-dag-json/issues"
-  },
-  "keywords": [
-    "ipfs",
-    "ipld",
-    "multiformats"
-  ],
-  "engines": {
-    "node": ">=16.0.0",
-    "npm": ">=7.0.0"
-  },
-  "type": "module",
-  "types": "./dist/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "*": [
-        "*",
-        "dist/*",
-        "dist/src/*",
-        "dist/src/*/index"
-      ],
-      "src/*": [
-        "*",
-        "dist/*",
-        "dist/src/*",
-        "dist/src/*/index"
-      ]
-    }
-  },
-  "files": [
-    "src",
-    "dist",
-    "!dist/test",
-    "!**/*.tsbuildinfo"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./src/index.js"
-    }
-  },
-  "eslintConfig": {
-    "extends": "ipfs",
-    "parserOptions": {
-      "sourceType": "module"
-    },
-    "ignorePatterns": [
-      "test/ts-use"
-    ]
-  },
-  "release": {
-    "branches": [
-      "master"
-    ],
-    "plugins": [
-      [
-        "@semantic-release/commit-analyzer",
-        {
-          "preset": "conventionalcommits",
-          "releaseRules": [
-            {
-              "breaking": true,
-              "release": "major"
-            },
-            {
-              "revert": true,
-              "release": "patch"
-            },
-            {
-              "type": "feat",
-              "release": "minor"
-            },
-            {
-              "type": "fix",
-              "release": "patch"
-            },
-            {
-              "type": "docs",
-              "release": "patch"
-            },
-            {
-              "type": "test",
-              "release": "patch"
-            },
-            {
-              "type": "deps",
-              "release": "patch"
-            },
-            {
-              "scope": "no-release",
-              "release": false
-            }
-          ]
-        }
-      ],
-      [
-        "@semantic-release/release-notes-generator",
-        {
-          "preset": "conventionalcommits",
-          "presetConfig": {
-            "types": [
-              {
-                "type": "feat",
-                "section": "Features"
-              },
-              {
-                "type": "fix",
-                "section": "Bug Fixes"
-              },
-              {
-                "type": "chore",
-                "section": "Trivial Changes"
-              },
-              {
-                "type": "docs",
-                "section": "Documentation"
-              },
-              {
-                "type": "deps",
-                "section": "Dependencies"
-              },
-              {
-                "type": "test",
-                "section": "Tests"
-              }
-            ]
-          }
-        }
-      ],
-      "@semantic-release/changelog",
-      "@semantic-release/npm",
-      "@semantic-release/github",
-      "@semantic-release/git"
-    ]
-  },
-  "scripts": {
-    "clean": "aegir clean",
-    "lint": "aegir lint",
-    "build": "aegir build",
-    "release": "aegir release",
-    "test": "npm run lint && aegir test",
-    "test:ts": "npm run test --prefix test/ts-use",
-    "test:node": "aegir test -t node --cov",
-    "test:chrome": "aegir test -t browser --cov",
-    "test:chrome-webworker": "aegir test -t webworker",
-    "test:firefox": "aegir test -t browser -- --browser firefox",
-    "test:firefox-webworker": "aegir test -t webworker -- --browser firefox",
-    "test:electron-main": "aegir test -t electron-main",
-    "dep-check": "aegir dep-check"
-  },
-  "dependencies": {
-    "cborg": "^4.0.0",
-    "multiformats": "^13.1.0"
-  },
-  "devDependencies": {
-    "@ipld/garbage": "^6.0.0",
-    "aegir": "^45.0.7",
-    "eslint-config-ipfs": "^7.0.6",
-    "eslint-plugin-n": "^17.14.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()