@fireproof/vendor 1.0.3 → 1.1.0-dev

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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