@fireproof/vendor 0.0.0-smoke → 0.0.2-dev-test

package/src/@ipld/car/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/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/car/dist/src/reader.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="node" />
-/**
- * @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 {fs.promises.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: fs.promises.FileHandle | number, blockIndex: BlockIndex): Promise<Block>;
-}
-export const __browser: false;
-export type Block = import('./api').Block;
-export type BlockIndex = import('./api').BlockIndex;
-export type CarReaderIface = import('./api').CarReader;
-import { CarReader as BrowserCarReader } from './reader-browser.js';
-import fs from 'fs';
-//# sourceMappingURL=reader.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../src/reader.js"],"names":[],"mappings":";AAYA;;;GAGG;AACH;IACE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBARW,GAAG,QAAQ,CAAC,UAAU,GAAG,MAAM,cAG/B,UAAU,GAGR,QAAQ,KAAK,CAAC,CAiB1B;CACF;AAED,8BAA8B;oBAlDjB,OAAO,OAAO,EAAE,KAAK;yBACrB,OAAO,OAAO,EAAE,UAAU;6BAC1B,OAAO,OAAO,EAAE,SAAS;8CALQ,qBAAqB;eAFpD,IAAI"}

package/src/@ipld/car/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/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/car/dist/src/writer.d.ts

@@ -1,45 +0,0 @@
-/// <reference types="node" />
-/**
- * @typedef {import('multiformats/cid').CID} CID
- * @typedef {import('./api').BlockWriter} BlockWriter
- */
-/**
- * @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 {fs.promises.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: fs.promises.FileHandle | number, roots: CID[]): Promise<void>;
-}
-export const __browser: false;
-export type CID = import('multiformats/cid').CID;
-export type BlockWriter = import('./api').BlockWriter;
-import { CarWriter as BrowserCarWriter } from './writer-browser.js';
-import fs from 'fs';
-//# sourceMappingURL=writer.d.ts.map

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

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

package/src/@ipld/car/car/node_modules/.bin/cborg

@@ -1,17 +0,0 @@
-#!/bin/sh
-basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
-
-case `uname` in
-    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
-esac
-
-if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/home/runner/work/vendor/vendor/dist/node_modules/.pnpm/cborg@4.2.7/node_modules/cborg/lib/node_modules:/home/runner/work/vendor/vendor/dist/node_modules/.pnpm/cborg@4.2.7/node_modules/cborg/node_modules:/home/runner/work/vendor/vendor/dist/node_modules/.pnpm/cborg@4.2.7/node_modules:/home/runner/work/vendor/vendor/dist/node_modules/.pnpm/node_modules"
-else
-  export NODE_PATH="/home/runner/work/vendor/vendor/dist/node_modules/.pnpm/cborg@4.2.7/node_modules/cborg/lib/node_modules:/home/runner/work/vendor/vendor/dist/node_modules/.pnpm/cborg@4.2.7/node_modules/cborg/node_modules:/home/runner/work/vendor/vendor/dist/node_modules/.pnpm/cborg@4.2.7/node_modules:/home/runner/work/vendor/vendor/dist/node_modules/.pnpm/node_modules:$NODE_PATH"
-fi
-if [ -x "$basedir/node" ]; then
-  exec "$basedir/node"  "$basedir/../../../../../../cborg@4.2.7/node_modules/cborg/lib/bin.js" "$@"
-else
-  exec node  "$basedir/../../../../../../cborg@4.2.7/node_modules/cborg/lib/bin.js" "$@"
-fi

package/src/@ipld/car/car/package.json

@@ -1,235 +0,0 @@
-{
-  "name": "@ipld/car",
-  "version": "5.3.3",
-  "description": "Content Addressable aRchive format reader and writer",
-  "author": "Rod <rod@vagg.org> (http://r.va.gg/)",
-  "license": "Apache-2.0 OR MIT",
-  "homepage": "https://github.com/ipld/js-car#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ipld/js-car.git"
-  },
-  "bugs": {
-    "url": "https://github.com/ipld/js-car/issues"
-  },
-  "keywords": [
-    "car",
-    "ipfs",
-    "ipld",
-    "multiformats"
-  ],
-  "engines": {
-    "node": ">=16.0.0",
-    "npm": ">=7.0.0"
-  },
-  "type": "module",
-  "types": "./dist/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "*": [
-        "*",
-        "dist/*",
-        "dist/src/*",
-        "dist/src/*/index"
-      ],
-      "src/*": [
-        "*",
-        "dist/*",
-        "dist/src/*",
-        "dist/src/*/index"
-      ]
-    }
-  },
-  "files": [
-    "src",
-    "dist",
-    "!dist/test",
-    "!**/*.tsbuildinfo"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./src/index.js",
-      "browser": "./src/index-browser.js"
-    },
-    "./buffer-writer": {
-      "types": "./dist/src/buffer-writer.d.ts",
-      "import": "./src/buffer-writer.js"
-    },
-    "./decoder": {
-      "types": "./dist/src/decoder.d.ts",
-      "import": "./src/decoder.js"
-    },
-    "./indexed-reader": {
-      "types": "./dist/src/indexed-reader.d.ts",
-      "browser": "./src/indexed-reader-browser.js",
-      "import": "./src/indexed-reader.js"
-    },
-    "./indexer": {
-      "types": "./dist/src/indexer.d.ts",
-      "import": "./src/indexer.js"
-    },
-    "./iterator": {
-      "types": "./dist/src/iterator.d.ts",
-      "import": "./src/iterator.js"
-    },
-    "./reader": {
-      "types": "./dist/src/reader.d.ts",
-      "browser": "./src/reader-browser.js",
-      "import": "./src/reader.js"
-    },
-    "./buffer-reader": {
-      "types": "./dist/src/buffer-reader-browser.d.ts",
-      "browser": "./src/buffer-reader-browser.js",
-      "import": "./src/buffer-reader.js"
-    },
-    "./writer": {
-      "types": "./dist/src/writer.d.ts",
-      "browser": "./src/writer-browser.js",
-      "import": "./src/writer.js"
-    }
-  },
-  "eslintConfig": {
-    "extends": "ipfs",
-    "parserOptions": {
-      "sourceType": "module"
-    }
-  },
-  "release": {
-    "branches": [
-      "master"
-    ],
-    "plugins": [
-      [
-        "@semantic-release/commit-analyzer",
-        {
-          "preset": "conventionalcommits",
-          "releaseRules": [
-            {
-              "breaking": true,
-              "release": "major"
-            },
-            {
-              "revert": true,
-              "release": "patch"
-            },
-            {
-              "type": "feat",
-              "release": "minor"
-            },
-            {
-              "type": "fix",
-              "release": "patch"
-            },
-            {
-              "type": "docs",
-              "release": "patch"
-            },
-            {
-              "type": "test",
-              "release": "patch"
-            },
-            {
-              "type": "deps",
-              "release": "patch"
-            },
-            {
-              "scope": "no-release",
-              "release": false
-            }
-          ]
-        }
-      ],
-      [
-        "@semantic-release/release-notes-generator",
-        {
-          "preset": "conventionalcommits",
-          "presetConfig": {
-            "types": [
-              {
-                "type": "feat",
-                "section": "Features"
-              },
-              {
-                "type": "fix",
-                "section": "Bug Fixes"
-              },
-              {
-                "type": "chore",
-                "section": "Trivial Changes"
-              },
-              {
-                "type": "docs",
-                "section": "Documentation"
-              },
-              {
-                "type": "deps",
-                "section": "Dependencies"
-              },
-              {
-                "type": "test",
-                "section": "Tests"
-              }
-            ]
-          }
-        }
-      ],
-      "@semantic-release/changelog",
-      "@semantic-release/npm",
-      "@semantic-release/github",
-      "@semantic-release/git"
-    ]
-  },
-  "scripts": {
-    "clean": "aegir clean",
-    "lint": "aegir lint",
-    "build": "aegir build",
-    "build:validator": "npx @ipld/schema to-js src/header.ipldsch > src/header-validator.js",
-    "release": "aegir release",
-    "test": "npm run lint && aegir test && npm run test:examples",
-    "test:node": "aegir test -t node --cov",
-    "test:chrome": "aegir test -t browser --cov",
-    "test:chrome-webworker": "aegir test -t webworker",
-    "test:firefox": "aegir test -t browser -- --browser firefox",
-    "test:firefox-webworker": "aegir test -t webworker -- --browser firefox",
-    "test:electron-main": "aegir test -t electron-main",
-    "test:examples": "npm run test --prefix examples/",
-    "dep-check": "aegir dep-check",
-    "coverage": "c8 --reporter=html --reporter=text mocha test/test-*.js && npx st -d coverage -p 8888",
-    "docs": "jsdoc4readme --readme --description-only src/reader*.js src/indexed-reader.js src/iterator.js src/indexer.js src/writer*.js src/buffer-writer.js src/decoder.js src/buffer-reader*.js"
-  },
-  "dependencies": {
-    "@ipld/dag-cbor": "^9.0.7",
-    "cborg": "^4.0.5",
-    "multiformats": "^13.0.0",
-    "varint": "^6.0.0"
-  },
-  "devDependencies": {
-    "@ipld/dag-pb": "^4.0.7",
-    "@ipld/garbage": "^6.0.5",
-    "@types/varint": "^6.0.3",
-    "aegir": "^45.0.1",
-    "jsdoc4readme": "^1.4.0"
-  },
-  "browser": {
-    "./src/index.js": "./src/index-browser.js",
-    "./src/index-reader.js": "./src/index-reader-browser.js",
-    "./src/reader.js": "./src/reader-browser.js",
-    "./src/buffer-reader.js": "./src/buffer-reader-browser.js",
-    "./src/writer.js": "./src/writer-browser.js",
-    "fs": false,
-    "util": false,
-    "stream": false
-  },
-  "directories": {
-    "test": "test"
-  },
-  "standard": {
-    "ignore": [
-      "dist"
-    ]
-  },
-  "eslintIgnore": [
-    "src/header-validator.js"
-  ]
-}