@fireproof/vendor 1.0.4 → 1.1.0-dev

package/src/@ipld/car/src/buffer-decoder.js

@@ -1,213 +0,0 @@
-import { decode as decodeDagCbor } from "@fireproof/vendor/@ipld/dag-cbor"
-import { CID } from 'multiformats/cid'
-import * as Digest from 'multiformats/hashes/digest'
-import { CIDV0_BYTES, decodeV2Header, decodeVarint, getMultihashLength, V2_HEADER_LENGTH } from './decoder-common.js'
-import { CarV1HeaderOrV2Pragma } from './header-validator.js'
-
-/**
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').BlockHeader} BlockHeader
- * @typedef {import('./api').BlockIndex} BlockIndex
- * @typedef {import('./coding').BytesBufferReader} BytesBufferReader
- * @typedef {import('./coding').CarHeader} CarHeader
- * @typedef {import('./coding').CarV2Header} CarV2Header
- * @typedef {import('./coding').CarV2FixedHeader} CarV2FixedHeader
- */
-
-/**
- * Reads header data from a `BytesReader`. The header may either be in the form
- * of a `CarHeader` or `CarV2Header` depending on the CAR being read.
- *
- * @name decoder.readHeader(reader)
- * @param {BytesBufferReader} reader
- * @param {number} [strictVersion]
- * @returns {CarHeader | CarV2Header}
- */
-export function readHeader (reader, strictVersion) {
-  const length = decodeVarint(reader.upTo(8), reader)
-  if (length === 0) {
-    throw new Error('Invalid CAR header (zero length)')
-  }
-  const header = reader.exactly(length, true)
-  const block = decodeDagCbor(header)
-  if (CarV1HeaderOrV2Pragma.toTyped(block) === undefined) {
-    throw new Error('Invalid CAR header format')
-  }
-  if ((block.version !== 1 && block.version !== 2) || (strictVersion !== undefined && block.version !== strictVersion)) {
-    throw new Error(`Invalid CAR version: ${block.version}${strictVersion !== undefined ? ` (expected ${strictVersion})` : ''}`)
-  }
-  if (block.version === 1) {
-    // CarV1HeaderOrV2Pragma makes roots optional, let's make it mandatory
-    if (!Array.isArray(block.roots)) {
-      throw new Error('Invalid CAR header format')
-    }
-    return block
-  }
-  // version 2
-  if (block.roots !== undefined) {
-    throw new Error('Invalid CAR header format')
-  }
-  const v2Header = decodeV2Header(reader.exactly(V2_HEADER_LENGTH, true))
-  reader.seek(v2Header.dataOffset - reader.pos)
-  const v1Header = readHeader(reader, 1)
-  return Object.assign(v1Header, v2Header)
-}
-
-/**
- * Reads CID sync
- *
- * @param {BytesBufferReader} reader
- * @returns {CID}
- */
-function readCid (reader) {
-  const first = reader.exactly(2, false)
-  if (first[0] === CIDV0_BYTES.SHA2_256 && first[1] === CIDV0_BYTES.LENGTH) {
-    // cidv0 32-byte sha2-256
-    const bytes = reader.exactly(34, true)
-    const multihash = Digest.decode(bytes)
-    return CID.create(0, CIDV0_BYTES.DAG_PB, multihash)
-  }
-
-  const version = decodeVarint(reader.upTo(8), reader)
-  if (version !== 1) {
-    throw new Error(`Unexpected CID version (${version})`)
-  }
-  const codec = decodeVarint(reader.upTo(8), reader)
-  const bytes = reader.exactly(getMultihashLength(reader.upTo(8)), true)
-  const multihash = Digest.decode(bytes)
-  return CID.create(version, codec, multihash)
-}
-
-/**
- * Reads the leading data of an individual block from CAR data from a
- * `BytesBufferReader`. Returns a `BlockHeader` object which contains
- * `{ cid, length, blockLength }` which can be used to either index the block
- * or read the block binary data.
- *
- * @name async decoder.readBlockHead(reader)
- * @param {BytesBufferReader} reader
- * @returns {BlockHeader}
- */
-export function readBlockHead (reader) {
-  // length includes a CID + Binary, where CID has a variable length
-  // we have to deal with
-  const start = reader.pos
-  let length = decodeVarint(reader.upTo(8), reader)
-  if (length === 0) {
-    throw new Error('Invalid CAR section (zero length)')
-  }
-  length += (reader.pos - start)
-  const cid = readCid(reader)
-  const blockLength = length - Number(reader.pos - start) // subtract CID length
-
-  return { cid, length, blockLength }
-}
-
-/**
- * Returns Car header and blocks from a Uint8Array
- *
- * @param {Uint8Array} bytes
- * @returns {{ header : CarHeader | CarV2Header , blocks: Block[]}}
- */
-export function fromBytes (bytes) {
-  let reader = bytesReader(bytes)
-  const header = readHeader(reader)
-  if (header.version === 2) {
-    const v1length = reader.pos - header.dataOffset
-    reader = limitReader(reader, header.dataSize - v1length)
-  }
-
-  const blocks = []
-  while (reader.upTo(8).length > 0) {
-    const { cid, blockLength } = readBlockHead(reader)
-
-    blocks.push({ cid, bytes: reader.exactly(blockLength, true) })
-  }
-
-  return {
-    header, blocks
-  }
-}
-
-/**
- * Creates a `BytesBufferReader` from a `Uint8Array`.
- *
- * @name decoder.bytesReader(bytes)
- * @param {Uint8Array} bytes
- * @returns {BytesBufferReader}
- */
-export function bytesReader (bytes) {
-  let pos = 0
-
-  /** @type {BytesBufferReader} */
-  return {
-    upTo (length) {
-      return bytes.subarray(pos, pos + Math.min(length, bytes.length - pos))
-    },
-
-    exactly (length, seek = false) {
-      if (length > bytes.length - pos) {
-        throw new Error('Unexpected end of data')
-      }
-
-      const out = bytes.subarray(pos, pos + length)
-      if (seek) {
-        pos += length
-      }
-      return out
-    },
-
-    seek (length) {
-      pos += length
-    },
-
-    get pos () {
-      return pos
-    }
-  }
-}
-
-/**
- * Wraps a `BytesBufferReader` in a limiting `BytesBufferReader` which limits maximum read
- * to `byteLimit` bytes. It _does not_ update `pos` of the original
- * `BytesBufferReader`.
- *
- * @name decoder.limitReader(reader, byteLimit)
- * @param {BytesBufferReader} reader
- * @param {number} byteLimit
- * @returns {BytesBufferReader}
- */
-export function limitReader (reader, byteLimit) {
-  let bytesRead = 0
-
-  /** @type {BytesBufferReader} */
-  return {
-    upTo (length) {
-      let bytes = reader.upTo(length)
-      if (bytes.length + bytesRead > byteLimit) {
-        bytes = bytes.subarray(0, byteLimit - bytesRead)
-      }
-      return bytes
-    },
-
-    exactly (length, seek = false) {
-      const bytes = reader.exactly(length, seek)
-      if (bytes.length + bytesRead > byteLimit) {
-        throw new Error('Unexpected end of data')
-      }
-      if (seek) {
-        bytesRead += length
-      }
-      return bytes
-    },
-
-    seek (length) {
-      bytesRead += length
-      reader.seek(length)
-    },
-
-    get pos () {
-      return reader.pos
-    }
-  }
-}

package/src/@ipld/car/src/buffer-reader-browser.js

@@ -1,144 +0,0 @@
-import * as BufferDecoder from './buffer-decoder.js'
-
-/**
- * @typedef {import('multiformats').CID} CID
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').CarBufferReader} ICarBufferReader
- * @typedef {import('./coding').CarHeader} CarHeader
- * @typedef {import('./coding').CarV2Header} CarV2Header
- */
-
-/**
- * Provides blockstore-like access to a CAR.
- *
- * Implements the `RootsBufferReader` interface:
- * {@link ICarBufferReader.getRoots `getRoots()`}. And the `BlockBufferReader` interface:
- * {@link ICarBufferReader.get `get()`}, {@link ICarBufferReader.has `has()`},
- * {@link ICarBufferReader.blocks `blocks()`} and
- * {@link ICarBufferReader.cids `cids()`}.
- *
- * Load this class with either `import { CarBufferReader } from '@ipld/car/buffer-reader'`
- * (`const { CarBufferReader } = require('@ipld/car/buffer-reader')`). Or
- * `import { CarBufferReader } from '@ipld/car'` (`const { CarBufferReader } = require('@ipld/car')`).
- * The former will likely result in smaller bundle sizes where this is
- * important.
- *
- * @name CarBufferReader
- * @class
- * @implements {ICarBufferReader}
- * @property {number} version The version number of the CAR referenced by this
- * reader (should be `1` or `2`).
- */
-export class CarBufferReader {
-  /**
-   * @constructs CarBufferReader
-   * @param {CarHeader|CarV2Header} header
-   * @param {Block[]} blocks
-   */
-  constructor (header, blocks) {
-    this._header = header
-    this._blocks = blocks
-    this._cids = undefined
-  }
-
-  /**
-   * @property version
-   * @memberof CarBufferReader
-   * @instance
-   */
-  get version () {
-    return this._header.version
-  }
-
-  /**
-   * Get the list of roots defined by the CAR referenced by this reader. May be
-   * zero or more `CID`s.
-   *
-   * @function
-   * @memberof CarBufferReader
-   * @instance
-   * @returns {CID[]}
-   */
-  getRoots () {
-    return this._header.roots
-  }
-
-  /**
-   * Check whether a given `CID` exists within the CAR referenced by this
-   * reader.
-   *
-   * @function
-   * @memberof CarBufferReader
-   * @instance
-   * @param {CID} key
-   * @returns {boolean}
-   */
-  has (key) {
-    return this._blocks.some(b => b.cid.equals(key))
-  }
-
-  /**
-   * Fetch a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) from the CAR
-   * referenced by this reader matching the provided `CID`. In the case where
-   * the provided `CID` doesn't exist within the CAR, `undefined` will be
-   * returned.
-   *
-   * @function
-   * @memberof CarBufferReader
-   * @instance
-   * @param {CID} key
-   * @returns {Block | undefined}
-   */
-  get (key) {
-    return this._blocks.find(b => b.cid.equals(key))
-  }
-
-  /**
-   * Returns a `Block[]` of the `Block`s (`{ cid:CID, bytes:Uint8Array }` pairs) contained within
-   * the CAR referenced by this reader.
-   *
-   * @function
-   * @memberof CarBufferReader
-   * @instance
-   * @returns {Block[]}
-   */
-  blocks () {
-    return this._blocks
-  }
-
-  /**
-   * Returns a `CID[]` of the `CID`s contained within the CAR referenced by this reader.
-   *
-   * @function
-   * @memberof CarBufferReader
-   * @instance
-   * @returns {CID[]}
-   */
-  cids () {
-    if (!this._cids) {
-      this._cids = this._blocks.map(b => b.cid)
-    }
-    return this._cids
-  }
-
-  /**
-   * Instantiate a {@link CarBufferReader} from a `Uint8Array` blob. This performs a
-   * decode fully in memory and maintains the decoded state in memory for full
-   * access to the data via the `CarReader` API.
-   *
-   * @static
-   * @memberof CarBufferReader
-   * @param {Uint8Array} bytes
-   * @returns {CarBufferReader}
-   */
-  static fromBytes (bytes) {
-    if (!(bytes instanceof Uint8Array)) {
-      throw new TypeError('fromBytes() requires a Uint8Array')
-    }
-
-    const { header, blocks } = BufferDecoder.fromBytes(bytes)
-    return new CarBufferReader(header, blocks)
-  }
-}
-
-export const __browser = true

package/src/@ipld/car/src/buffer-reader.js

@@ -1,51 +0,0 @@
-import fs from 'fs'
-import { CarBufferReader as BrowserCarBufferReader } from './buffer-reader-browser.js'
-
-/**
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').BlockIndex} BlockIndex
- * @typedef {import('./api').CarBufferReader} ICarBufferReader
- */
-
-const fsread = fs.readSync
-
-/**
- * @class
- * @implements {ICarBufferReader}
- */
-export class CarBufferReader extends BrowserCarBufferReader {
-  /**
-   * Reads a block directly from a file descriptor for an open CAR file. This
-   * function is **only available in Node.js** and not a browser environment.
-   *
-   * This function can be used in connection with {@link CarIndexer} which emits
-   * the `BlockIndex` objects that are required by this function.
-   *
-   * The user is responsible for opening and closing the file used in this call.
-   *
-   * @static
-   * @memberof CarBufferReader
-   * @param {number} fd - A file descriptor from the
-   * Node.js `fs` module. An integer, from `fs.open()`.
-   * @param {BlockIndex} blockIndex - An index pointing to the location of the
-   * Block required. This `BlockIndex` should take the form:
-   * `{cid:CID, blockLength:number, blockOffset:number}`.
-   * @returns {Block} A `{ cid:CID, bytes:Uint8Array }` pair.
-   */
-  static readRaw (fd, blockIndex) {
-    const { cid, blockLength, blockOffset } = blockIndex
-    const bytes = new Uint8Array(blockLength)
-    let read
-    if (typeof fd === 'number') {
-      read = fsread(fd, bytes, 0, blockLength, blockOffset)
-    } else {
-      throw new TypeError('Bad fd')
-    }
-    if (read !== blockLength) {
-      throw new Error(`Failed to read entire block (${read} instead of ${blockLength})`)
-    }
-    return { cid, bytes }
-  }
-}
-
-export const __browser = false

package/src/@ipld/car/src/buffer-writer.js

@@ -1,286 +0,0 @@
-import * as CBOR from "@fireproof/vendor/@ipld/dag-cbor"
-import { Token, Type } from "@fireproof/vendor/cborg"
-import { tokensToLength } from "@fireproof/vendor/cborg/length"
-import varint from 'varint'
-
-/**
- * @typedef {import('./api').CID} CID
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').CarBufferWriter} Writer
- * @typedef {import('./api').CarBufferWriterOptions} Options
- * @typedef {import('./coding').CarEncoder} CarEncoder
- */
-
-/**
- * A simple CAR writer that writes to a pre-allocated buffer.
- *
- * @class
- * @name CarBufferWriter
- * @implements {Writer}
- */
-class CarBufferWriter {
-  /**
-   * @param {Uint8Array} bytes
-   * @param {number} headerSize
-   */
-  constructor (bytes, headerSize) {
-    /** @readonly */
-    this.bytes = bytes
-    this.byteOffset = headerSize
-
-    /**
-     * @readonly
-     * @type {CID[]}
-     */
-    this.roots = []
-    this.headerSize = headerSize
-  }
-
-  /**
-   * Add a root to this writer, to be used to create a header when the CAR is
-   * finalized with {@link CarBufferWriter.close `close()`}
-   *
-   * @param {CID} root
-   * @param {{resize?:boolean}} [options]
-   * @returns {CarBufferWriter}
-   */
-  addRoot (root, options) {
-    addRoot(this, root, options)
-    return this
-  }
-
-  /**
-   * Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
-   * Throws if there is not enough capacity.
-   *
-   * @param {Block} block - A `{ cid:CID, bytes:Uint8Array }` pair.
-   * @returns {CarBufferWriter}
-   */
-  write (block) {
-    addBlock(this, block)
-    return this
-  }
-
-  /**
-   * Finalize the CAR and return it as a `Uint8Array`.
-   *
-   * @param {object} [options]
-   * @param {boolean} [options.resize]
-   * @returns {Uint8Array}
-   */
-  close (options) {
-    return close(this, options)
-  }
-}
-
-/**
- * @param {CarBufferWriter} writer
- * @param {CID} root
- * @param {{resize?:boolean}} [options]
- */
-export const addRoot = (writer, root, options = {}) => {
-  const { resize = false } = options
-  const { bytes, headerSize, byteOffset, roots } = writer
-  writer.roots.push(root)
-  const size = headerLength(writer)
-  // If there is not enough space for the new root
-  if (size > headerSize) {
-    // Check if we root would fit if we were to resize the head.
-    if (size - headerSize + byteOffset < bytes.byteLength) {
-      // If resize is enabled resize head
-      if (resize) {
-        resizeHeader(writer, size)
-      // otherwise remove head and throw an error suggesting to resize
-      } else {
-        roots.pop()
-        throw new RangeError(`Header of size ${headerSize} has no capacity for new root ${root}.
-  However there is a space in the buffer and you could call addRoot(root, { resize: root }) to resize header to make a space for this root.`)
-      }
-    // If head would not fit even with resize pop new root and throw error
-    } else {
-      roots.pop()
-      throw new RangeError(`Buffer has no capacity for a new root ${root}`)
-    }
-  }
-}
-
-/**
- * Calculates number of bytes required for storing given block in CAR. Useful in
- * estimating size of an `ArrayBuffer` for the `CarBufferWriter`.
- *
- * @name CarBufferWriter.blockLength(Block)
- * @param {Block} block
- * @returns {number}
- */
-export const blockLength = ({ cid, bytes }) => {
-  const size = cid.bytes.byteLength + bytes.byteLength
-  return varint.encodingLength(size) + size
-}
-
-/**
- * @param {CarBufferWriter} writer
- * @param {Block} block
- */
-export const addBlock = (writer, { cid, bytes }) => {
-  const byteLength = cid.bytes.byteLength + bytes.byteLength
-  const size = varint.encode(byteLength)
-  if (writer.byteOffset + size.length + byteLength > writer.bytes.byteLength) {
-    throw new RangeError('Buffer has no capacity for this block')
-  } else {
-    writeBytes(writer, size)
-    writeBytes(writer, cid.bytes)
-    writeBytes(writer, bytes)
-  }
-}
-
-/**
- * @param {CarBufferWriter} writer
- * @param {object} [options]
- * @param {boolean} [options.resize]
- */
-export const close = (writer, options = {}) => {
-  const { resize = false } = options
-  const { roots, bytes, byteOffset, headerSize } = writer
-
-  const headerBytes = CBOR.encode({ version: 1, roots })
-  const varintBytes = varint.encode(headerBytes.length)
-
-  const size = varintBytes.length + headerBytes.byteLength
-  const offset = headerSize - size
-
-  // If header size estimate was accurate we just write header and return
-  // view into buffer.
-  if (offset === 0) {
-    writeHeader(writer, varintBytes, headerBytes)
-    return bytes.subarray(0, byteOffset)
-    // If header was overestimated and `{resize: true}` is passed resize header
-  } else if (resize) {
-    resizeHeader(writer, size)
-    writeHeader(writer, varintBytes, headerBytes)
-    return bytes.subarray(0, writer.byteOffset)
-  } else {
-    throw new RangeError(`Header size was overestimated.
-You can use close({ resize: true }) to resize header`)
-  }
-}
-
-/**
- * @param {CarBufferWriter} writer
- * @param {number} byteLength
- */
-export const resizeHeader = (writer, byteLength) => {
-  const { bytes, headerSize } = writer
-  // Move data section to a new offset
-  bytes.set(bytes.subarray(headerSize, writer.byteOffset), byteLength)
-  // Update header size & byteOffset
-  writer.byteOffset += byteLength - headerSize
-  writer.headerSize = byteLength
-}
-
-/**
- * @param {CarBufferWriter} writer
- * @param {number[]|Uint8Array} bytes
- */
-
-const writeBytes = (writer, bytes) => {
-  writer.bytes.set(bytes, writer.byteOffset)
-  writer.byteOffset += bytes.length
-}
-/**
- * @param {{bytes:Uint8Array}} writer
- * @param {number[]} varint
- * @param {Uint8Array} header
- */
-const writeHeader = ({ bytes }, varint, header) => {
-  bytes.set(varint)
-  bytes.set(header, varint.length)
-}
-
-const headerPreludeTokens = [
-  new Token(Type.map, 2),
-  new Token(Type.string, 'version'),
-  new Token(Type.uint, 1),
-  new Token(Type.string, 'roots')
-]
-
-const CID_TAG = new Token(Type.tag, 42)
-
-/**
- * Calculates header size given the array of byteLength for roots.
- *
- * @name CarBufferWriter.calculateHeaderLength(rootLengths)
- * @param {number[]} rootLengths
- * @returns {number}
- */
-export const calculateHeaderLength = (rootLengths) => {
-  const tokens = [...headerPreludeTokens]
-  tokens.push(new Token(Type.array, rootLengths.length))
-  for (const rootLength of rootLengths) {
-    tokens.push(CID_TAG)
-    tokens.push(new Token(Type.bytes, { length: rootLength + 1 }))
-  }
-  const length = tokensToLength(tokens) // no options needed here because we have simple tokens
-  return varint.encodingLength(length) + length
-}
-
-/**
- * Calculates header size given the array of roots.
- *
- * @name CarBufferWriter.headerLength({ roots })
- * @param {object} options
- * @param {CID[]} options.roots
- * @returns {number}
- */
-export const headerLength = ({ roots }) =>
-  calculateHeaderLength(roots.map(cid => cid.bytes.byteLength))
-
-/**
- * Estimates header size given a count of the roots and the expected byte length
- * of the root CIDs. The default length works for a standard CIDv1 with a
- * single-byte multihash code, such as SHA2-256 (i.e. the most common CIDv1).
- *
- * @name CarBufferWriter.estimateHeaderLength(rootCount[, rootByteLength])
- * @param {number} rootCount
- * @param {number} [rootByteLength]
- * @returns {number}
- */
-export const estimateHeaderLength = (rootCount, rootByteLength = 36) =>
-  calculateHeaderLength(new Array(rootCount).fill(rootByteLength))
-
-/**
- * Creates synchronous CAR writer that can be used to encode blocks into a given
- * buffer. Optionally you could pass `byteOffset` and `byteLength` to specify a
- * range inside buffer to write into. If car file is going to have `roots` you
- * need to either pass them under `options.roots` (from which header size will
- * be calculated) or provide `options.headerSize` to allocate required space
- * in the buffer. You may also provide known `roots` and `headerSize` to
- * allocate space for the roots that may not be known ahead of time.
- *
- * Note: Incorrect `headerSize` may lead to copying bytes inside a buffer
- * which will have a negative impact on performance.
- *
- * @name CarBufferWriter.createWriter(buffer[, options])
- * @param {ArrayBuffer} buffer
- * @param {object} [options]
- * @param {CID[]} [options.roots]
- * @param {number} [options.byteOffset]
- * @param {number} [options.byteLength]
- * @param {number} [options.headerSize]
- * @returns {CarBufferWriter}
- */
-export const createWriter = (buffer, options = {}) => {
-  const {
-    roots = [],
-    byteOffset = 0,
-    byteLength = buffer.byteLength,
-    headerSize = headerLength({ roots })
-  } = options
-  const bytes = new Uint8Array(buffer, byteOffset, byteLength)
-
-  const writer = new CarBufferWriter(bytes, headerSize)
-  for (const root of roots) {
-    writer.addRoot(root)
-  }
-
-  return writer
-}