@fireproof/vendor 1.1.0 → 1.2.0

package/src/@ipld/car/dist/src/decoder.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @typedef {import('./api').Block} Block
+ * @typedef {import('./api').BlockHeader} BlockHeader
+ * @typedef {import('./api').BlockIndex} BlockIndex
+ * @typedef {import('./coding').BytesReader} BytesReader
+ * @typedef {import('./coding').CarHeader} CarHeader
+ * @typedef {import('./coding').CarV2Header} CarV2Header
+ * @typedef {import('./coding').CarV2FixedHeader} CarV2FixedHeader
+ * @typedef {import('./coding').CarDecoder} CarDecoder
+ */
+/**
+ * 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 async decoder.readHeader(reader)
+ * @param {BytesReader} reader
+ * @param {number} [strictVersion]
+ * @returns {Promise<CarHeader|CarV2Header>}
+ */
+export function readHeader(reader: BytesReader, strictVersion?: number | undefined): Promise<CarHeader | CarV2Header>;
+/**
+ * Reads the leading data of an individual block from CAR data from a
+ * `BytesReader`. 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 {BytesReader} reader
+ * @returns {Promise<BlockHeader>}
+ */
+export function readBlockHead(reader: BytesReader): Promise<BlockHeader>;
+/**
+ * Creates a `CarDecoder` from a `BytesReader`. The `CarDecoder` is as async
+ * interface that will consume the bytes from the `BytesReader` to yield a
+ * `header()` and either `blocks()` or `blocksIndex()` data.
+ *
+ * @name decoder.createDecoder(reader)
+ * @param {BytesReader} reader
+ * @returns {CarDecoder}
+ */
+export function createDecoder(reader: BytesReader): CarDecoder;
+/**
+ * Creates a `BytesReader` from a `Uint8Array`.
+ *
+ * @name decoder.bytesReader(bytes)
+ * @param {Uint8Array} bytes
+ * @returns {BytesReader}
+ */
+export function bytesReader(bytes: Uint8Array): BytesReader;
+/**
+ * @ignore
+ * reusable reader for streams and files, we just need a way to read an
+ * additional chunk (of some undetermined size) and a way to close the
+ * reader when finished
+ * @param {() => Promise<Uint8Array|null>} readChunk
+ * @returns {BytesReader}
+ */
+export function chunkReader(readChunk: () => Promise<Uint8Array | null>): BytesReader;
+/**
+ * Creates a `BytesReader` from an `AsyncIterable<Uint8Array>`, which allows for
+ * consumption of CAR data from a streaming source.
+ *
+ * @name decoder.asyncIterableReader(asyncIterable)
+ * @param {AsyncIterable<Uint8Array>} asyncIterable
+ * @returns {BytesReader}
+ */
+export function asyncIterableReader(asyncIterable: AsyncIterable<Uint8Array>): BytesReader;
+/**
+ * Wraps a `BytesReader` in a limiting `BytesReader` which limits maximum read
+ * to `byteLimit` bytes. It _does not_ update `pos` of the original
+ * `BytesReader`.
+ *
+ * @name decoder.limitReader(reader, byteLimit)
+ * @param {BytesReader} reader
+ * @param {number} byteLimit
+ * @returns {BytesReader}
+ */
+export function limitReader(reader: BytesReader, byteLimit: number): BytesReader;
+export type Block = import('./api').Block;
+export type BlockHeader = import('./api').BlockHeader;
+export type BlockIndex = import('./api').BlockIndex;
+export type BytesReader = import('./coding').BytesReader;
+export type CarHeader = import('./coding').CarHeader;
+export type CarV2Header = import('./coding').CarV2Header;
+export type CarV2FixedHeader = import('./coding').CarV2FixedHeader;
+export type CarDecoder = import('./coding').CarDecoder;
+//# sourceMappingURL=decoder.d.ts.map

package/src/@ipld/car/dist/src/decoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../src/decoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AAEH;;;;;;;;GAQG;AACH,mCAJW,WAAW,uCAET,QAAQ,SAAS,GAAC,WAAW,CAAC,CA8B1C;AAyBD;;;;;;;;;GASG;AACH,sCAHW,WAAW,GACT,QAAQ,WAAW,CAAC,CAehC;AAwBD;;;;;;;;GAQG;AACH,sCAHW,WAAW,GACT,UAAU,CA6BtB;AAED;;;;;;GAMG;AACH,mCAHW,UAAU,GACR,WAAW,CA+BvB;AAED;;;;;;;GAOG;AACH,uCAHW,MAAM,QAAQ,UAAU,GAAC,IAAI,CAAC,GAC5B,WAAW,CAuEvB;AAED;;;;;;;GAOG;AACH,mDAHW,cAAc,UAAU,CAAC,GACvB,WAAW,CAcvB;AAED;;;;;;;;;GASG;AACH,oCAJW,WAAW,aACX,MAAM,GACJ,WAAW,CAmCvB;oBAnVY,OAAO,OAAO,EAAE,KAAK;0BACrB,OAAO,OAAO,EAAE,WAAW;yBAC3B,OAAO,OAAO,EAAE,UAAU;0BAC1B,OAAO,UAAU,EAAE,WAAW;wBAC9B,OAAO,UAAU,EAAE,SAAS;0BAC5B,OAAO,UAAU,EAAE,WAAW;+BAC9B,OAAO,UAAU,EAAE,gBAAgB;yBACnC,OAAO,UAAU,EAAE,UAAU"}

package/src/@ipld/car/dist/src/encoder.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Create a header from an array of roots.
+ *
+ * @param {CID[]} roots
+ * @returns {Uint8Array}
+ */
+export function createHeader(roots: CID[]): Uint8Array;
+export type CID = import('multiformats').CID;
+export type Block = import('./api').Block;
+export type CarEncoder = import('./coding').CarEncoder;
+export type IteratorChannel_Writer = import('./coding').IteratorChannel_Writer<Uint8Array>;
+/**
+ * @param {IteratorChannel_Writer} writer
+ * @returns {CarEncoder}
+ */
+export function createEncoder(writer: import("./coding").IteratorChannel_Writer<Uint8Array>): CarEncoder;
+//# sourceMappingURL=encoder.d.ts.map

package/src/@ipld/car/dist/src/encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../src/encoder.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,oCAHW,GAAG,EAAE,GACH,UAAU,CAStB;kBArBY,OAAO,cAAc,EAAE,GAAG;oBAC1B,OAAO,OAAO,EAAE,KAAK;yBACrB,OAAO,UAAU,EAAE,UAAU;qCAC7B,OAAO,UAAU,EAAE,sBAAsB,CAAC,UAAU,CAAC;AAoBlE;;;GAGG;AACH,8FAFa,UAAU,CA4CtB"}

package/src/@ipld/car/dist/src/header-validator.d.ts

@@ -0,0 +1,5 @@
+export namespace CarV1HeaderOrV2Pragma {
+    function toTyped(obj: any): any;
+    function toRepresentation(obj: any): any;
+}
+//# sourceMappingURL=header-validator.d.ts.map

package/src/@ipld/car/dist/src/header-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-validator.d.ts","sourceRoot":"","sources":["../../src/header-validator.js"],"names":[],"mappings":";IAkC4B,gCAAwB;IAwFxB,yCAAwB"}

package/src/@ipld/car/dist/src/index-browser.d.ts

@@ -0,0 +1,10 @@
+import { CarReader } from './reader-browser.js';
+import { CarIndexer } from './indexer.js';
+import { CarBlockIterator } from './iterator.js';
+import { CarCIDIterator } from './iterator.js';
+import { CarWriter } from './writer-browser.js';
+import { CarIndexedReader } from './indexed-reader-browser.js';
+import { CarBufferReader } from './buffer-reader.js';
+import * as CarBufferWriter from './buffer-writer.js';
+export { CarReader, CarIndexer, CarBlockIterator, CarCIDIterator, CarWriter, CarIndexedReader, CarBufferReader, CarBufferWriter };
+//# sourceMappingURL=index-browser.d.ts.map

package/src/@ipld/car/dist/src/index-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-browser.d.ts","sourceRoot":"","sources":["../../src/index-browser.js"],"names":[],"mappings":"0BAK0B,qBAAqB;2BAFpB,cAAc;iCACQ,eAAe;+BAAf,eAAe;0BAEtC,qBAAqB;iCAJd,6BAA6B;gCAF9B,oBAAoB;iCACnB,oBAAoB"}

package/src/@ipld/car/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+export const contentType: "application/vnd.ipld.car";
+import { CarReader } from './reader.js';
+import { CarBufferReader } from './buffer-reader.js';
+import { CarIndexer } from './indexer.js';
+import { CarBlockIterator } from './iterator.js';
+import { CarCIDIterator } from './iterator.js';
+import { CarWriter } from './writer.js';
+import { CarIndexedReader } from './indexed-reader.js';
+import * as CarBufferWriter from './buffer-writer.js';
+export { CarReader, CarBufferReader, CarIndexer, CarBlockIterator, CarCIDIterator, CarWriter, CarIndexedReader, CarBufferWriter };
+//# sourceMappingURL=index.d.ts.map

package/src/@ipld/car/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":"AASA,qDAAqD;0BAJ3B,aAAa;gCALP,oBAAoB;2BAGzB,cAAc;iCACQ,eAAe;+BAAf,eAAe;0BAEtC,aAAa;iCAJN,qBAAqB;iCADrB,oBAAoB"}

package/src/@ipld/car/dist/src/indexed-reader-browser.d.ts

@@ -0,0 +1,5 @@
+export class CarIndexedReader {
+    static fromFile(): Promise<void>;
+}
+export const __browser: true;
+//# sourceMappingURL=indexed-reader-browser.d.ts.map

package/src/@ipld/car/dist/src/indexed-reader-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexed-reader-browser.d.ts","sourceRoot":"","sources":["../../src/indexed-reader-browser.js"],"names":[],"mappings":"AAAA;IACE,iCAEC;CACF;AAED,6BAA6B"}

package/src/@ipld/car/dist/src/indexed-reader.d.ts

@@ -0,0 +1,152 @@
+/// <reference types="node" />
+/**
+ * @typedef {import('fs').promises.FileHandle} FileHandle
+ * @typedef {import('./api').Block} Block
+ * @typedef {import('./api').BlockIndex} BlockIndex
+ * @typedef {import('./api').CarReader} CarReaderIface
+ * @typedef {import('./reader-browser').CarReader} CarReader
+ * @typedef {{ blockLength:number, blockOffset:number }} RawLocation
+ */
+/**
+ * A form of {@link CarReader} that pre-indexes a CAR archive from a file and
+ * provides random access to blocks within the file using the index data. This
+ * function is **only available in Node.js** and not a browser environment.
+ *
+ * For large CAR files, using this form of `CarReader` can be singificantly more
+ * efficient in terms of memory. The index consists of a list of `CID`s and
+ * their location within the archive (see {@link CarIndexer}). For large numbers
+ * of blocks, this index can also occupy a significant amount of memory. In some
+ * cases it may be necessary to expand the memory capacity of a Node.js instance
+ * to allow this index to fit. (e.g. by running with
+ * `NODE_OPTIONS="--max-old-space-size=16384"`).
+ *
+ * As an `CarIndexedReader` instance maintains an open file descriptor for its
+ * CAR file, an additional {@link CarReader#close} method is attached. This
+ * _must_ be called to have full clean-up of resources after use.
+ *
+ * Load this class with either
+ * `import { CarIndexedReader } from '@ipld/car/indexed-reader'`
+ * (`const { CarIndexedReader } = require('@ipld/car/indexed-reader')`). Or
+ * `import { CarIndexedReader } from '@ipld/car'`
+ * (`const { CarIndexedReader } = require('@ipld/car')`). The former will likely
+ * result in smaller bundle sizes where this is important.
+ *
+ * @name CarIndexedReader
+ * @class
+ * @implements {CarReaderIface}
+ * @extends {CarReader}
+ * @property {number} version The version number of the CAR referenced by this
+ * reader (should be `1`).
+ */
+export class CarIndexedReader implements CarReaderIface {
+    /**
+     * Instantiate an {@link CarIndexedReader} from a file with the provided
+     * `path`. The CAR file is first indexed with a full path that collects `CID`s
+     * and block locations. This index is maintained in memory. Subsequent reads
+     * operate on a read-only file descriptor, fetching the block from its in-file
+     * location.
+     *
+     * For large archives, the initial indexing may take some time. The returned
+     * `Promise` will resolve only after this is complete.
+     *
+     * @async
+     * @static
+     * @memberof CarIndexedReader
+     * @param {string} path
+     * @returns {Promise<CarIndexedReader>}
+     */
+    static fromFile(path: string): Promise<CarIndexedReader>;
+    /**
+     * @param {number} version
+     * @param {string} path
+     * @param {CID[]} roots
+     * @param {Map<string, RawLocation>} index
+     * @param {string[]} order
+     */
+    constructor(version: number, path: string, roots: CID[], index: Map<string, RawLocation>, order: string[]);
+    _version: number;
+    _path: string;
+    _roots: CID<any, number, number, import("multiformats/cid").Version>[];
+    _index: Map<string, RawLocation>;
+    _order: string[];
+    _fd: fs.promises.FileHandle | null;
+    get version(): number;
+    /**
+     * See {@link CarReader#getRoots}
+     *
+     * @function
+     * @memberof CarIndexedReader
+     * @instance
+     * @async
+     * @returns {Promise<CID[]>}
+     */
+    getRoots(): Promise<CID[]>;
+    /**
+     * See {@link CarReader#has}
+     *
+     * @function
+     * @memberof CarIndexedReader
+     * @instance
+     * @async
+     * @param {CID} key
+     * @returns {Promise<boolean>}
+     */
+    has(key: CID): Promise<boolean>;
+    /**
+     * See {@link CarReader#get}
+     *
+     * @function
+     * @memberof CarIndexedReader
+     * @instance
+     * @async
+     * @param {CID} key
+     * @returns {Promise<Block | undefined>}
+     */
+    get(key: CID): Promise<Block | undefined>;
+    /**
+     * See {@link CarReader#blocks}
+     *
+     * @function
+     * @memberof CarIndexedReader
+     * @instance
+     * @async
+     * @generator
+     * @returns {AsyncGenerator<Block>}
+     */
+    blocks(): AsyncGenerator<Block>;
+    /**
+     * See {@link CarReader#cids}
+     *
+     * @function
+     * @memberof CarIndexedReader
+     * @instance
+     * @async
+     * @generator
+     * @returns {AsyncGenerator<CID>}
+     */
+    cids(): AsyncGenerator<CID>;
+    /**
+     * Close the underlying file descriptor maintained by this `CarIndexedReader`.
+     * This must be called for proper resource clean-up to occur.
+     *
+     * @function
+     * @memberof CarIndexedReader
+     * @instance
+     * @async
+     * @returns {Promise<void>}
+     */
+    close(): Promise<void>;
+}
+export const __browser: false;
+export type FileHandle = import('fs').promises.FileHandle;
+export type Block = import('./api').Block;
+export type BlockIndex = import('./api').BlockIndex;
+export type CarReaderIface = import('./api').CarReader;
+export type CarReader = import('./reader-browser').CarReader;
+export type RawLocation = {
+    blockLength: number;
+    blockOffset: number;
+};
+import { CID } from 'multiformats/cid';
+import fs from 'fs';
+//# sourceMappingURL=indexed-reader.d.ts.map

package/src/@ipld/car/dist/src/indexed-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexed-reader.d.ts","sourceRoot":"","sources":["../../src/indexed-reader.js"],"names":[],"mappings":";AAMA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAiIE;;;;;;;;;;;;;;;OAeG;IACH,sBAHW,MAAM,GACJ,QAAQ,gBAAgB,CAAC,CAkBrC;IAhKD;;;;;;OAMG;IACH,qBANW,MAAM,QACN,MAAM,SACN,GAAG,EAAE,SACL,IAAI,MAAM,EAAE,WAAW,CAAC,SACxB,MAAM,EAAE,EASlB;IANC,iBAAuB;IACvB,cAAiB;IACjB,uEAAmB;IACnB,iCAAmB;IACnB,iBAAmB;IACnB,mCAAe;IAGjB,sBAEC;IAED;;;;;;;;OAQG;IACH,YAFa,QAAQ,GAAG,EAAE,CAAC,CAI1B;IAED;;;;;;;;;OASG;IACH,SAHW,GAAG,GACD,QAAQ,OAAO,CAAC,CAI5B;IAED;;;;;;;;;OASG;IACH,SAHW,GAAG,GACD,QAAQ,KAAK,GAAG,SAAS,CAAC,CAkBtC;IAED;;;;;;;;;OASG;IACH,UAFa,eAAe,KAAK,CAAC,CAWjC;IAED;;;;;;;;;OASG;IACH,QAFa,eAAe,GAAG,CAAC,CAM/B;IAED;;;;;;;;;OASG;IACH,SAFa,QAAQ,IAAI,CAAC,CAMzB;CAmCF;AAED,8BAA8B;yBA3MjB,OAAO,IAAI,EAAE,QAAQ,CAAC,UAAU;oBAChC,OAAO,OAAO,EAAE,KAAK;yBACrB,OAAO,OAAO,EAAE,UAAU;6BAC1B,OAAO,OAAO,EAAE,SAAS;wBACzB,OAAO,kBAAkB,EAAE,SAAS;0BACpC;IAAE,WAAW,EAAC,MAAM,CAAC;IAAC,WAAW,EAAC,MAAM,CAAA;CAAE;oBAVnC,kBAAkB;eAFvB,IAAI"}

package/src/@ipld/car/dist/src/indexer.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @typedef {import('multiformats').CID} CID
+ * @typedef {import('./api').Block} Block
+ * @typedef {import('./api').RootsReader} RootsReader
+ * @typedef {import('./api').BlockIndex} BlockIndex
+ * @typedef {import('./coding').BytesReader} BytesReader
+ */
+/**
+ * Provides an iterator over all of the `Block`s in a CAR, returning their CIDs
+ * and byte-location information. Implements an `AsyncIterable<BlockIndex>`.
+ * Where a `BlockIndex` is a
+ * `{ cid:CID, length:number, offset:number, blockLength:number, blockOffset:number }`.
+ *
+ * As an implementer of `AsyncIterable`, this class can be used directly in a
+ * `for await (const blockIndex of iterator) {}` loop. Where the `iterator` is
+ * constructed using {@link CarIndexer.fromBytes} or
+ * {@link CarIndexer.fromIterable}.
+ *
+ * An iteration can only be performce _once_ per instantiation.
+ *
+ * `CarIndexer` also implements the `RootsReader` interface and provides
+ * the {@link CarIndexer.getRoots `getRoots()`} method.
+ *
+ * Load this class with either
+ * `import { CarIndexer } from '@ipld/car/indexer'`
+ * (`const { CarIndexer } = require('@ipld/car/indexer')`). Or
+ * `import { CarIndexer } from '@ipld/car'`
+ * (`const { CarIndexer } = require('@ipld/car')`). The former will likely
+ * result in smaller bundle sizes where this is important.
+ *
+ * @name CarIndexer
+ * @class
+ * @implements {RootsReader}
+ * @implements {AsyncIterable<BlockIndex>}
+ * @property {number} version The version number of the CAR referenced by this
+ * reader (should be `1`).
+ */
+export class CarIndexer implements RootsReader, AsyncIterable<BlockIndex> {
+    /**
+     * Instantiate a {@link CarIndexer} from a `Uint8Array` blob. Only the header
+     * is decoded initially, the remainder is processed and emitted via the
+     * iterator as it is consumed.
+     *
+     * @async
+     * @static
+     * @memberof CarIndexer
+     * @param {Uint8Array} bytes
+     * @returns {Promise<CarIndexer>}
+     */
+    static fromBytes(bytes: Uint8Array): Promise<CarIndexer>;
+    /**
+     * Instantiate a {@link CarIndexer} from a `AsyncIterable<Uint8Array>`,
+     * such as a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
+     * is decoded initially, the remainder is processed and emitted via the
+     * iterator as it is consumed.
+     *
+     * @async
+     * @static
+     * @memberof CarIndexer
+     * @param {AsyncIterable<Uint8Array>} asyncIterable
+     * @returns {Promise<CarIndexer>}
+     */
+    static fromIterable(asyncIterable: AsyncIterable<Uint8Array>): Promise<CarIndexer>;
+    /**
+     * @param {number} version
+     * @param {CID[]} roots
+     * @param {AsyncGenerator<BlockIndex>} iterator
+     */
+    constructor(version: number, roots: CID[], iterator: AsyncGenerator<BlockIndex>);
+    _version: number;
+    _roots: import("multiformats").CID<any, number, number, import("multiformats").Version>[];
+    _iterator: AsyncGenerator<import("./api").BlockIndex, any, any>;
+    get version(): number;
+    /**
+     * Get the list of roots defined by the CAR referenced by this indexer. May be
+     * zero or more `CID`s.
+     *
+     * @function
+     * @memberof CarIndexer
+     * @instance
+     * @async
+     * @returns {Promise<CID[]>}
+     */
+    getRoots(): Promise<CID[]>;
+    /**
+     * @returns {AsyncIterator<BlockIndex>}
+     */
+    [Symbol.asyncIterator](): AsyncIterator<BlockIndex>;
+}
+export type CID = import('multiformats').CID;
+export type Block = import('./api').Block;
+export type RootsReader = import('./api').RootsReader;
+export type BlockIndex = import('./api').BlockIndex;
+export type BytesReader = import('./coding').BytesReader;
+//# sourceMappingURL=indexer.d.ts.map

package/src/@ipld/car/dist/src/indexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexer.d.ts","sourceRoot":"","sources":["../../src/indexer.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,8DAJ8B,UAAU;IAyCtC;;;;;;;;;;OAUG;IACH,wBAHW,UAAU,GACR,QAAQ,UAAU,CAAC,CAO/B;IAED;;;;;;;;;;;OAWG;IACH,mCAHW,cAAc,UAAU,CAAC,GACvB,QAAQ,UAAU,CAAC,CAO/B;IAvED;;;;OAIG;IACH,qBAJW,MAAM,SACN,GAAG,EAAE,YACL,eAAe,UAAU,CAAC,EAMpC;IAHC,iBAAuB;IACvB,0FAAmB;IACnB,gEAAyB;IAG3B,sBAEC;IAED;;;;;;;;;OASG;IACH,YAFa,QAAQ,GAAG,EAAE,CAAC,CAI1B;IAED;;OAEG;IACH,0BAFa,cAAc,UAAU,CAAC,CAIrC;CAsCF;kBA9GY,OAAO,cAAc,EAAE,GAAG;oBAC1B,OAAO,OAAO,EAAE,KAAK;0BACrB,OAAO,OAAO,EAAE,WAAW;yBAC3B,OAAO,OAAO,EAAE,UAAU;0BAC1B,OAAO,UAAU,EAAE,WAAW"}

package/src/@ipld/car/dist/src/iterator-channel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @template {any} T
+ * @returns {IteratorChannel<T>}
+ */
+export function create<T extends unknown>(): import("./coding").IteratorChannel<T>;
+export type IteratorChannel<T extends unknown> = import('./coding').IteratorChannel<T>;
+//# sourceMappingURL=iterator-channel.d.ts.map

package/src/@ipld/car/dist/src/iterator-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterator-channel.d.ts","sourceRoot":"","sources":["../../src/iterator-channel.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,mFA+EC;iDAxFY,OAAO,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC"}

package/src/@ipld/car/dist/src/iterator.d.ts

@@ -0,0 +1,174 @@
+/**
+ * @typedef {import('multiformats').CID} CID
+ * @typedef {import('./api').Block} Block
+ * @typedef {import('./api').RootsReader} RootsReader
+ * @typedef {import('./coding').BytesReader} BytesReader
+ */
+/**
+ * @class
+ * @implements {RootsReader}
+ * @property {number} version The version number of the CAR referenced by this reader (should be `1`).
+ */
+export class CarIteratorBase implements RootsReader {
+    /**
+     * @param {number} version
+     * @param {CID[]} roots
+     * @param {AsyncIterable<Block>|void} iterable
+     */
+    constructor(version: number, roots: CID[], iterable: AsyncIterable<Block> | void);
+    _version: number;
+    _roots: import("multiformats").CID<any, number, number, import("multiformats").Version>[];
+    _iterable: void | AsyncIterable<import("./api").Block>;
+    _decoded: boolean;
+    get version(): number;
+    /**
+     * @returns {Promise<CID[]>}
+     */
+    getRoots(): Promise<CID[]>;
+}
+/**
+ * Provides an iterator over all of the `Block`s in a CAR. Implements a
+ * `BlockIterator` interface, or `AsyncIterable<Block>`. Where a `Block` is
+ * a `{ cid:CID, bytes:Uint8Array }` pair.
+ *
+ * As an implementer of `AsyncIterable`, this class can be used directly in a
+ * `for await (const block of iterator) {}` loop. Where the `iterator` is
+ * constructed using {@link CarBlockiterator.fromBytes} or
+ * {@link CarBlockiterator.fromIterable}.
+ *
+ * An iteration can only be performce _once_ per instantiation.
+ *
+ * `CarBlockIterator` also implements the `RootsReader` interface and provides
+ * the {@link CarBlockiterator.getRoots `getRoots()`} method.
+ *
+ * Load this class with either
+ * `import { CarBlockIterator } from '@ipld/car/iterator'`
+ * (`const { CarBlockIterator } = require('@ipld/car/iterator')`). Or
+ * `import { CarBlockIterator } from '@ipld/car'`
+ * (`const { CarBlockIterator } = require('@ipld/car')`).
+ *
+ * @name CarBlockIterator
+ * @class
+ * @implements {RootsReader}
+ * @implements {AsyncIterable<Block>}
+ * @property {number} version The version number of the CAR referenced by this
+ * iterator (should be `1`).
+ */
+export class CarBlockIterator extends CarIteratorBase implements RootsReader, AsyncIterable<Block> {
+    /**
+     * Instantiate a {@link CarBlockIterator} from a `Uint8Array` blob. Rather
+     * than decoding the entire byte array prior to returning the iterator, as in
+     * {@link CarReader.fromBytes}, only the header is decoded and the remainder
+     * of the CAR is parsed as the `Block`s as yielded.
+     *
+     * @async
+     * @static
+     * @memberof CarBlockIterator
+     * @param {Uint8Array} bytes
+     * @returns {Promise<CarBlockIterator>}
+     */
+    static fromBytes(bytes: Uint8Array): Promise<CarBlockIterator>;
+    /**
+     * Instantiate a {@link CarBlockIterator} from a `AsyncIterable<Uint8Array>`,
+     * such as a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
+     * Rather than decoding the entire byte array prior to returning the iterator,
+     * as in {@link CarReader.fromIterable}, only the header is decoded and the
+     * remainder of the CAR is parsed as the `Block`s as yielded.
+     *
+     * @async
+     * @static
+     * @param {AsyncIterable<Uint8Array>} asyncIterable
+     * @returns {Promise<CarBlockIterator>}
+     */
+    static fromIterable(asyncIterable: AsyncIterable<Uint8Array>): Promise<CarBlockIterator>;
+    /**
+     * Get the list of roots defined by the CAR referenced by this iterator. May be
+     * zero or more `CID`s.
+     *
+     * @function getRoots
+     * @memberof CarBlockIterator
+     * @instance
+     * @async
+     * @returns {Promise<CID[]>}
+     */
+    /**
+     * @returns {AsyncIterator<Block>}
+     */
+    [Symbol.asyncIterator](): AsyncIterator<Block>;
+}
+/**
+ * Provides an iterator over all of the `CID`s in a CAR. Implements a
+ * `CIDIterator` interface, or `AsyncIterable<CID>`. Similar to
+ * {@link CarBlockIterator} but only yields the CIDs in the CAR.
+ *
+ * As an implementer of `AsyncIterable`, this class can be used directly in a
+ * `for await (const cid of iterator) {}` loop. Where the `iterator` is
+ * constructed using {@link CarCIDiterator.fromBytes} or
+ * {@link CarCIDiterator.fromIterable}.
+ *
+ * An iteration can only be performce _once_ per instantiation.
+ *
+ * `CarCIDIterator` also implements the `RootsReader` interface and provides
+ * the {@link CarCIDiterator.getRoots `getRoots()`} method.
+ *
+ * Load this class with either
+ * `import { CarCIDIterator } from '@ipld/car/iterator'`
+ * (`const { CarCIDIterator } = require('@ipld/car/iterator')`). Or
+ * `import { CarCIDIterator } from '@ipld/car'`
+ * (`const { CarCIDIterator } = require('@ipld/car')`).
+ *
+ * @name CarCIDIterator
+ * @class
+ * @implements {RootsReader}
+ * @implements {AsyncIterable<CID>}
+ * @property {number} version The version number of the CAR referenced by this
+ * iterator (should be `1`).
+ */
+export class CarCIDIterator extends CarIteratorBase implements RootsReader, AsyncIterable<CID> {
+    /**
+     * Instantiate a {@link CarCIDIterator} from a `Uint8Array` blob. Rather
+     * than decoding the entire byte array prior to returning the iterator, as in
+     * {@link CarReader.fromBytes}, only the header is decoded and the remainder
+     * of the CAR is parsed as the `CID`s as yielded.
+     *
+     * @async
+     * @static
+     * @memberof CarCIDIterator
+     * @param {Uint8Array} bytes
+     * @returns {Promise<CarCIDIterator>}
+     */
+    static fromBytes(bytes: Uint8Array): Promise<CarCIDIterator>;
+    /**
+     * Instantiate a {@link CarCIDIterator} from a `AsyncIterable<Uint8Array>`,
+     * such as a [modern Node.js stream](https://nodejs.org/api/stream.html#stream_streams_compatibility_with_async_generators_and_async_iterators).
+     * Rather than decoding the entire byte array prior to returning the iterator,
+     * as in {@link CarReader.fromIterable}, only the header is decoded and the
+     * remainder of the CAR is parsed as the `CID`s as yielded.
+     *
+     * @async
+     * @static
+     * @memberof CarCIDIterator
+     * @param {AsyncIterable<Uint8Array>} asyncIterable
+     * @returns {Promise<CarCIDIterator>}
+     */
+    static fromIterable(asyncIterable: AsyncIterable<Uint8Array>): Promise<CarCIDIterator>;
+    /**
+     * Get the list of roots defined by the CAR referenced by this iterator. May be
+     * zero or more `CID`s.
+     *
+     * @function getRoots
+     * @memberof CarCIDIterator
+     * @instance
+     * @async
+     * @returns {Promise<CID[]>}
+     */
+    /**
+     * @returns {AsyncIterator<CID>}
+     */
+    [Symbol.asyncIterator](): AsyncIterator<CID>;
+}
+export type CID = import('multiformats').CID;
+export type Block = import('./api').Block;
+export type RootsReader = import('./api').RootsReader;
+export type BytesReader = import('./coding').BytesReader;
+//# sourceMappingURL=iterator.d.ts.map

package/src/@ipld/car/dist/src/iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterator.d.ts","sourceRoot":"","sources":["../../src/iterator.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AAEH;;;;GAIG;AACH;IACE;;;;OAIG;IACH,qBAJW,MAAM,SACN,GAAG,EAAE,YACL,cAAc,KAAK,CAAC,GAAC,IAAI,EAOnC;IAJC,iBAAuB;IACvB,0FAAmB;IACnB,uDAAyB;IACzB,kBAAqB;IAGvB,sBAEC;IAED;;OAEG;IACH,YAFa,QAAQ,GAAG,EAAE,CAAC,CAI1B;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4FAJ8B,KAAK;IAgCjC;;;;;;;;;;;OAWG;IACH,wBAHW,UAAU,GACR,QAAQ,gBAAgB,CAAC,CAKrC;IAED;;;;;;;;;;;OAWG;IACH,mCAHW,cAAc,UAAU,CAAC,GACvB,QAAQ,gBAAgB,CAAC,CAKrC;IA1DD;;;;;;;;;OASG;IAEH;;OAEG;IACH,0BAFa,cAAc,KAAK,CAAC,CAYhC;CAmCF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,0FAJ8B,GAAG;IAyC/B;;;;;;;;;;;OAWG;IACH,wBAHW,UAAU,GACR,QAAQ,cAAc,CAAC,CAKnC;IAED;;;;;;;;;;;;OAYG;IACH,mCAHW,cAAc,UAAU,CAAC,GACvB,QAAQ,cAAc,CAAC,CAKnC;IApED;;;;;;;;;OASG;IAEH;;OAEG;IACH,0BAFa,cAAc,GAAG,CAAC,CAqB9B;CAoCF;kBAlOY,OAAO,cAAc,EAAE,GAAG;oBAC1B,OAAO,OAAO,EAAE,KAAK;0BACrB,OAAO,OAAO,EAAE,WAAW;0BAC3B,OAAO,UAAU,EAAE,WAAW"}

package/src/@ipld/car/dist/src/promise-fs-opts.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @description This function is needed not to initialize the `fs.read` on load time. To run in cf workers without polyfill.
+ * @param {number} fd
+ * @param {Uint8Array} buffer
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} position
+ * @returns {Promise<{ bytesRead: number, buffer: Uint8Array }>}
+ */
+export function fsread(fd: number, buffer: Uint8Array, offset: number, length: number, position: number): Promise<{
+    bytesRead: number;
+    buffer: Uint8Array;
+}>;
+/**
+ * @description This function is needed not to initialize the `fs.write` on load time. To run in cf workers without polyfill.
+ * @param {number} fd
+ * @param {Uint8Array} buffer
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} position
+ * @returns {Promise<{ bytesRead: number, buffer: Uint8Array }>}
+ */
+export function fswrite(fd: number, buffer: Uint8Array, offset: number, length: number, position: number): Promise<{
+    bytesRead: number;
+    buffer: Uint8Array;
+}>;
+export const hasFS: boolean;
+//# sourceMappingURL=promise-fs-opts.d.ts.map

package/src/@ipld/car/dist/src/promise-fs-opts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-fs-opts.d.ts","sourceRoot":"","sources":["../../src/promise-fs-opts.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,2BAPW,MAAM,UACN,UAAU,UACV,MAAM,UACN,MAAM,YACN,MAAM,GACJ,QAAQ;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC,CAO9D;AAMD;;;;;;;;GAQG;AACH,4BAPW,MAAM,UACN,UAAU,UACV,MAAM,UACN,MAAM,YACN,MAAM,GACJ,QAAQ;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC,CAO9D;AA1CD,4BAAyB"}