@fireproof/vendor 1.2.0 → 2.0.0

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

@@ -1,151 +0,0 @@
-/**
- * @private
- * @param {BytesReader} reader
- * @returns {Promise<CarReader>}
- */
-export function decodeReaderComplete(reader: BytesReader): Promise<CarReader>;
-/**
- * @typedef {import('multiformats').CID} CID
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').CarReader} CarReaderIface
- * @typedef {import('./coding').BytesReader} BytesReader
- * @typedef {import('./coding').CarHeader} CarHeader
- * @typedef {import('./coding').CarV2Header} CarV2Header
- */
-/**
- * Provides blockstore-like access to a CAR.
- *
- * Implements the `RootsReader` interface:
- * {@link CarReader.getRoots `getRoots()`}. And the `BlockReader` interface:
- * {@link CarReader.get `get()`}, {@link CarReader.has `has()`},
- * {@link CarReader.blocks `blocks()`} (defined as a `BlockIterator`) and
- * {@link CarReader.cids `cids()`} (defined as a `CIDIterator`).
- *
- * Load this class with either `import { CarReader } from '@ipld/car/reader'`
- * (`const { CarReader } = require('@ipld/car/reader')`). Or
- * `import { CarReader } from '@ipld/car'` (`const { CarReader } = require('@ipld/car')`).
- * The former will likely result in smaller bundle sizes where this is
- * important.
- *
- * @name CarReader
- * @class
- * @implements {CarReaderIface}
- * @property {number} version The version number of the CAR referenced by this
- * reader (should be `1` or `2`).
- */
-export class CarReader implements CarReaderIface {
-    /**
-     * Instantiate a {@link CarReader} 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.
-     *
-     * @async
-     * @static
-     * @memberof CarReader
-     * @param {Uint8Array} bytes
-     * @returns {Promise<CarReader>}
-     */
-    static fromBytes(bytes: Uint8Array): Promise<CarReader>;
-    /**
-     * Instantiate a {@link CarReader} 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).
-     * This performs a decode fully in memory and maintains the decoded state in
-     * memory for full access to the data via the `CarReader` API.
-     *
-     * Care should be taken for large archives; this API may not be appropriate
-     * where memory is a concern or the archive is potentially larger than the
-     * amount of memory that the runtime can handle.
-     *
-     * @async
-     * @static
-     * @memberof CarReader
-     * @param {AsyncIterable<Uint8Array>} asyncIterable
-     * @returns {Promise<CarReader>}
-     */
-    static fromIterable(asyncIterable: AsyncIterable<Uint8Array>): Promise<CarReader>;
-    /**
-     * @constructs CarReader
-     * @param {CarHeader|CarV2Header} header
-     * @param {Block[]} blocks
-     */
-    constructor(header: CarHeader | CarV2Header, blocks: Block[]);
-    _header: import("./coding").CarHeader | import("./coding").CarV2Header;
-    _blocks: import("./api").Block[];
-    _keys: string[];
-    /**
-     * @property
-     * @memberof CarReader
-     * @instance
-     */
-    get version(): 1 | 2;
-    /**
-     * Get the list of roots defined by the CAR referenced by this reader. May be
-     * zero or more `CID`s.
-     *
-     * @function
-     * @memberof CarReader
-     * @instance
-     * @async
-     * @returns {Promise<CID[]>}
-     */
-    getRoots(): Promise<CID[]>;
-    /**
-     * Check whether a given `CID` exists within the CAR referenced by this
-     * reader.
-     *
-     * @function
-     * @memberof CarReader
-     * @instance
-     * @async
-     * @param {CID} key
-     * @returns {Promise<boolean>}
-     */
-    has(key: CID): Promise<boolean>;
-    /**
-     * 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 CarReader
-     * @instance
-     * @async
-     * @param {CID} key
-     * @returns {Promise<Block | undefined>}
-     */
-    get(key: CID): Promise<Block | undefined>;
-    /**
-     * Returns a `BlockIterator` (`AsyncIterable<Block>`) that iterates over all
-     * of the `Block`s (`{ cid:CID, bytes:Uint8Array }` pairs) contained within
-     * the CAR referenced by this reader.
-     *
-     * @function
-     * @memberof CarReader
-     * @instance
-     * @async
-     * @generator
-     * @returns {AsyncGenerator<Block>}
-     */
-    blocks(): AsyncGenerator<Block>;
-    /**
-     * Returns a `CIDIterator` (`AsyncIterable<CID>`) that iterates over all of
-     * the `CID`s contained within the CAR referenced by this reader.
-     *
-     * @function
-     * @memberof CarReader
-     * @instance
-     * @async
-     * @generator
-     * @returns {AsyncGenerator<CID>}
-     */
-    cids(): AsyncGenerator<CID>;
-}
-export const __browser: true;
-export type CID = import('multiformats').CID;
-export type Block = import('./api').Block;
-export type CarReaderIface = import('./api').CarReader;
-export type BytesReader = import('./coding').BytesReader;
-export type CarHeader = import('./coding').CarHeader;
-export type CarV2Header = import('./coding').CarV2Header;
-//# sourceMappingURL=reader-browser.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"reader-browser.d.ts","sourceRoot":"","sources":["../../src/reader-browser.js"],"names":[],"mappings":"AAiLA;;;;GAIG;AACH,6CAHW,WAAW,GACT,QAAQ,SAAS,CAAC,CAW9B;AA7LD;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAuGE;;;;;;;;;;OAUG;IACH,wBAHW,UAAU,GACR,QAAQ,SAAS,CAAC,CAO9B;IAED;;;;;;;;;;;;;;;OAeG;IACH,mCAHW,cAAc,UAAU,CAAC,GACvB,QAAQ,SAAS,CAAC,CAO9B;IA7ID;;;;OAIG;IACH,oBAHW,SAAS,GAAC,WAAW,UACrB,KAAK,EAAE,EAMjB;IAHC,uEAAqB;IACrB,iCAAqB;IACrB,gBAAgD;IAGlD;;;;OAIG;IACH,qBAEC;IAED;;;;;;;;;OASG;IACH,YAFa,QAAQ,GAAG,EAAE,CAAC,CAI1B;IAED;;;;;;;;;;OAUG;IACH,SAHW,GAAG,GACD,QAAQ,OAAO,CAAC,CAI5B;IAED;;;;;;;;;;;;OAYG;IACH,SAHW,GAAG,GACD,QAAQ,KAAK,GAAG,SAAS,CAAC,CAKtC;IAED;;;;;;;;;;;OAWG;IACH,UAFa,eAAe,KAAK,CAAC,CAMjC;IAED;;;;;;;;;;OAUG;IACH,QAFa,eAAe,GAAG,CAAC,CAM/B;CA0CF;AAkBD,6BAA6B;kBA9LhB,OAAO,cAAc,EAAE,GAAG;oBAC1B,OAAO,OAAO,EAAE,KAAK;6BACrB,OAAO,OAAO,EAAE,SAAS;0BACzB,OAAO,UAAU,EAAE,WAAW;wBAC9B,OAAO,UAAU,EAAE,SAAS;0BAC5B,OAAO,UAAU,EAAE,WAAW"}

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

@@ -1,40 +0,0 @@
-/**
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').BlockIndex} BlockIndex
- * @typedef {import('./api').CarReader} CarReaderIface
- * @typedef {import('fs').promises.FileHandle} FileHandle
- */
-/**
- * @class
- * @implements {CarReaderIface}
- */
-export class CarReader extends BrowserCarReader implements CarReaderIface {
-    /**
-     * 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.
-     *
-     * @async
-     * @static
-     * @memberof CarReader
-     * @param {FileHandle | number} fd - A file descriptor from the
-     * Node.js `fs` module. Either an integer, from `fs.open()` or a `FileHandle`
-     * from `fs.promises.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 {Promise<Block>} A `{ cid:CID, bytes:Uint8Array }` pair.
-     */
-    static readRaw(fd: FileHandle | number, blockIndex: BlockIndex): Promise<Block>;
-}
-export const __browser: boolean;
-export type Block = import('./api').Block;
-export type BlockIndex = import('./api').BlockIndex;
-export type CarReaderIface = import('./api').CarReader;
-export type FileHandle = import('fs').promises.FileHandle;
-import { CarReader as BrowserCarReader } from './reader-browser.js';
-//# sourceMappingURL=reader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../src/reader.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH;;;GAGG;AACH;IACE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBARW,UAAU,GAAG,MAAM,cAGnB,UAAU,GAGR,QAAQ,KAAK,CAAC,CAiB1B;CACF;AAED,gCAA+B;oBAjDlB,OAAO,OAAO,EAAE,KAAK;yBACrB,OAAO,OAAO,EAAE,UAAU;6BAC1B,OAAO,OAAO,EAAE,SAAS;yBACzB,OAAO,IAAI,EAAE,QAAQ,CAAC,UAAU;8CANC,qBAAqB"}

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

@@ -1,155 +0,0 @@
-/**
- * @typedef {import('./api').Block} Block
- * @typedef {import('./api').BlockWriter} BlockWriter
- * @typedef {import('./api').WriterChannel} WriterChannel
- * @typedef {import('./coding').CarEncoder} CarEncoder
- * @typedef {import('./coding').IteratorChannel<Uint8Array>} IteratorChannel
- */
-/**
- * Provides a writer interface for the creation of CAR files.
- *
- * Creation of a `CarWriter` involves the instatiation of an input / output pair
- * in the form of a `WriterChannel`, which is a
- * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair. These two
- * components form what can be thought of as a stream-like interface. The
- * `writer` component (an instantiated `CarWriter`), has methods to
- * {@link CarWriter.put `put()`} new blocks and {@link CarWriter.put `close()`}
- * the writing operation (finalising the CAR archive). The `out` component is
- * an `AsyncIterable` that yields the bytes of the archive. This can be
- * redirected to a file or other sink. In Node.js, you can use the
- * [`Readable.from()`](https://nodejs.org/api/stream.html#stream_stream_readable_from_iterable_options)
- * API to convert this to a standard Node.js stream, or it can be directly fed
- * to a
- * [`stream.pipeline()`](https://nodejs.org/api/stream.html#stream_stream_pipeline_source_transforms_destination_callback).
- *
- * The channel will provide a form of backpressure. The `Promise` from a
- * `write()` won't resolve until the resulting data is drained from the `out`
- * iterable.
- *
- * It is also possible to ignore the `Promise` from `write()` calls and allow
- * the generated data to queue in memory. This should be avoided for large CAR
- * archives of course due to the memory costs and potential for memory overflow.
- *
- * Load this class with either
- * `import { CarWriter } from '@ipld/car/writer'`
- * (`const { CarWriter } = require('@ipld/car/writer')`). Or
- * `import { CarWriter } from '@ipld/car'`
- * (`const { CarWriter } = require('@ipld/car')`). The former will likely
- * result in smaller bundle sizes where this is important.
- *
- * @name CarWriter
- * @class
- * @implements {BlockWriter}
- */
-export class CarWriter implements BlockWriter {
-    /**
-     * Create a new CAR writer "channel" which consists of a
-     * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
-     *
-     * @async
-     * @static
-     * @memberof CarWriter
-     * @param {CID[] | CID | void} roots
-     * @returns {WriterChannel} The channel takes the form of
-     * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
-     */
-    static create(roots: CID[] | CID | void): WriterChannel;
-    /**
-     * Create a new CAR appender "channel" which consists of a
-     * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }` pair.
-     * This appender does not consider roots and does not produce a CAR header.
-     * It is designed to append blocks to an _existing_ CAR archive. It is
-     * expected that `out` will be concatenated onto the end of an existing
-     * archive that already has a properly formatted header.
-     *
-     * @async
-     * @static
-     * @memberof CarWriter
-     * @returns {WriterChannel} The channel takes the form of
-     * `{ writer:CarWriter, out:AsyncIterable<Uint8Array> }`.
-     */
-    static createAppender(): WriterChannel;
-    /**
-     * Update the list of roots in the header of an existing CAR as represented
-     * in a Uint8Array.
-     *
-     * This operation is an _overwrite_, the total length of the CAR will not be
-     * modified. A rejection will occur if the new header will not be the same
-     * length as the existing header, in which case the CAR will not be modified.
-     * It is the responsibility of the user to ensure that the roots being
-     * replaced encode as the same length as the new roots.
-     *
-     * The byte array passed in an argument will be modified and also returned
-     * upon successful modification.
-     *
-     * @async
-     * @static
-     * @memberof CarWriter
-     * @param {Uint8Array} bytes
-     * @param {CID[]} roots - A new list of roots to replace the existing list in
-     * the CAR header. The new header must take up the same number of bytes as the
-     * existing header, so the roots should collectively be the same byte length
-     * as the existing roots.
-     * @returns {Promise<Uint8Array>}
-     */
-    static updateRootsInBytes(bytes: Uint8Array, roots: CID[]): Promise<Uint8Array>;
-    /**
-     * @param {CID[]} roots
-     * @param {CarEncoder} encoder
-     */
-    constructor(roots: CID[], encoder: CarEncoder);
-    _encoder: import("./coding").CarEncoder;
-    /** @type {Promise<void>} */
-    _mutex: Promise<void>;
-    _ended: boolean;
-    /**
-     * Write a `Block` (a `{ cid:CID, bytes:Uint8Array }` pair) to the archive.
-     *
-     * @function
-     * @memberof CarWriter
-     * @instance
-     * @async
-     * @param {Block} block - A `{ cid:CID, bytes:Uint8Array }` pair.
-     * @returns {Promise<void>} The returned promise will only resolve once the
-     * bytes this block generates are written to the `out` iterable.
-     */
-    put(block: Block): Promise<void>;
-    /**
-     * Finalise the CAR archive and signal that the `out` iterable should end once
-     * any remaining bytes are written.
-     *
-     * @function
-     * @memberof CarWriter
-     * @instance
-     * @async
-     * @returns {Promise<void>}
-     */
-    close(): Promise<void>;
-    /**
-     * Returns the version number of the CAR file being written
-     *
-     * @returns {number}
-     */
-    version(): number;
-}
-/**
- * @class
- * @implements {AsyncIterable<Uint8Array>}
- */
-export class CarWriterOut implements AsyncIterable<Uint8Array> {
-    /**
-     * @param {AsyncIterator<Uint8Array>} iterator
-     */
-    constructor(iterator: AsyncIterator<Uint8Array>);
-    _iterator: AsyncIterator<Uint8Array, any, undefined>;
-    _iterating: boolean | undefined;
-    [Symbol.asyncIterator](): AsyncIterator<Uint8Array, any, undefined>;
-}
-export const __browser: true;
-export type Block = import('./api').Block;
-export type BlockWriter = import('./api').BlockWriter;
-export type WriterChannel = import('./api').WriterChannel;
-export type CarEncoder = import('./coding').CarEncoder;
-export type IteratorChannel = import('./coding').IteratorChannel<Uint8Array>;
-import { CID } from 'multiformats/cid';
-//# sourceMappingURL=writer-browser.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"writer-browser.d.ts","sourceRoot":"","sources":["../../src/writer-browser.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IAkEE;;;;;;;;;;OAUG;IACH,qBAJW,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,GAChB,aAAa,CASzB;IAED;;;;;;;;;;;;;OAaG;IACH,yBAHa,aAAa,CASzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iCAPW,UAAU,SACV,GAAG,EAAE,GAIH,QAAQ,UAAU,CAAC,CAW/B;IA1ID;;;OAGG;IACH,mBAHW,GAAG,EAAE,WACL,UAAU,EAOpB;IAJC,wCAAuB;IACvB,4BAA4B;IAC5B,QADW,QAAQ,IAAI,CAAC,CACa;IACrC,gBAAmB;IAGrB;;;;;;;;;;OAUG;IACH,WAJW,KAAK,GACH,QAAQ,IAAI,CAAC,CAgBzB;IAED;;;;;;;;;OASG;IACH,SAFa,QAAQ,IAAI,CAAC,CASzB;IAED;;;;OAIG;IACH,WAFa,MAAM,CAIlB;CA4EF;AAED;;;GAGG;AACH,mDAF8B,UAAU;IAGtC;;OAEG;IACH,sBAFW,cAAc,UAAU,CAAC,EAInC;IADC,qDAAyB;IAOzB,gCAAsB;IAJxB,oEAMC;CACF;AAuCD,6BAA6B;oBAnPhB,OAAO,OAAO,EAAE,KAAK;0BACrB,OAAO,OAAO,EAAE,WAAW;4BAC3B,OAAO,OAAO,EAAE,aAAa;yBAC7B,OAAO,UAAU,EAAE,UAAU;8BAC7B,OAAO,UAAU,EAAE,eAAe,CAAC,UAAU,CAAC;oBAVvC,kBAAkB"}

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

@@ -1,45 +0,0 @@
-/**
- * @typedef {import('multiformats/cid').CID} CID
- * @typedef {import('./api').BlockWriter} BlockWriter
- * @typedef {import('fs').promises.FileHandle} FileHandle
- */
-/**
- * @class
- * @implements {BlockWriter}
- */
-export class CarWriter extends BrowserCarWriter implements BlockWriter {
-    /**
-     * Update the list of roots in the header of an existing CAR file. The first
-     * argument must be a file descriptor for CAR file that is open in read and
-     * write mode (not append), e.g. `fs.open` or `fs.promises.open` with `'r+'`
-     * mode.
-     *
-     * This operation is an _overwrite_, the total length of the CAR will not be
-     * modified. A rejection will occur if the new header will not be the same
-     * length as the existing header, in which case the CAR will not be modified.
-     * It is the responsibility of the user to ensure that the roots being
-     * replaced encode as the same length as the new roots.
-     *
-     * This function is **only available in Node.js** and not a browser
-     * environment.
-     *
-     * @async
-     * @static
-     * @memberof CarWriter
-     * @param {FileHandle | number} fd - A file descriptor from the
-     * Node.js `fs` module. Either an integer, from `fs.open()` or a `FileHandle`
-     * from `fs.promises.open()`.
-     * @param {CID[]} roots - A new list of roots to replace the existing list in
-     * the CAR header. The new header must take up the same number of bytes as the
-     * existing header, so the roots should collectively be the same byte length
-     * as the existing roots.
-     * @returns {Promise<void>}
-     */
-    static updateRootsInFile(fd: FileHandle | number, roots: CID[]): Promise<void>;
-}
-export const __browser: boolean;
-export type CID = import('multiformats/cid').CID;
-export type BlockWriter = import('./api').BlockWriter;
-export type FileHandle = import('fs').promises.FileHandle;
-import { CarWriter as BrowserCarWriter } from './writer-browser.js';
-//# sourceMappingURL=writer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../src/writer.js"],"names":[],"mappings":"AAKA;;;;GAIG;AAEH;;;GAGG;AACH;IACE;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,6BATW,UAAU,GAAG,MAAM,SAGnB,GAAG,EAAE,GAIH,QAAQ,IAAI,CAAC,CAoCzB;CACF;AAED,gCAA+B;kBA1ElB,OAAO,kBAAkB,EAAE,GAAG;0BAC9B,OAAO,OAAO,EAAE,WAAW;yBAC3B,OAAO,IAAI,EAAE,QAAQ,CAAC,UAAU;8CALC,qBAAqB"}

package/src/@ipld/car/src/api.ts

@@ -1,90 +0,0 @@
-import type { CID } from 'multiformats/cid'
-
-/**
- * Literally any `Iterable` (async or regular).
- */
-export type AwaitIterable<T> = Iterable<T> | AsyncIterable<T>
-
-export type { CID }
-/* Generic types for interfacing with block storage */
-
-export interface Block {
-  cid: CID
-  bytes: Uint8Array
-}
-
-export interface BlockHeader {
-  cid: CID
-  length: number
-  blockLength: number
-}
-
-export interface BlockIndex extends BlockHeader {
-  offset: number
-  blockOffset: number
-}
-
-export interface RootsReader {
-  version: number
-  getRoots(): Promise<CID[]>
-}
-
-export interface RootsBufferReader {
-  version: number
-  getRoots(): CID[]
-}
-
-export interface BlockIterator extends AsyncIterable<Block> {}
-
-export interface CIDIterator extends AsyncIterable<CID> {}
-
-export interface BlockReader {
-  has(key: CID): Promise<boolean>
-  get(key: CID): Promise<Block | undefined>
-  blocks(): BlockIterator
-  cids(): CIDIterator
-}
-
-export interface BlockBufferReader {
-  has(key: CID): boolean
-  get(key: CID): Block | undefined
-  blocks(): Iterable<Block>
-  cids(): Iterable<CID>
-}
-
-export interface BlockWriter {
-  put(block: Block): Promise<void>
-  close(): Promise<void>
-  version(): number
-}
-
-export interface CarBufferWriter {
-  addRoot(root: CID, options?: { resize?: boolean }): CarBufferWriter
-  write(block: Block): CarBufferWriter
-  close(options?: { resize?: boolean }): Uint8Array
-}
-
-export interface CarBufferWriterOptions {
-  roots?: CID[] // defaults to []
-  byteOffset?: number // defaults to 0
-  byteLength?: number // defaults to buffer.byteLength
-
-  headerSize?: number // defaults to size needed for provided roots
-}
-
-export interface WriterChannel {
-  writer: BlockWriter
-  out: AsyncIterable<Uint8Array>
-}
-
-export interface CarReader extends BlockReader, RootsReader {}
-export interface CarBufferReader extends BlockBufferReader, RootsBufferReader {}
-
-/* Specific implementations for CAR block storage */
-
-/*
-export interface CarBlockIterator extends BlockIterator, RootsReader {}
-export interface CarCIDIterator extends CIDIterator, RootsReader {}
-export interface CarIndexer extends AsyncIterable<BlockIndex>, RootsReader {}
-export interface CarWriter extends BlockWriter {}
-*/