@ipld/car 4.1.5 → 5.0.0

package/cjs/car-browser.js

@@ -1,18 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var readerBrowser = require('./lib/reader-browser.js');
-var indexer = require('./lib/indexer.js');
-var iterator = require('./lib/iterator.js');
-var writerBrowser = require('./lib/writer-browser.js');
-var indexedReaderBrowser = require('./lib/indexed-reader-browser.js');
-
-
-
-exports.CarReader = readerBrowser.CarReader;
-exports.CarIndexer = indexer.CarIndexer;
-exports.CarBlockIterator = iterator.CarBlockIterator;
-exports.CarCIDIterator = iterator.CarCIDIterator;
-exports.CarWriter = writerBrowser.CarWriter;
-exports.CarIndexedReader = indexedReaderBrowser.CarIndexedReader;

package/cjs/car.js

@@ -1,20 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var reader = require('./lib/reader.js');
-var indexer = require('./lib/indexer.js');
-var iterator = require('./lib/iterator.js');
-var writer = require('./lib/writer.js');
-var indexedReader = require('./lib/indexed-reader.js');
-var bufferWriter = require('./lib/buffer-writer.js');
-
-
-
-exports.CarReader = reader.CarReader;
-exports.CarIndexer = indexer.CarIndexer;
-exports.CarBlockIterator = iterator.CarBlockIterator;
-exports.CarCIDIterator = iterator.CarCIDIterator;
-exports.CarWriter = writer.CarWriter;
-exports.CarIndexedReader = indexedReader.CarIndexedReader;
-exports.CarBufferWriter = bufferWriter;

package/cjs/lib/buffer-writer.js

@@ -1,164 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var varint = require('varint');
-var cborg = require('cborg');
-var length = require('cborg/length');
-var CBOR = require('@ipld/dag-cbor');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
-var CBOR__namespace = /*#__PURE__*/_interopNamespace(CBOR);
-
-class CarBufferWriter {
-  constructor(bytes, headerSize) {
-    this.bytes = bytes;
-    this.byteOffset = headerSize;
-    this.roots = [];
-    this.headerSize = headerSize;
-  }
-  addRoot(root, options) {
-    addRoot(this, root, options);
-    return this;
-  }
-  write(block) {
-    addBlock(this, block);
-    return this;
-  }
-  close(options) {
-    return close(this, options);
-  }
-}
-const addRoot = (writer, root, options = {}) => {
-  const {
-    resize = false
-  } = options;
-  const {bytes, headerSize, byteOffset, roots} = writer;
-  writer.roots.push(root);
-  const size = headerLength(writer);
-  if (size > headerSize) {
-    if (size - headerSize + byteOffset < bytes.byteLength) {
-      if (resize) {
-        resizeHeader(writer, size);
-      } 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.`);
-      }
-    } else {
-      roots.pop();
-      throw new RangeError(`Buffer has no capacity for a new root ${ root }`);
-    }
-  }
-};
-const blockLength = ({cid, bytes}) => {
-  const size = cid.bytes.byteLength + bytes.byteLength;
-  return varint__default["default"].encodingLength(size) + size;
-};
-const addBlock = (writer, {cid, bytes}) => {
-  const byteLength = cid.bytes.byteLength + bytes.byteLength;
-  const size = varint__default["default"].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);
-  }
-};
-const close = (writer, options = {}) => {
-  const {
-    resize = false
-  } = options;
-  const {roots, bytes, byteOffset, headerSize} = writer;
-  const headerBytes = CBOR__namespace.encode({
-    version: 1,
-    roots
-  });
-  const varintBytes = varint__default["default"].encode(headerBytes.length);
-  const size = varintBytes.length + headerBytes.byteLength;
-  const offset = headerSize - size;
-  if (offset === 0) {
-    writeHeader(writer, varintBytes, headerBytes);
-    return bytes.subarray(0, byteOffset);
-  } 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`);
-  }
-};
-const resizeHeader = (writer, byteLength) => {
-  const {bytes, headerSize} = writer;
-  bytes.set(bytes.subarray(headerSize, writer.byteOffset), byteLength);
-  writer.byteOffset += byteLength - headerSize;
-  writer.headerSize = byteLength;
-};
-const writeBytes = (writer, bytes) => {
-  writer.bytes.set(bytes, writer.byteOffset);
-  writer.byteOffset += bytes.length;
-};
-const writeHeader = ({bytes}, varint, header) => {
-  bytes.set(varint);
-  bytes.set(header, varint.length);
-};
-const headerPreludeTokens = [
-  new cborg.Token(cborg.Type.map, 2),
-  new cborg.Token(cborg.Type.string, 'version'),
-  new cborg.Token(cborg.Type.uint, 1),
-  new cborg.Token(cborg.Type.string, 'roots')
-];
-const CID_TAG = new cborg.Token(cborg.Type.tag, 42);
-const calculateHeaderLength = rootLengths => {
-  const tokens = [...headerPreludeTokens];
-  tokens.push(new cborg.Token(cborg.Type.array, rootLengths.length));
-  for (const rootLength of rootLengths) {
-    tokens.push(CID_TAG);
-    tokens.push(new cborg.Token(cborg.Type.bytes, { length: rootLength + 1 }));
-  }
-  const length$1 = length.tokensToLength(tokens);
-  return varint__default["default"].encodingLength(length$1) + length$1;
-};
-const headerLength = ({roots}) => calculateHeaderLength(roots.map(cid => cid.bytes.byteLength));
-const estimateHeaderLength = (rootCount, rootByteLength = 36) => calculateHeaderLength(new Array(rootCount).fill(rootByteLength));
-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;
-};
-
-exports.addBlock = addBlock;
-exports.addRoot = addRoot;
-exports.blockLength = blockLength;
-exports.calculateHeaderLength = calculateHeaderLength;
-exports.close = close;
-exports.createWriter = createWriter;
-exports.estimateHeaderLength = estimateHeaderLength;
-exports.headerLength = headerLength;
-exports.resizeHeader = resizeHeader;

package/cjs/lib/decoder.js

@@ -1,301 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var varint = require('varint');
-var cid = require('multiformats/cid');
-var Digest = require('multiformats/hashes/digest');
-var CBOR = require('@ipld/dag-cbor');
-var headerValidator = require('./header-validator.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
-var Digest__namespace = /*#__PURE__*/_interopNamespace(Digest);
-
-const CIDV0_BYTES = {
-  SHA2_256: 18,
-  LENGTH: 32,
-  DAG_PB: 112
-};
-const V2_HEADER_LENGTH = 16 + 8 + 8 + 8;
-async function readVarint(reader) {
-  const bytes = await reader.upTo(8);
-  if (!bytes.length) {
-    throw new Error('Unexpected end of data');
-  }
-  const i = varint__default["default"].decode(bytes);
-  reader.seek(varint__default["default"].decode.bytes);
-  return i;
-}
-async function readV2Header(reader) {
-  const bytes = await reader.exactly(V2_HEADER_LENGTH);
-  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  let offset = 0;
-  const header = {
-    version: 2,
-    characteristics: [
-      dv.getBigUint64(offset, true),
-      dv.getBigUint64(offset += 8, true)
-    ],
-    dataOffset: Number(dv.getBigUint64(offset += 8, true)),
-    dataSize: Number(dv.getBigUint64(offset += 8, true)),
-    indexOffset: Number(dv.getBigUint64(offset += 8, true))
-  };
-  reader.seek(V2_HEADER_LENGTH);
-  return header;
-}
-async function readHeader(reader, strictVersion) {
-  const length = await readVarint(reader);
-  if (length === 0) {
-    throw new Error('Invalid CAR header (zero length)');
-  }
-  const header = await reader.exactly(length);
-  reader.seek(length);
-  const block = CBOR.decode(header);
-  if (!headerValidator.CarHeader(block)) {
-    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 })` : '' }`);
-  }
-  const hasRoots = Array.isArray(block.roots);
-  if (block.version === 1 && !hasRoots || block.version === 2 && hasRoots) {
-    throw new Error('Invalid CAR header format');
-  }
-  if (block.version === 1) {
-    return block;
-  }
-  const v2Header = await readV2Header(reader);
-  reader.seek(v2Header.dataOffset - reader.pos);
-  const v1Header = await readHeader(reader, 1);
-  return Object.assign(v1Header, v2Header);
-}
-async function readMultihash(reader) {
-  const bytes = await reader.upTo(8);
-  varint__default["default"].decode(bytes);
-  const codeLength = varint__default["default"].decode.bytes;
-  const length = varint__default["default"].decode(bytes.subarray(varint__default["default"].decode.bytes));
-  const lengthLength = varint__default["default"].decode.bytes;
-  const mhLength = codeLength + lengthLength + length;
-  const multihash = await reader.exactly(mhLength);
-  reader.seek(mhLength);
-  return multihash;
-}
-async function readCid(reader) {
-  const first = await reader.exactly(2);
-  if (first[0] === CIDV0_BYTES.SHA2_256 && first[1] === CIDV0_BYTES.LENGTH) {
-    const bytes = await reader.exactly(34);
-    reader.seek(34);
-    const multihash = Digest__namespace.decode(bytes);
-    return cid.CID.create(0, CIDV0_BYTES.DAG_PB, multihash);
-  }
-  const version = await readVarint(reader);
-  if (version !== 1) {
-    throw new Error(`Unexpected CID version (${ version })`);
-  }
-  const codec = await readVarint(reader);
-  const bytes = await readMultihash(reader);
-  const multihash = Digest__namespace.decode(bytes);
-  return cid.CID.create(version, codec, multihash);
-}
-async function readBlockHead(reader) {
-  const start = reader.pos;
-  let length = await readVarint(reader);
-  if (length === 0) {
-    throw new Error('Invalid CAR section (zero length)');
-  }
-  length += reader.pos - start;
-  const cid = await readCid(reader);
-  const blockLength = length - Number(reader.pos - start);
-  return {
-    cid,
-    length,
-    blockLength
-  };
-}
-async function readBlock(reader) {
-  const {cid, blockLength} = await readBlockHead(reader);
-  const bytes = await reader.exactly(blockLength);
-  reader.seek(blockLength);
-  return {
-    bytes,
-    cid
-  };
-}
-async function readBlockIndex(reader) {
-  const offset = reader.pos;
-  const {cid, length, blockLength} = await readBlockHead(reader);
-  const index = {
-    cid,
-    length,
-    blockLength,
-    offset,
-    blockOffset: reader.pos
-  };
-  reader.seek(index.blockLength);
-  return index;
-}
-function createDecoder(reader) {
-  const headerPromise = (async () => {
-    const header = await readHeader(reader);
-    if (header.version === 2) {
-      const v1length = reader.pos - header.dataOffset;
-      reader = limitReader(reader, header.dataSize - v1length);
-    }
-    return header;
-  })();
-  return {
-    header: () => headerPromise,
-    async *blocks() {
-      await headerPromise;
-      while ((await reader.upTo(8)).length > 0) {
-        yield await readBlock(reader);
-      }
-    },
-    async *blocksIndex() {
-      await headerPromise;
-      while ((await reader.upTo(8)).length > 0) {
-        yield await readBlockIndex(reader);
-      }
-    }
-  };
-}
-function bytesReader(bytes) {
-  let pos = 0;
-  return {
-    async upTo(length) {
-      return bytes.subarray(pos, pos + Math.min(length, bytes.length - pos));
-    },
-    async exactly(length) {
-      if (length > bytes.length - pos) {
-        throw new Error('Unexpected end of data');
-      }
-      return bytes.subarray(pos, pos + length);
-    },
-    seek(length) {
-      pos += length;
-    },
-    get pos() {
-      return pos;
-    }
-  };
-}
-function chunkReader(readChunk) {
-  let pos = 0;
-  let have = 0;
-  let offset = 0;
-  let currentChunk = new Uint8Array(0);
-  const read = async length => {
-    have = currentChunk.length - offset;
-    const bufa = [currentChunk.subarray(offset)];
-    while (have < length) {
-      const chunk = await readChunk();
-      if (chunk == null) {
-        break;
-      }
-      if (have < 0) {
-        if (chunk.length > have) {
-          bufa.push(chunk.subarray(-have));
-        }
-      } else {
-        bufa.push(chunk);
-      }
-      have += chunk.length;
-    }
-    currentChunk = new Uint8Array(bufa.reduce((p, c) => p + c.length, 0));
-    let off = 0;
-    for (const b of bufa) {
-      currentChunk.set(b, off);
-      off += b.length;
-    }
-    offset = 0;
-  };
-  return {
-    async upTo(length) {
-      if (currentChunk.length - offset < length) {
-        await read(length);
-      }
-      return currentChunk.subarray(offset, offset + Math.min(currentChunk.length - offset, length));
-    },
-    async exactly(length) {
-      if (currentChunk.length - offset < length) {
-        await read(length);
-      }
-      if (currentChunk.length - offset < length) {
-        throw new Error('Unexpected end of data');
-      }
-      return currentChunk.subarray(offset, offset + length);
-    },
-    seek(length) {
-      pos += length;
-      offset += length;
-    },
-    get pos() {
-      return pos;
-    }
-  };
-}
-function asyncIterableReader(asyncIterable) {
-  const iterator = asyncIterable[Symbol.asyncIterator]();
-  async function readChunk() {
-    const next = await iterator.next();
-    if (next.done) {
-      return null;
-    }
-    return next.value;
-  }
-  return chunkReader(readChunk);
-}
-function limitReader(reader, byteLimit) {
-  let bytesRead = 0;
-  return {
-    async upTo(length) {
-      let bytes = await reader.upTo(length);
-      if (bytes.length + bytesRead > byteLimit) {
-        bytes = bytes.subarray(0, byteLimit - bytesRead);
-      }
-      return bytes;
-    },
-    async exactly(length) {
-      const bytes = await reader.exactly(length);
-      if (bytes.length + bytesRead > byteLimit) {
-        throw new Error('Unexpected end of data');
-      }
-      return bytes;
-    },
-    seek(length) {
-      bytesRead += length;
-      reader.seek(length);
-    },
-    get pos() {
-      return reader.pos;
-    }
-  };
-}
-
-exports.asyncIterableReader = asyncIterableReader;
-exports.bytesReader = bytesReader;
-exports.chunkReader = chunkReader;
-exports.createDecoder = createDecoder;
-exports.limitReader = limitReader;
-exports.readBlockHead = readBlockHead;
-exports.readHeader = readHeader;

package/cjs/lib/encoder.js

@@ -1,44 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var varint = require('varint');
-var CBOR = require('@ipld/dag-cbor');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
-
-function createHeader(roots) {
-  const headerBytes = CBOR.encode({
-    version: 1,
-    roots
-  });
-  const varintBytes = varint__default["default"].encode(headerBytes.length);
-  const header = new Uint8Array(varintBytes.length + headerBytes.length);
-  header.set(varintBytes, 0);
-  header.set(headerBytes, varintBytes.length);
-  return header;
-}
-function createEncoder(writer) {
-  return {
-    async setRoots(roots) {
-      const bytes = createHeader(roots);
-      await writer.write(bytes);
-    },
-    async writeBlock(block) {
-      const {cid, bytes} = block;
-      await writer.write(new Uint8Array(varint__default["default"].encode(cid.bytes.length + bytes.length)));
-      await writer.write(cid.bytes);
-      if (bytes.length) {
-        await writer.write(bytes);
-      }
-    },
-    async close() {
-      await writer.end();
-    }
-  };
-}
-
-exports.createEncoder = createEncoder;
-exports.createHeader = createHeader;

package/cjs/lib/header-validator.js

@@ -1,29 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const Kinds = {
-  Null: obj => obj === null,
-  Int: obj => Number.isInteger(obj),
-  Float: obj => typeof obj === 'number' && Number.isFinite(obj),
-  String: obj => typeof obj === 'string',
-  Bool: obj => typeof obj === 'boolean',
-  Bytes: obj => obj instanceof Uint8Array,
-  Link: obj => !Kinds.Null(obj) && typeof obj === 'object' && obj.asCID === obj,
-  List: obj => Array.isArray(obj),
-  Map: obj => !Kinds.Null(obj) && typeof obj === 'object' && obj.asCID !== obj && !Kinds.List(obj) && !Kinds.Bytes(obj)
-};
-const Types = {
-  Int: Kinds.Int,
-  'CarHeader > version': obj => Types.Int(obj),
-  'CarHeader > roots (anon) > valueType (anon)': Kinds.Link,
-  'CarHeader > roots (anon)': obj => Kinds.List(obj) && Array.prototype.every.call(obj, Types['CarHeader > roots (anon) > valueType (anon)']),
-  'CarHeader > roots': obj => Types['CarHeader > roots (anon)'](obj),
-  CarHeader: obj => {
-    const keys = obj && Object.keys(obj);
-    return Kinds.Map(obj) && ['version'].every(k => keys.includes(k)) && Object.entries(obj).every(([name, value]) => Types['CarHeader > ' + name] && Types['CarHeader > ' + name](value));
-  }
-};
-const CarHeader = Types.CarHeader;
-
-exports.CarHeader = CarHeader;

package/cjs/lib/indexed-reader-browser.js

@@ -1,13 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-class CarIndexedReader {
-  static async fromFile() {
-    throw new Error('Unsupported in this environment');
-  }
-}
-const __browser = true;
-
-exports.CarIndexedReader = CarIndexedReader;
-exports.__browser = __browser;

package/cjs/lib/indexed-reader.js

@@ -1,90 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var fs = require('fs');
-var stream = require('stream');
-var cid = require('multiformats/cid');
-var indexer = require('./indexer.js');
-var reader = require('./reader.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-
-class CarIndexedReader {
-  constructor(version, path, roots, index, order) {
-    this._version = version;
-    this._path = path;
-    this._roots = roots;
-    this._index = index;
-    this._order = order;
-    this._fd = null;
-  }
-  get version() {
-    return this._version;
-  }
-  async getRoots() {
-    return this._roots;
-  }
-  async has(key) {
-    return this._index.has(key.toString());
-  }
-  async get(key) {
-    const blockIndex = this._index.get(key.toString());
-    if (!blockIndex) {
-      return undefined;
-    }
-    if (!this._fd) {
-      this._fd = await fs__default["default"].promises.open(this._path, 'r');
-    }
-    const readIndex = {
-      cid: key,
-      length: 0,
-      offset: 0,
-      blockLength: blockIndex.blockLength,
-      blockOffset: blockIndex.blockOffset
-    };
-    return reader.CarReader.readRaw(this._fd, readIndex);
-  }
-  async *blocks() {
-    for (const cidStr of this._order) {
-      const block = await this.get(cid.CID.parse(cidStr));
-      if (!block) {
-        throw new Error('Unexpected internal error');
-      }
-      yield block;
-    }
-  }
-  async *cids() {
-    for (const cidStr of this._order) {
-      yield cid.CID.parse(cidStr);
-    }
-  }
-  async close() {
-    if (this._fd) {
-      return this._fd.close();
-    }
-  }
-  static async fromFile(path) {
-    if (typeof path !== 'string') {
-      throw new TypeError('fromFile() requires a file path string');
-    }
-    const iterable = await indexer.CarIndexer.fromIterable(stream.Readable.from(fs__default["default"].createReadStream(path)));
-    const index = new Map();
-    const order = [];
-    for await (const {cid, blockLength, blockOffset} of iterable) {
-      const cidStr = cid.toString();
-      index.set(cidStr, {
-        blockLength,
-        blockOffset
-      });
-      order.push(cidStr);
-    }
-    return new CarIndexedReader(iterable.version, path, await iterable.getRoots(), index, order);
-  }
-}
-const __browser = false;
-
-exports.CarIndexedReader = CarIndexedReader;
-exports.__browser = __browser;