@pkcprotocol/pkc-js 0.0.61 → 0.0.63

package/dist/bundled/chunks/src-0J9-Tmgd.js

@@ -0,0 +1,4147 @@
+import { i as __toESM, t as __commonJSMin } from "./chunk-2rV9d50f.js";
+import { i as first, n as src_exports, r as prepare, t as encode } from "./src-BOzgM7Fp.js";
+import { CID } from "multiformats/cid";
+import { fromString } from "uint8arrays/from-string";
+import { concat } from "uint8arrays/concat";
+import { alloc, allocUnsafe } from "uint8arrays/alloc";
+import { equals } from "uint8arrays/equals";
+import { withArrayBuffer } from "uint8arrays/with-array-buffer";
+import * as raw from "multiformats/codecs/raw";
+import { sha256 } from "multiformats/hashes/sha2";
+import { murmur3128 } from "@multiformats/murmur3";
+import { BlackHoleBlockstore } from "blockstore-core/black-hole";
+//#region node_modules/it-batch/dist/src/index.js
+/**
+* @packageDocumentation
+*
+* The final batch may be smaller than the max.
+*
+* @example
+*
+* ```javascript
+* import batch from 'it-batch'
+* import all from 'it-all'
+*
+* // This can also be an iterator, generator, etc
+* const values = [0, 1, 2, 3, 4]
+* const batchSize = 2
+*
+* const result = all(batch(values, batchSize))
+*
+* console.info(result) // [0, 1], [2, 3], [4]
+* ```
+*
+* Async sources must be awaited:
+*
+* ```javascript
+* import batch from 'it-batch'
+* import all from 'it-all'
+*
+* const values = async function * () {
+*   yield * [0, 1, 2, 3, 4]
+* }
+*
+* const batchSize = 2
+* const result = await all(batch(values(), batchSize))
+*
+* console.info(result) // [0, 1], [2, 3], [4]
+* ```
+*/
+function isAsyncIterable$1(thing) {
+	return thing[Symbol.asyncIterator] != null;
+}
+function batch(source, size = 1) {
+	size = Number(size);
+	if (isAsyncIterable$1(source)) return async function* () {
+		let things = [];
+		if (size < 1) size = 1;
+		if (size !== Math.round(size)) throw new Error("Batch size must be an integer");
+		for await (const thing of source) {
+			things.push(thing);
+			while (things.length >= size) {
+				yield things.slice(0, size);
+				things = things.slice(size);
+			}
+		}
+		while (things.length > 0) {
+			yield things.slice(0, size);
+			things = things.slice(size);
+		}
+	}();
+	return function* () {
+		let things = [];
+		if (size < 1) size = 1;
+		if (size !== Math.round(size)) throw new Error("Batch size must be an integer");
+		for (const thing of source) {
+			things.push(thing);
+			while (things.length >= size) {
+				yield things.slice(0, size);
+				things = things.slice(size);
+			}
+		}
+		while (things.length > 0) {
+			yield things.slice(0, size);
+			things = things.slice(size);
+		}
+	}();
+}
+//#endregion
+//#region node_modules/it-parallel-batch/dist/src/index.js
+/**
+* @packageDocumentation
+*
+* Takes an async iterator that emits promise-returning functions, invokes them in parallel and emits the results in the same order as the input.
+*
+* The final batch may be smaller than the batch size.
+*
+* @example
+*
+* ```javascript
+* import parallelBatch from 'it-parallel-batch'
+* import all from 'it-all'
+* import delay from 'delay'
+*
+* // This can also be an iterator, async iterator, generator, etc
+* const input = [
+*   async () => {
+*     await delay(500)
+*
+*     return 1
+*   },
+*   async () => {
+*     await delay(200)
+*
+*     return 2
+*   },
+*   async () => {
+*     await delay(100)
+*
+*     return 3
+*   }
+* ]
+*
+* const batchSize = 2
+*
+* const result = await all(parallelBatch(input, batchSize))
+*
+* console.info(result) // [1, 2, 3]
+* ```
+*/
+/**
+* Takes an (async) iterator that emits promise-returning functions,
+* invokes them in parallel and emits the results as they become available but
+* in the same order as the input
+*/
+async function* parallelBatch(source, size = 1) {
+	for await (const tasks of batch(source, size)) {
+		const things = tasks.map(async (p) => {
+			return p().then((value) => ({
+				ok: true,
+				value
+			}), (err) => ({
+				ok: false,
+				err
+			}));
+		});
+		for (let i = 0; i < things.length; i++) {
+			const result = await things[i];
+			if (result.ok) yield result.value;
+			else throw result.err;
+		}
+	}
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/uint8arraylist/dist/src/index.js
+/**
+* @packageDocumentation
+*
+* A class that lets you do operations over a list of Uint8Arrays without
+* copying them.
+*
+* ```js
+* import { Uint8ArrayList } from 'uint8arraylist'
+*
+* const list = new Uint8ArrayList()
+* list.append(Uint8Array.from([0, 1, 2]))
+* list.append(Uint8Array.from([3, 4, 5]))
+*
+* list.subarray()
+* // -> Uint8Array([0, 1, 2, 3, 4, 5])
+*
+* list.consume(3)
+* list.subarray()
+* // -> Uint8Array([3, 4, 5])
+*
+* // you can also iterate over the list
+* for (const buf of list) {
+*   // ..do something with `buf`
+* }
+*
+* list.subarray(0, 1)
+* // -> Uint8Array([0])
+* ```
+*
+* ## Converting Uint8ArrayLists to Uint8Arrays
+*
+* There are two ways to turn a `Uint8ArrayList` into a `Uint8Array` - `.slice` and `.subarray` and one way to turn a `Uint8ArrayList` into a `Uint8ArrayList` with different contents - `.sublist`.
+*
+* ### slice
+*
+* Slice follows the same semantics as [Uint8Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/slice) in that it creates a new `Uint8Array` and copies bytes into it using an optional offset & length.
+*
+* ```js
+* const list = new Uint8ArrayList()
+* list.append(Uint8Array.from([0, 1, 2]))
+* list.append(Uint8Array.from([3, 4, 5]))
+*
+* list.slice(0, 1)
+* // -> Uint8Array([0])
+* ```
+*
+* ### subarray
+*
+* Subarray attempts to follow the same semantics as [Uint8Array.subarray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/subarray) with one important different - this is a no-copy operation, unless the requested bytes span two internal buffers in which case it is a copy operation.
+*
+* ```js
+* const list = new Uint8ArrayList()
+* list.append(Uint8Array.from([0, 1, 2]))
+* list.append(Uint8Array.from([3, 4, 5]))
+*
+* list.subarray(0, 1)
+* // -> Uint8Array([0]) - no-copy
+*
+* list.subarray(2, 5)
+* // -> Uint8Array([2, 3, 4]) - copy
+* ```
+*
+* ### sublist
+*
+* Sublist creates and returns a new `Uint8ArrayList` that shares the underlying buffers with the original so is always a no-copy operation.
+*
+* ```js
+* const list = new Uint8ArrayList()
+* list.append(Uint8Array.from([0, 1, 2]))
+* list.append(Uint8Array.from([3, 4, 5]))
+*
+* list.sublist(0, 1)
+* // -> Uint8ArrayList([0]) - no-copy
+*
+* list.sublist(2, 5)
+* // -> Uint8ArrayList([2], [3, 4]) - no-copy
+* ```
+*
+* ## Inspiration
+*
+* Borrows liberally from [bl](https://www.npmjs.com/package/bl) but only uses native JS types.
+*/
+const symbol = Symbol.for("@achingbrain/uint8arraylist");
+function findBufAndOffset(bufs, index) {
+	if (index == null || index < 0) throw new RangeError("index is out of bounds");
+	let offset = 0;
+	for (const buf of bufs) {
+		const bufEnd = offset + buf.byteLength;
+		if (index < bufEnd) return {
+			buf,
+			index: index - offset
+		};
+		offset = bufEnd;
+	}
+	throw new RangeError("index is out of bounds");
+}
+/**
+* Check if object is a CID instance
+*
+* @example
+*
+* ```js
+* import { isUint8ArrayList, Uint8ArrayList } from 'uint8arraylist'
+*
+* isUint8ArrayList(true) // false
+* isUint8ArrayList([]) // false
+* isUint8ArrayList(new Uint8ArrayList()) // true
+* ```
+*/
+function isUint8ArrayList(value) {
+	return Boolean(value?.[symbol]);
+}
+var Uint8ArrayList = class Uint8ArrayList {
+	bufs;
+	length;
+	[symbol] = true;
+	constructor(...data) {
+		this.bufs = [];
+		this.length = 0;
+		if (data.length > 0) this.appendAll(data);
+	}
+	*[Symbol.iterator]() {
+		yield* this.bufs;
+	}
+	get byteLength() {
+		return this.length;
+	}
+	/**
+	* Add one or more `bufs` to the end of this Uint8ArrayList
+	*/
+	append(...bufs) {
+		this.appendAll(bufs);
+	}
+	/**
+	* Add all `bufs` to the end of this Uint8ArrayList
+	*/
+	appendAll(bufs) {
+		let length = 0;
+		for (const buf of bufs) if (buf instanceof Uint8Array) {
+			length += buf.byteLength;
+			this.bufs.push(buf);
+		} else if (isUint8ArrayList(buf)) {
+			length += buf.byteLength;
+			for (const chunk of buf.bufs) this.bufs.push(chunk);
+		} else throw new Error("Could not append value, must be an Uint8Array or a Uint8ArrayList");
+		this.length += length;
+	}
+	/**
+	* Add one or more `bufs` to the start of this Uint8ArrayList
+	*/
+	prepend(...bufs) {
+		this.prependAll(bufs);
+	}
+	/**
+	* Add all `bufs` to the start of this Uint8ArrayList
+	*/
+	prependAll(bufs) {
+		let length = 0;
+		for (const buf of bufs.reverse()) if (buf instanceof Uint8Array) {
+			length += buf.byteLength;
+			this.bufs.unshift(buf);
+		} else if (isUint8ArrayList(buf)) {
+			length += buf.byteLength;
+			this.bufs.unshift(...buf.bufs);
+		} else throw new Error("Could not prepend value, must be an Uint8Array or a Uint8ArrayList");
+		this.length += length;
+	}
+	/**
+	* Read the value at `index`
+	*/
+	get(index) {
+		const res = findBufAndOffset(this.bufs, index);
+		return res.buf[res.index];
+	}
+	/**
+	* Set the value at `index` to `value`
+	*/
+	set(index, value) {
+		const res = findBufAndOffset(this.bufs, index);
+		res.buf[res.index] = value;
+	}
+	/**
+	* Copy bytes from `buf` to the index specified by `offset`
+	*/
+	write(buf, offset = 0) {
+		if (buf instanceof Uint8Array) for (let i = 0; i < buf.length; i++) this.set(offset + i, buf[i]);
+		else if (isUint8ArrayList(buf)) for (let i = 0; i < buf.length; i++) this.set(offset + i, buf.get(i));
+		else throw new Error("Could not write value, must be an Uint8Array or a Uint8ArrayList");
+	}
+	/**
+	* Remove bytes from the front of the pool
+	*/
+	consume(bytes) {
+		bytes = Math.trunc(bytes);
+		if (Number.isNaN(bytes) || bytes <= 0) return;
+		if (bytes === this.byteLength) {
+			this.bufs = [];
+			this.length = 0;
+			return;
+		}
+		while (this.bufs.length > 0) if (bytes >= this.bufs[0].byteLength) {
+			bytes -= this.bufs[0].byteLength;
+			this.length -= this.bufs[0].byteLength;
+			this.bufs.shift();
+		} else {
+			this.bufs[0] = this.bufs[0].subarray(bytes);
+			this.length -= bytes;
+			break;
+		}
+	}
+	/**
+	* Extracts a section of an array and returns a new array.
+	*
+	* This is a copy operation as it is with Uint8Arrays and Arrays
+	* - note this is different to the behaviour of Node Buffers.
+	*/
+	slice(beginInclusive, endExclusive) {
+		const { bufs, length } = this._subList(beginInclusive, endExclusive);
+		return concat(bufs, length);
+	}
+	/**
+	* Returns a section of the array from the given start and end element index.
+	*
+	* This is a no-copy operation where the data extracted data comes from a
+	* single Uint8Array internally, otherwise it is a copy operation.
+	*/
+	subarray(beginInclusive, endExclusive) {
+		const { bufs, length } = this._subList(beginInclusive, endExclusive);
+		if (bufs.length === 1) return bufs[0];
+		return concat(bufs, length);
+	}
+	/**
+	* Returns a new Uint8ArrayList from the given start and end element index.
+	*
+	* This is a no-copy operation.
+	*/
+	sublist(beginInclusive, endExclusive) {
+		const { bufs, length } = this._subList(beginInclusive, endExclusive);
+		const list = new Uint8ArrayList();
+		list.length = length;
+		list.bufs = bufs;
+		return list;
+	}
+	_subList(beginInclusive, endExclusive) {
+		beginInclusive = beginInclusive ?? 0;
+		endExclusive = endExclusive ?? this.length;
+		if (beginInclusive < 0) beginInclusive = this.length + beginInclusive;
+		if (endExclusive < 0) endExclusive = this.length + endExclusive;
+		if (beginInclusive < 0 || endExclusive > this.length) throw new RangeError("index is out of bounds");
+		if (beginInclusive === endExclusive) return {
+			bufs: [],
+			length: 0
+		};
+		if (beginInclusive === 0 && endExclusive === this.length) return {
+			bufs: [...this.bufs],
+			length: this.length
+		};
+		const bufs = [];
+		let offset = 0;
+		for (let i = 0; i < this.bufs.length; i++) {
+			const buf = this.bufs[i];
+			const bufStart = offset;
+			const bufEnd = bufStart + buf.byteLength;
+			offset = bufEnd;
+			if (beginInclusive >= bufEnd) continue;
+			const sliceStartInBuf = beginInclusive >= bufStart && beginInclusive < bufEnd;
+			const sliceEndsInBuf = endExclusive > bufStart && endExclusive <= bufEnd;
+			if (sliceStartInBuf && sliceEndsInBuf) {
+				if (beginInclusive === bufStart && endExclusive === bufEnd) {
+					bufs.push(buf);
+					break;
+				}
+				const start = beginInclusive - bufStart;
+				bufs.push(buf.subarray(start, start + (endExclusive - beginInclusive)));
+				break;
+			}
+			if (sliceStartInBuf) {
+				if (beginInclusive === 0) {
+					bufs.push(buf);
+					continue;
+				}
+				bufs.push(buf.subarray(beginInclusive - bufStart));
+				continue;
+			}
+			if (sliceEndsInBuf) {
+				if (endExclusive === bufEnd) {
+					bufs.push(buf);
+					break;
+				}
+				bufs.push(buf.subarray(0, endExclusive - bufStart));
+				break;
+			}
+			bufs.push(buf);
+		}
+		return {
+			bufs,
+			length: endExclusive - beginInclusive
+		};
+	}
+	indexOf(search, offset = 0) {
+		if (!isUint8ArrayList(search) && !(search instanceof Uint8Array)) throw new TypeError("The \"value\" argument must be a Uint8ArrayList or Uint8Array");
+		const needle = search instanceof Uint8Array ? search : search.subarray();
+		offset = Number(offset ?? 0);
+		if (isNaN(offset)) offset = 0;
+		if (offset < 0) offset = this.length + offset;
+		if (offset < 0) offset = 0;
+		if (search.length === 0) return offset > this.length ? this.length : offset;
+		const M = needle.byteLength;
+		if (M === 0) throw new TypeError("search must be at least 1 byte long");
+		const radix = 256;
+		const rightmostPositions = new Int32Array(radix);
+		for (let c = 0; c < radix; c++) rightmostPositions[c] = -1;
+		for (let j = 0; j < M; j++) rightmostPositions[needle[j]] = j;
+		const right = rightmostPositions;
+		const lastIndex = this.byteLength - needle.byteLength;
+		const lastPatIndex = needle.byteLength - 1;
+		let skip;
+		for (let i = offset; i <= lastIndex; i += skip) {
+			skip = 0;
+			for (let j = lastPatIndex; j >= 0; j--) {
+				const char = this.get(i + j);
+				if (needle[j] !== char) {
+					skip = Math.max(1, j - right[char]);
+					break;
+				}
+			}
+			if (skip === 0) return i;
+		}
+		return -1;
+	}
+	getInt8(byteOffset) {
+		const buf = this.subarray(byteOffset, byteOffset + 1);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getInt8(0);
+	}
+	setInt8(byteOffset, value) {
+		const buf = allocUnsafe(1);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setInt8(0, value);
+		this.write(buf, byteOffset);
+	}
+	getInt16(byteOffset, littleEndian) {
+		const buf = this.subarray(byteOffset, byteOffset + 2);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getInt16(0, littleEndian);
+	}
+	setInt16(byteOffset, value, littleEndian) {
+		const buf = alloc(2);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setInt16(0, value, littleEndian);
+		this.write(buf, byteOffset);
+	}
+	getInt32(byteOffset, littleEndian) {
+		const buf = this.subarray(byteOffset, byteOffset + 4);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getInt32(0, littleEndian);
+	}
+	setInt32(byteOffset, value, littleEndian) {
+		const buf = alloc(4);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setInt32(0, value, littleEndian);
+		this.write(buf, byteOffset);
+	}
+	getBigInt64(byteOffset, littleEndian) {
+		const buf = this.subarray(byteOffset, byteOffset + 8);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getBigInt64(0, littleEndian);
+	}
+	setBigInt64(byteOffset, value, littleEndian) {
+		const buf = alloc(8);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setBigInt64(0, value, littleEndian);
+		this.write(buf, byteOffset);
+	}
+	getUint8(byteOffset) {
+		const buf = this.subarray(byteOffset, byteOffset + 1);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint8(0);
+	}
+	setUint8(byteOffset, value) {
+		const buf = allocUnsafe(1);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setUint8(0, value);
+		this.write(buf, byteOffset);
+	}
+	getUint16(byteOffset, littleEndian) {
+		const buf = this.subarray(byteOffset, byteOffset + 2);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint16(0, littleEndian);
+	}
+	setUint16(byteOffset, value, littleEndian) {
+		const buf = alloc(2);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setUint16(0, value, littleEndian);
+		this.write(buf, byteOffset);
+	}
+	getUint32(byteOffset, littleEndian) {
+		const buf = this.subarray(byteOffset, byteOffset + 4);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(0, littleEndian);
+	}
+	setUint32(byteOffset, value, littleEndian) {
+		const buf = alloc(4);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setUint32(0, value, littleEndian);
+		this.write(buf, byteOffset);
+	}
+	getBigUint64(byteOffset, littleEndian) {
+		const buf = this.subarray(byteOffset, byteOffset + 8);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getBigUint64(0, littleEndian);
+	}
+	setBigUint64(byteOffset, value, littleEndian) {
+		const buf = alloc(8);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setBigUint64(0, value, littleEndian);
+		this.write(buf, byteOffset);
+	}
+	getFloat32(byteOffset, littleEndian) {
+		const buf = this.subarray(byteOffset, byteOffset + 4);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getFloat32(0, littleEndian);
+	}
+	setFloat32(byteOffset, value, littleEndian) {
+		const buf = alloc(4);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setFloat32(0, value, littleEndian);
+		this.write(buf, byteOffset);
+	}
+	getFloat64(byteOffset, littleEndian) {
+		const buf = this.subarray(byteOffset, byteOffset + 8);
+		return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getFloat64(0, littleEndian);
+	}
+	setFloat64(byteOffset, value, littleEndian) {
+		const buf = alloc(8);
+		new DataView(buf.buffer, buf.byteOffset, buf.byteLength).setFloat64(0, value, littleEndian);
+		this.write(buf, byteOffset);
+	}
+	equals(other) {
+		if (other == null) return false;
+		if (!(other instanceof Uint8ArrayList)) return false;
+		if (other.bufs.length !== this.bufs.length) return false;
+		for (let i = 0; i < this.bufs.length; i++) if (!equals(this.bufs[i], other.bufs[i])) return false;
+		return true;
+	}
+	/**
+	* Create a Uint8ArrayList from a pre-existing list of Uint8Arrays.  Use this
+	* method if you know the total size of all the Uint8Arrays ahead of time.
+	*/
+	static fromUint8Arrays(bufs, length) {
+		const list = new Uint8ArrayList();
+		list.bufs = bufs;
+		if (length == null) length = bufs.reduce((acc, curr) => acc + curr.byteLength, 0);
+		list.length = length;
+		return list;
+	}
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/constants.js
+const DEFAULT_SHARD_HASH_CODE = BigInt(34);
+const DEFAULT_CHUNK_SIZE_256KIB = 262144;
+const DEFAULT_CHUNK_SIZE_1MIB = 1048576;
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/chunker/fixed-size.js
+const fixedSize = (options = {}) => {
+	const chunkSize = options.chunkSize ?? 262144;
+	return async function* fixedSizeChunker(source) {
+		let list = new Uint8ArrayList();
+		let currentLength = 0;
+		let emitted = false;
+		for await (const buffer of source) {
+			list.append(buffer);
+			currentLength += buffer.length;
+			while (currentLength >= chunkSize) {
+				yield list.subarray(0, chunkSize);
+				emitted = true;
+				if (chunkSize === list.length) {
+					list = new Uint8ArrayList();
+					currentLength = 0;
+				} else {
+					const newBl = new Uint8ArrayList();
+					newBl.append(list.sublist(chunkSize));
+					list = newBl;
+					currentLength -= chunkSize;
+				}
+			}
+		}
+		if (!emitted || currentLength > 0) yield list.subarray(0, currentLength);
+	};
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/ipfs-unixfs/dist/src/errors.js
+var InvalidTypeError = class InvalidTypeError extends Error {
+	static name = "InvalidTypeError";
+	static code = "ERR_INVALID_TYPE";
+	name = InvalidTypeError.name;
+	code = InvalidTypeError.code;
+	constructor(message = "Invalid type") {
+		super(message);
+	}
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/uint8-varint/dist/src/index.js
+const N1 = Math.pow(2, 7);
+const N2 = Math.pow(2, 14);
+const N3 = Math.pow(2, 21);
+const N4 = Math.pow(2, 28);
+const N5 = Math.pow(2, 35);
+const N6 = Math.pow(2, 42);
+const N7 = Math.pow(2, 49);
+/** Most significant bit of a byte */
+const MSB = 128;
+/** Rest of the bits in a byte */
+const REST = 127;
+function encodingLength(value) {
+	if (value < N1) return 1;
+	if (value < N2) return 2;
+	if (value < N3) return 3;
+	if (value < N4) return 4;
+	if (value < N5) return 5;
+	if (value < N6) return 6;
+	if (value < N7) return 7;
+	if (Number.MAX_SAFE_INTEGER != null && value > Number.MAX_SAFE_INTEGER) throw new RangeError("Could not encode varint");
+	return 8;
+}
+function encodeUint8Array(value, buf, offset = 0) {
+	switch (encodingLength(value)) {
+		case 8:
+			buf[offset++] = value & 255 | MSB;
+			value /= 128;
+		case 7:
+			buf[offset++] = value & 255 | MSB;
+			value /= 128;
+		case 6:
+			buf[offset++] = value & 255 | MSB;
+			value /= 128;
+		case 5:
+			buf[offset++] = value & 255 | MSB;
+			value /= 128;
+		case 4:
+			buf[offset++] = value & 255 | MSB;
+			value >>>= 7;
+		case 3:
+			buf[offset++] = value & 255 | MSB;
+			value >>>= 7;
+		case 2:
+			buf[offset++] = value & 255 | MSB;
+			value >>>= 7;
+		case 1:
+			buf[offset++] = value & 255;
+			value >>>= 7;
+			break;
+		default: throw new Error("unreachable");
+	}
+	return buf;
+}
+function decodeUint8Array(buf, offset) {
+	let b = buf[offset];
+	let res = 0;
+	res += b & REST;
+	if (b < MSB) return res;
+	b = buf[offset + 1];
+	res += (b & REST) << 7;
+	if (b < MSB) return res;
+	b = buf[offset + 2];
+	res += (b & REST) << 14;
+	if (b < MSB) return res;
+	b = buf[offset + 3];
+	res += (b & REST) << 21;
+	if (b < MSB) return res;
+	b = buf[offset + 4];
+	res += (b & REST) * N4;
+	if (b < MSB) return res;
+	b = buf[offset + 5];
+	res += (b & REST) * N5;
+	if (b < MSB) return res;
+	b = buf[offset + 6];
+	res += (b & REST) * N6;
+	if (b < MSB) return res;
+	b = buf[offset + 7];
+	res += (b & REST) * N7;
+	if (b < MSB) return res;
+	throw new RangeError("Could not decode varint");
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/utils/float.js
+const f32 = new Float32Array([-0]);
+const f8b = new Uint8Array(f32.buffer);
+/**
+* Writes a 32 bit float to a buffer using little endian byte order
+*/
+function writeFloatLE(val, buf, pos) {
+	f32[0] = val;
+	buf[pos] = f8b[0];
+	buf[pos + 1] = f8b[1];
+	buf[pos + 2] = f8b[2];
+	buf[pos + 3] = f8b[3];
+}
+/**
+* Reads a 32 bit float from a buffer using little endian byte order
+*/
+function readFloatLE(buf, pos) {
+	f8b[0] = buf[pos];
+	f8b[1] = buf[pos + 1];
+	f8b[2] = buf[pos + 2];
+	f8b[3] = buf[pos + 3];
+	return f32[0];
+}
+const f64 = new Float64Array([-0]);
+const d8b = new Uint8Array(f64.buffer);
+/**
+* Writes a 64 bit double to a buffer using little endian byte order
+*/
+function writeDoubleLE(val, buf, pos) {
+	f64[0] = val;
+	buf[pos] = d8b[0];
+	buf[pos + 1] = d8b[1];
+	buf[pos + 2] = d8b[2];
+	buf[pos + 3] = d8b[3];
+	buf[pos + 4] = d8b[4];
+	buf[pos + 5] = d8b[5];
+	buf[pos + 6] = d8b[6];
+	buf[pos + 7] = d8b[7];
+}
+/**
+* Reads a 64 bit double from a buffer using little endian byte order
+*/
+function readDoubleLE(buf, pos) {
+	d8b[0] = buf[pos];
+	d8b[1] = buf[pos + 1];
+	d8b[2] = buf[pos + 2];
+	d8b[3] = buf[pos + 3];
+	d8b[4] = buf[pos + 4];
+	d8b[5] = buf[pos + 5];
+	d8b[6] = buf[pos + 6];
+	d8b[7] = buf[pos + 7];
+	return f64[0];
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/utils/longbits.js
+const MAX_SAFE_NUMBER_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_NUMBER_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
+/**
+* Constructs new long bits.
+*
+* @classdesc Helper class for working with the low and high bits of a 64 bit value.
+* @memberof util
+* @function Object() { [native code] }
+* @param {number} lo - Low 32 bits, unsigned
+* @param {number} hi - High 32 bits, unsigned
+*/
+var LongBits = class LongBits {
+	lo;
+	hi;
+	constructor(lo, hi) {
+		/**
+		* Low bits
+		*/
+		this.lo = lo | 0;
+		/**
+		* High bits
+		*/
+		this.hi = hi | 0;
+	}
+	/**
+	* Converts this long bits to a possibly unsafe JavaScript number
+	*/
+	toNumber(unsigned = false) {
+		if (!unsigned && this.hi >>> 31 > 0) {
+			const lo = ~this.lo + 1 >>> 0;
+			let hi = ~this.hi >>> 0;
+			if (lo === 0) hi = hi + 1 >>> 0;
+			return -(lo + hi * 4294967296);
+		}
+		return this.lo + this.hi * 4294967296;
+	}
+	/**
+	* Converts this long bits to a bigint
+	*/
+	toBigInt(unsigned = false) {
+		if (unsigned) return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+		if (this.hi >>> 31 !== 0) {
+			const lo = ~this.lo + 1 >>> 0;
+			let hi = ~this.hi >>> 0;
+			if (lo === 0) hi = hi + 1 >>> 0;
+			return -(BigInt(lo) + (BigInt(hi) << 32n));
+		}
+		return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+	}
+	/**
+	* Converts this long bits to a string
+	*/
+	toString(unsigned = false) {
+		return this.toBigInt(unsigned).toString();
+	}
+	/**
+	* Zig-zag encodes this long bits
+	*/
+	zzEncode() {
+		const mask = this.hi >> 31;
+		this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+		this.lo = (this.lo << 1 ^ mask) >>> 0;
+		return this;
+	}
+	/**
+	* Zig-zag decodes this long bits
+	*/
+	zzDecode() {
+		const mask = -(this.lo & 1);
+		this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+		this.hi = (this.hi >>> 1 ^ mask) >>> 0;
+		return this;
+	}
+	/**
+	* Calculates the length of this longbits when encoded as a varint.
+	*/
+	length() {
+		const part0 = this.lo;
+		const part1 = (this.lo >>> 28 | this.hi << 4) >>> 0;
+		const part2 = this.hi >>> 24;
+		return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
+	}
+	/**
+	* Constructs new long bits from the specified number
+	*/
+	static fromBigInt(value) {
+		if (value === 0n) return zero;
+		if (value < MAX_SAFE_NUMBER_INTEGER && value > MIN_SAFE_NUMBER_INTEGER) return this.fromNumber(Number(value));
+		const negative = value < 0n;
+		if (negative) value = -value;
+		let hi = value >> 32n;
+		let lo = value - (hi << 32n);
+		if (negative) {
+			hi = ~hi | 0n;
+			lo = ~lo | 0n;
+			if (++lo > TWO_32) {
+				lo = 0n;
+				if (++hi > TWO_32) hi = 0n;
+			}
+		}
+		return new LongBits(Number(lo), Number(hi));
+	}
+	/**
+	* Constructs new long bits from the specified number
+	*/
+	static fromNumber(value) {
+		if (value === 0) return zero;
+		const sign = value < 0;
+		if (sign) value = -value;
+		let lo = value >>> 0;
+		let hi = (value - lo) / 4294967296 >>> 0;
+		if (sign) {
+			hi = ~hi >>> 0;
+			lo = ~lo >>> 0;
+			if (++lo > 4294967295) {
+				lo = 0;
+				if (++hi > 4294967295) hi = 0;
+			}
+		}
+		return new LongBits(lo, hi);
+	}
+	/**
+	* Constructs new long bits from a number, long or string
+	*/
+	static from(value) {
+		if (typeof value === "number") return LongBits.fromNumber(value);
+		if (typeof value === "bigint") return LongBits.fromBigInt(value);
+		if (typeof value === "string") return LongBits.fromBigInt(BigInt(value));
+		return value.low != null || value.high != null ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+	}
+};
+const zero = new LongBits(0, 0);
+zero.toBigInt = function() {
+	return 0n;
+};
+zero.zzEncode = zero.zzDecode = function() {
+	return this;
+};
+zero.length = function() {
+	return 1;
+};
+const TWO_32 = 4294967296n;
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/utils/utf8.js
+/**
+* Calculates the UTF8 byte length of a string
+*/
+function length(string) {
+	let len = 0;
+	let c = 0;
+	for (let i = 0; i < string.length; ++i) {
+		c = string.charCodeAt(i);
+		if (c < 128) len += 1;
+		else if (c < 2048) len += 2;
+		else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) {
+			++i;
+			len += 4;
+		} else len += 3;
+	}
+	return len;
+}
+/**
+* Reads UTF8 bytes as a string
+*/
+function read(buffer, start, end) {
+	if (end - start < 1) return "";
+	let parts;
+	const chunk = [];
+	let i = 0;
+	let t;
+	while (start < end) {
+		t = buffer[start++];
+		if (t < 128) chunk[i++] = t;
+		else if (t > 191 && t < 224) chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+		else if (t > 239 && t < 365) {
+			t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 65536;
+			chunk[i++] = 55296 + (t >> 10);
+			chunk[i++] = 56320 + (t & 1023);
+		} else chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+		if (i > 8191) {
+			(parts ?? (parts = [])).push(String.fromCharCode.apply(String, chunk));
+			i = 0;
+		}
+	}
+	if (parts != null) {
+		if (i > 0) parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+		return parts.join("");
+	}
+	return String.fromCharCode.apply(String, chunk.slice(0, i));
+}
+/**
+* Writes a string as UTF8 bytes
+*/
+function write(string, buffer, offset) {
+	const start = offset;
+	let c1;
+	let c2;
+	for (let i = 0; i < string.length; ++i) {
+		c1 = string.charCodeAt(i);
+		if (c1 < 128) buffer[offset++] = c1;
+		else if (c1 < 2048) {
+			buffer[offset++] = c1 >> 6 | 192;
+			buffer[offset++] = c1 & 63 | 128;
+		} else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) {
+			c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+			++i;
+			buffer[offset++] = c1 >> 18 | 240;
+			buffer[offset++] = c1 >> 12 & 63 | 128;
+			buffer[offset++] = c1 >> 6 & 63 | 128;
+			buffer[offset++] = c1 & 63 | 128;
+		} else {
+			buffer[offset++] = c1 >> 12 | 224;
+			buffer[offset++] = c1 >> 6 & 63 | 128;
+			buffer[offset++] = c1 & 63 | 128;
+		}
+	}
+	return offset - start;
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/utils/reader.js
+/* istanbul ignore next */
+function indexOutOfRange(reader, writeLength) {
+	return RangeError(`index out of range: ${reader.pos} + ${writeLength ?? 1} > ${reader.len}`);
+}
+function readFixed32End(buf, end) {
+	return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
+}
+/**
+* Constructs a new reader instance using the specified buffer.
+*/
+var Uint8ArrayReader = class {
+	buf;
+	pos;
+	len;
+	_slice = Uint8Array.prototype.subarray;
+	constructor(buffer) {
+		/**
+		* Read buffer
+		*/
+		this.buf = withArrayBuffer(buffer);
+		/**
+		* Read buffer position
+		*/
+		this.pos = 0;
+		/**
+		* Read buffer length
+		*/
+		this.len = buffer.length;
+	}
+	/**
+	* Reads a varint as an unsigned 32 bit value
+	*/
+	uint32() {
+		let value = 4294967295;
+		value = (this.buf[this.pos] & 127) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		if ((this.pos += 5) > this.len) {
+			this.pos = this.len;
+			throw indexOutOfRange(this, 10);
+		}
+		return value;
+	}
+	/**
+	* Reads a varint as a signed 32 bit value
+	*/
+	int32() {
+		return this.uint32() | 0;
+	}
+	/**
+	* Reads a zig-zag encoded varint as a signed 32 bit value
+	*/
+	sint32() {
+		const value = this.uint32();
+		return value >>> 1 ^ -(value & 1) | 0;
+	}
+	/**
+	* Reads a varint as a boolean
+	*/
+	bool() {
+		return this.uint32() !== 0;
+	}
+	/**
+	* Reads fixed 32 bits as an unsigned 32 bit integer
+	*/
+	fixed32() {
+		if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+		return readFixed32End(this.buf, this.pos += 4);
+	}
+	/**
+	* Reads fixed 32 bits as a signed 32 bit integer
+	*/
+	sfixed32() {
+		if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+		return readFixed32End(this.buf, this.pos += 4) | 0;
+	}
+	/**
+	* Reads a float (32 bit) as a number
+	*/
+	float() {
+		if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+		const value = readFloatLE(this.buf, this.pos);
+		this.pos += 4;
+		return value;
+	}
+	/**
+	* Reads a double (64 bit float) as a number
+	*/
+	double() {
+		/* istanbul ignore if */
+		if (this.pos + 8 > this.len) throw indexOutOfRange(this, 4);
+		const value = readDoubleLE(this.buf, this.pos);
+		this.pos += 8;
+		return value;
+	}
+	/**
+	* Reads a sequence of bytes preceded by its length as a varint
+	*/
+	bytes() {
+		const length = this.uint32();
+		const start = this.pos;
+		const end = this.pos + length;
+		/* istanbul ignore if */
+		if (end > this.len) throw indexOutOfRange(this, length);
+		this.pos += length;
+		return start === end ? new Uint8Array(0) : this.buf.subarray(start, end);
+	}
+	/**
+	* Reads a string preceded by its byte length as a varint
+	*/
+	string() {
+		const bytes = this.bytes();
+		return read(bytes, 0, bytes.length);
+	}
+	/**
+	* Skips the specified number of bytes if specified, otherwise skips a varint
+	*/
+	skip(length) {
+		if (typeof length === "number") {
+			/* istanbul ignore if */
+			if (this.pos + length > this.len) throw indexOutOfRange(this, length);
+			this.pos += length;
+		} else do
+			/* istanbul ignore if */
+			if (this.pos >= this.len) throw indexOutOfRange(this);
+		while ((this.buf[this.pos++] & 128) !== 0);
+		return this;
+	}
+	/**
+	* Skips the next element of the specified wire type
+	*/
+	skipType(wireType) {
+		switch (wireType) {
+			case 0:
+				this.skip();
+				break;
+			case 1:
+				this.skip(8);
+				break;
+			case 2:
+				this.skip(this.uint32());
+				break;
+			case 3:
+				while ((wireType = this.uint32() & 7) !== 4) this.skipType(wireType);
+				break;
+			case 5:
+				this.skip(4);
+				break;
+			/* istanbul ignore next */
+			default: throw Error(`invalid wire type ${wireType} at offset ${this.pos}`);
+		}
+		return this;
+	}
+	readLongVarint() {
+		const bits = new LongBits(0, 0);
+		let i = 0;
+		if (this.len - this.pos > 4) {
+			for (; i < 4; ++i) {
+				bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+				if (this.buf[this.pos++] < 128) return bits;
+			}
+			bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
+			bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
+			if (this.buf[this.pos++] < 128) return bits;
+			i = 0;
+		} else {
+			for (; i < 3; ++i) {
+				/* istanbul ignore if */
+				if (this.pos >= this.len) throw indexOutOfRange(this);
+				bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+				if (this.buf[this.pos++] < 128) return bits;
+			}
+			bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+			return bits;
+		}
+		if (this.len - this.pos > 4) for (; i < 5; ++i) {
+			bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+			if (this.buf[this.pos++] < 128) return bits;
+		}
+		else for (; i < 5; ++i) {
+			if (this.pos >= this.len) throw indexOutOfRange(this);
+			bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+			if (this.buf[this.pos++] < 128) return bits;
+		}
+		throw Error("invalid varint encoding");
+	}
+	readFixed64() {
+		if (this.pos + 8 > this.len) throw indexOutOfRange(this, 8);
+		return new LongBits(readFixed32End(this.buf, this.pos += 4), readFixed32End(this.buf, this.pos += 4));
+	}
+	/**
+	* Reads a varint as a signed 64 bit value
+	*/
+	int64() {
+		return this.readLongVarint().toBigInt();
+	}
+	/**
+	* Reads a varint as a signed 64 bit value returned as a possibly unsafe
+	* JavaScript number
+	*/
+	int64Number() {
+		return this.readLongVarint().toNumber();
+	}
+	/**
+	* Reads a varint as a signed 64 bit value returned as a string
+	*/
+	int64String() {
+		return this.readLongVarint().toString();
+	}
+	/**
+	* Reads a varint as an unsigned 64 bit value
+	*/
+	uint64() {
+		return this.readLongVarint().toBigInt(true);
+	}
+	/**
+	* Reads a varint as an unsigned 64 bit value returned as a possibly unsafe
+	* JavaScript number
+	*/
+	uint64Number() {
+		const value = decodeUint8Array(this.buf, this.pos);
+		this.pos += encodingLength(value);
+		return value;
+	}
+	/**
+	* Reads a varint as an unsigned 64 bit value returned as a string
+	*/
+	uint64String() {
+		return this.readLongVarint().toString(true);
+	}
+	/**
+	* Reads a zig-zag encoded varint as a signed 64 bit value
+	*/
+	sint64() {
+		return this.readLongVarint().zzDecode().toBigInt();
+	}
+	/**
+	* Reads a zig-zag encoded varint as a signed 64 bit value returned as a
+	* possibly unsafe JavaScript number
+	*/
+	sint64Number() {
+		return this.readLongVarint().zzDecode().toNumber();
+	}
+	/**
+	* Reads a zig-zag encoded varint as a signed 64 bit value returned as a
+	* string
+	*/
+	sint64String() {
+		return this.readLongVarint().zzDecode().toString();
+	}
+	/**
+	* Reads fixed 64 bits
+	*/
+	fixed64() {
+		return this.readFixed64().toBigInt();
+	}
+	/**
+	* Reads fixed 64 bits returned as a possibly unsafe JavaScript number
+	*/
+	fixed64Number() {
+		return this.readFixed64().toNumber();
+	}
+	/**
+	* Reads fixed 64 bits returned as a string
+	*/
+	fixed64String() {
+		return this.readFixed64().toString();
+	}
+	/**
+	* Reads zig-zag encoded fixed 64 bits
+	*/
+	sfixed64() {
+		return this.readFixed64().toBigInt();
+	}
+	/**
+	* Reads zig-zag encoded fixed 64 bits returned as a possibly unsafe
+	* JavaScript number
+	*/
+	sfixed64Number() {
+		return this.readFixed64().toNumber();
+	}
+	/**
+	* Reads zig-zag encoded fixed 64 bits returned as a string
+	*/
+	sfixed64String() {
+		return this.readFixed64().toString();
+	}
+};
+function createReader(buf) {
+	return new Uint8ArrayReader(buf instanceof Uint8Array ? buf : buf.subarray());
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/decode.js
+function decodeMessage(buf, codec, opts) {
+	const reader = createReader(buf);
+	return codec.decode(reader, void 0, opts);
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/utils/pool.js
+/**
+* A general purpose buffer pool
+*/
+function pool(size) {
+	const SIZE = size ?? 8192;
+	const MAX = SIZE >>> 1;
+	let slab;
+	let offset = SIZE;
+	return function poolAlloc(size) {
+		if (size < 1 || size > MAX) return allocUnsafe(size);
+		if (offset + size > SIZE) {
+			slab = allocUnsafe(SIZE);
+			offset = 0;
+		}
+		const buf = slab.subarray(offset, offset += size);
+		if ((offset & 7) !== 0) offset = (offset | 7) + 1;
+		return buf;
+	};
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/utils/writer.js
+/**
+* Constructs a new writer operation instance.
+*
+* @classdesc Scheduled writer operation
+*/
+var Op = class {
+	/**
+	* Function to call
+	*/
+	fn;
+	/**
+	* Value byte length
+	*/
+	len;
+	/**
+	* Next operation
+	*/
+	next;
+	/**
+	* Value to write
+	*/
+	val;
+	constructor(fn, len, val) {
+		this.fn = fn;
+		this.len = len;
+		this.next = void 0;
+		this.val = val;
+	}
+};
+/* istanbul ignore next */
+function noop() {}
+/**
+* Constructs a new writer state instance
+*/
+var State = class {
+	/**
+	* Current head
+	*/
+	head;
+	/**
+	* Current tail
+	*/
+	tail;
+	/**
+	* Current buffer length
+	*/
+	len;
+	/**
+	* Next state
+	*/
+	next;
+	constructor(writer) {
+		this.head = writer.head;
+		this.tail = writer.tail;
+		this.len = writer.len;
+		this.next = writer.states;
+	}
+};
+const bufferPool = pool();
+/**
+* Allocates a buffer of the specified size
+*/
+function alloc$1(size) {
+	if (globalThis.Buffer != null) return allocUnsafe(size);
+	return bufferPool(size);
+}
+/**
+* When a value is written, the writer calculates its byte length and puts it into a linked
+* list of operations to perform when finish() is called. This both allows us to allocate
+* buffers of the exact required size and reduces the amount of work we have to do compared
+* to first calculating over objects and then encoding over objects. In our case, the encoding
+* part is just a linked list walk calling operations with already prepared values.
+*/
+var Uint8ArrayWriter = class {
+	/**
+	* Current length
+	*/
+	len;
+	/**
+	* Operations head
+	*/
+	head;
+	/**
+	* Operations tail
+	*/
+	tail;
+	/**
+	* Linked forked states
+	*/
+	states;
+	constructor() {
+		this.len = 0;
+		this.head = new Op(noop, 0, 0);
+		this.tail = this.head;
+		this.states = null;
+	}
+	/**
+	* Pushes a new operation to the queue
+	*/
+	_push(fn, len, val) {
+		this.tail = this.tail.next = new Op(fn, len, val);
+		this.len += len;
+		return this;
+	}
+	/**
+	* Writes an unsigned 32 bit value as a varint
+	*/
+	uint32(value) {
+		this.len += (this.tail = this.tail.next = new VarintOp((value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5, value)).len;
+		return this;
+	}
+	/**
+	* Writes a signed 32 bit value as a varint`
+	*/
+	int32(value) {
+		return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
+	}
+	/**
+	* Writes a 32 bit value as a varint, zig-zag encoded
+	*/
+	sint32(value) {
+		return this.uint32((value << 1 ^ value >> 31) >>> 0);
+	}
+	/**
+	* Writes an unsigned 64 bit value as a varint
+	*/
+	uint64(value) {
+		const bits = LongBits.fromBigInt(value);
+		return this._push(writeVarint64, bits.length(), bits);
+	}
+	/**
+	* Writes an unsigned 64 bit value as a varint
+	*/
+	uint64Number(value) {
+		return this._push(encodeUint8Array, encodingLength(value), value);
+	}
+	/**
+	* Writes an unsigned 64 bit value as a varint
+	*/
+	uint64String(value) {
+		return this.uint64(BigInt(value));
+	}
+	/**
+	* Writes a signed 64 bit value as a varint
+	*/
+	int64(value) {
+		return this.uint64(value);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint
+	*/
+	int64Number(value) {
+		return this.uint64Number(value);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint
+	*/
+	int64String(value) {
+		return this.uint64String(value);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint, zig-zag encoded
+	*/
+	sint64(value) {
+		const bits = LongBits.fromBigInt(value).zzEncode();
+		return this._push(writeVarint64, bits.length(), bits);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint, zig-zag encoded
+	*/
+	sint64Number(value) {
+		const bits = LongBits.fromNumber(value).zzEncode();
+		return this._push(writeVarint64, bits.length(), bits);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint, zig-zag encoded
+	*/
+	sint64String(value) {
+		return this.sint64(BigInt(value));
+	}
+	/**
+	* Writes a boolish value as a varint
+	*/
+	bool(value) {
+		return this._push(writeByte, 1, value ? 1 : 0);
+	}
+	/**
+	* Writes an unsigned 32 bit value as fixed 32 bits
+	*/
+	fixed32(value) {
+		return this._push(writeFixed32, 4, value >>> 0);
+	}
+	/**
+	* Writes a signed 32 bit value as fixed 32 bits
+	*/
+	sfixed32(value) {
+		return this.fixed32(value);
+	}
+	/**
+	* Writes an unsigned 64 bit value as fixed 64 bits
+	*/
+	fixed64(value) {
+		const bits = LongBits.fromBigInt(value);
+		return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+	}
+	/**
+	* Writes an unsigned 64 bit value as fixed 64 bits
+	*/
+	fixed64Number(value) {
+		const bits = LongBits.fromNumber(value);
+		return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+	}
+	/**
+	* Writes an unsigned 64 bit value as fixed 64 bits
+	*/
+	fixed64String(value) {
+		return this.fixed64(BigInt(value));
+	}
+	/**
+	* Writes a signed 64 bit value as fixed 64 bits
+	*/
+	sfixed64(value) {
+		return this.fixed64(value);
+	}
+	/**
+	* Writes a signed 64 bit value as fixed 64 bits
+	*/
+	sfixed64Number(value) {
+		return this.fixed64Number(value);
+	}
+	/**
+	* Writes a signed 64 bit value as fixed 64 bits
+	*/
+	sfixed64String(value) {
+		return this.fixed64String(value);
+	}
+	/**
+	* Writes a float (32 bit)
+	*/
+	float(value) {
+		return this._push(writeFloatLE, 4, value);
+	}
+	/**
+	* Writes a double (64 bit float).
+	*
+	* @function
+	* @param {number} value - Value to write
+	* @returns {Writer} `this`
+	*/
+	double(value) {
+		return this._push(writeDoubleLE, 8, value);
+	}
+	/**
+	* Writes a sequence of bytes
+	*/
+	bytes(value) {
+		const len = value.length >>> 0;
+		if (len === 0) return this._push(writeByte, 1, 0);
+		return this.uint32(len)._push(writeBytes, len, value);
+	}
+	/**
+	* Writes a string
+	*/
+	string(value) {
+		const len = length(value);
+		return len !== 0 ? this.uint32(len)._push(write, len, value) : this._push(writeByte, 1, 0);
+	}
+	/**
+	* Forks this writer's state by pushing it to a stack.
+	* Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
+	*/
+	fork() {
+		this.states = new State(this);
+		this.head = this.tail = new Op(noop, 0, 0);
+		this.len = 0;
+		return this;
+	}
+	/**
+	* Resets this instance to the last state
+	*/
+	reset() {
+		if (this.states != null) {
+			this.head = this.states.head;
+			this.tail = this.states.tail;
+			this.len = this.states.len;
+			this.states = this.states.next;
+		} else {
+			this.head = this.tail = new Op(noop, 0, 0);
+			this.len = 0;
+		}
+		return this;
+	}
+	/**
+	* Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
+	*/
+	ldelim() {
+		const head = this.head;
+		const tail = this.tail;
+		const len = this.len;
+		this.reset().uint32(len);
+		if (len !== 0) {
+			this.tail.next = head.next;
+			this.tail = tail;
+			this.len += len;
+		}
+		return this;
+	}
+	/**
+	* Finishes the write operation
+	*/
+	finish() {
+		let head = this.head.next;
+		const buf = alloc$1(this.len);
+		let pos = 0;
+		while (head != null) {
+			head.fn(head.val, buf, pos);
+			pos += head.len;
+			head = head.next;
+		}
+		return buf;
+	}
+};
+function writeByte(val, buf, pos) {
+	buf[pos] = val & 255;
+}
+function writeVarint32(val, buf, pos) {
+	while (val > 127) {
+		buf[pos++] = val & 127 | 128;
+		val >>>= 7;
+	}
+	buf[pos] = val;
+}
+/**
+* Constructs a new varint writer operation instance.
+*
+* @classdesc Scheduled varint writer operation
+*/
+var VarintOp = class extends Op {
+	next;
+	constructor(len, val) {
+		super(writeVarint32, len, val);
+		this.next = void 0;
+	}
+};
+function writeVarint64(val, buf, pos) {
+	while (val.hi !== 0) {
+		buf[pos++] = val.lo & 127 | 128;
+		val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
+		val.hi >>>= 7;
+	}
+	while (val.lo > 127) {
+		buf[pos++] = val.lo & 127 | 128;
+		val.lo = val.lo >>> 7;
+	}
+	buf[pos++] = val.lo;
+}
+function writeFixed32(val, buf, pos) {
+	buf[pos] = val & 255;
+	buf[pos + 1] = val >>> 8 & 255;
+	buf[pos + 2] = val >>> 16 & 255;
+	buf[pos + 3] = val >>> 24;
+}
+function writeBytes(val, buf, pos) {
+	buf.set(val, pos);
+}
+if (globalThis.Buffer != null) {
+	Uint8ArrayWriter.prototype.bytes = function(value) {
+		const len = value.length >>> 0;
+		this.uint32(len);
+		if (len > 0) this._push(writeBytesBuffer, len, value);
+		return this;
+	};
+	Uint8ArrayWriter.prototype.string = function(value) {
+		const len = globalThis.Buffer.byteLength(value);
+		this.uint32(len);
+		if (len > 0) this._push(writeStringBuffer, len, value);
+		return this;
+	};
+}
+function writeBytesBuffer(val, buf, pos) {
+	buf.set(val, pos);
+}
+function writeStringBuffer(val, buf, pos) {
+	if (val.length < 40) write(val, buf, pos);
+	else if (buf.utf8Write != null) buf.utf8Write(val, pos);
+	else buf.set(fromString(val), pos);
+}
+/**
+* Creates a new writer
+*/
+function createWriter() {
+	return new Uint8ArrayWriter();
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/encode.js
+function encodeMessage(message, codec) {
+	const w = createWriter();
+	codec.encode(message, w, { lengthDelimited: false });
+	return w.finish();
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/stream.js
+function* streamMessage(buf, codec, opts) {
+	const reader = createReader(buf);
+	yield* codec.stream(reader, void 0, "$", opts);
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/codec.js
+const CODEC_TYPES = {
+	VARINT: 0,
+	BIT64: 1,
+	LENGTH_DELIMITED: 2,
+	START_GROUP: 3,
+	END_GROUP: 4,
+	BIT32: 5
+};
+function createCodec(name, type, encode, decode, stream) {
+	return {
+		name,
+		type,
+		encode,
+		decode,
+		stream
+	};
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/codecs/enum.js
+function enumeration(v) {
+	function findValue(val) {
+		if (v[val.toString()] == null) throw new Error("Invalid enum value");
+		return v[val];
+	}
+	return createCodec("enum", CODEC_TYPES.VARINT, function enumEncode(val, writer) {
+		const enumValue = findValue(val);
+		writer.int32(enumValue);
+	}, function enumDecode(reader) {
+		return findValue(reader.int32());
+	}, function* enumStream(reader) {
+		yield findValue(reader.int32());
+	});
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/codecs/message.js
+function message(encode, decode, stream) {
+	return createCodec("message", CODEC_TYPES.LENGTH_DELIMITED, encode, decode, stream);
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/protons-runtime/dist/src/index.js
+/**
+* Thrown when a repeated field has too many elements
+*/
+var MaxLengthError = class extends Error {
+	/**
+	* This will be removed in a future release
+	*
+	* @deprecated use the `.name` property instead
+	*/
+	code = "ERR_MAX_LENGTH";
+	name = "MaxLengthError";
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/ipfs-unixfs/dist/src/unixfs.js
+var Data;
+(function(Data) {
+	(function(DataType) {
+		DataType["Raw"] = "Raw";
+		DataType["Directory"] = "Directory";
+		DataType["File"] = "File";
+		DataType["Metadata"] = "Metadata";
+		DataType["Symlink"] = "Symlink";
+		DataType["HAMTShard"] = "HAMTShard";
+	})(Data.DataType || (Data.DataType = {}));
+	let __DataTypeValues;
+	(function(__DataTypeValues) {
+		__DataTypeValues[__DataTypeValues["Raw"] = 0] = "Raw";
+		__DataTypeValues[__DataTypeValues["Directory"] = 1] = "Directory";
+		__DataTypeValues[__DataTypeValues["File"] = 2] = "File";
+		__DataTypeValues[__DataTypeValues["Metadata"] = 3] = "Metadata";
+		__DataTypeValues[__DataTypeValues["Symlink"] = 4] = "Symlink";
+		__DataTypeValues[__DataTypeValues["HAMTShard"] = 5] = "HAMTShard";
+	})(__DataTypeValues || (__DataTypeValues = {}));
+	(function(DataType) {
+		DataType.codec = () => {
+			return enumeration(__DataTypeValues);
+		};
+	})(Data.DataType || (Data.DataType = {}));
+	let _codec;
+	Data.codec = () => {
+		if (_codec == null) _codec = message((obj, w, opts = {}) => {
+			if (opts.lengthDelimited !== false) w.fork();
+			if (obj.Type != null) {
+				w.uint32(8);
+				Data.DataType.codec().encode(obj.Type, w);
+			}
+			if (obj.Data != null) {
+				w.uint32(18);
+				w.bytes(obj.Data);
+			}
+			if (obj.filesize != null) {
+				w.uint32(24);
+				w.uint64(obj.filesize);
+			}
+			if (obj.blocksizes != null && obj.blocksizes.length > 0) for (const value of obj.blocksizes) {
+				w.uint32(32);
+				w.uint64(value);
+			}
+			if (obj.hashType != null) {
+				w.uint32(40);
+				w.uint64(obj.hashType);
+			}
+			if (obj.fanout != null) {
+				w.uint32(48);
+				w.uint64(obj.fanout);
+			}
+			if (obj.mode != null) {
+				w.uint32(56);
+				w.uint32(obj.mode);
+			}
+			if (obj.mtime != null) {
+				w.uint32(66);
+				UnixTime.codec().encode(obj.mtime, w);
+			}
+			if (opts.lengthDelimited !== false) w.ldelim();
+		}, (reader, length, opts = {}) => {
+			const obj = { blocksizes: [] };
+			const end = length == null ? reader.len : reader.pos + length;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				switch (tag >>> 3) {
+					case 1:
+						obj.Type = Data.DataType.codec().decode(reader);
+						break;
+					case 2:
+						obj.Data = reader.bytes();
+						break;
+					case 3:
+						obj.filesize = reader.uint64();
+						break;
+					case 4:
+						if (opts.limits?.blocksizes != null && obj.blocksizes.length === opts.limits.blocksizes) throw new MaxLengthError("Decode error - repeated field \"blocksizes\" had too many elements");
+						obj.blocksizes.push(reader.uint64());
+						break;
+					case 5:
+						obj.hashType = reader.uint64();
+						break;
+					case 6:
+						obj.fanout = reader.uint64();
+						break;
+					case 7:
+						obj.mode = reader.uint32();
+						break;
+					case 8:
+						obj.mtime = UnixTime.codec().decode(reader, reader.uint32(), { limits: opts.limits?.mtime });
+						break;
+					default:
+						reader.skipType(tag & 7);
+						break;
+				}
+			}
+			return obj;
+		}, function* (reader, length, prefix, opts = {}) {
+			const obj = { blocksizes: 0 };
+			const end = length == null ? reader.len : reader.pos + length;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				switch (tag >>> 3) {
+					case 1:
+						yield {
+							field: `${prefix}.Type`,
+							value: Data.DataType.codec().decode(reader)
+						};
+						break;
+					case 2:
+						yield {
+							field: `${prefix}.Data`,
+							value: reader.bytes()
+						};
+						break;
+					case 3:
+						yield {
+							field: `${prefix}.filesize`,
+							value: reader.uint64()
+						};
+						break;
+					case 4:
+						if (opts.limits?.blocksizes != null && obj.blocksizes === opts.limits.blocksizes) throw new MaxLengthError("Streaming decode error - repeated field \"blocksizes\" had too many elements");
+						yield {
+							field: `${prefix}.blocksizes[]`,
+							index: obj.blocksizes,
+							value: reader.uint64()
+						};
+						obj.blocksizes++;
+						break;
+					case 5:
+						yield {
+							field: `${prefix}.hashType`,
+							value: reader.uint64()
+						};
+						break;
+					case 6:
+						yield {
+							field: `${prefix}.fanout`,
+							value: reader.uint64()
+						};
+						break;
+					case 7:
+						yield {
+							field: `${prefix}.mode`,
+							value: reader.uint32()
+						};
+						break;
+					case 8:
+						yield* UnixTime.codec().stream(reader, reader.uint32(), `${prefix}.mtime`, { limits: opts.limits?.mtime });
+						break;
+					default:
+						reader.skipType(tag & 7);
+						break;
+				}
+			}
+		});
+		return _codec;
+	};
+	function encode(obj) {
+		return encodeMessage(obj, Data.codec());
+	}
+	Data.encode = encode;
+	function decode(buf, opts) {
+		return decodeMessage(buf, Data.codec(), opts);
+	}
+	Data.decode = decode;
+	function stream(buf, opts) {
+		return streamMessage(buf, Data.codec(), opts);
+	}
+	Data.stream = stream;
+})(Data || (Data = {}));
+var UnixTime;
+(function(UnixTime) {
+	let _codec;
+	UnixTime.codec = () => {
+		if (_codec == null) _codec = message((obj, w, opts = {}) => {
+			if (opts.lengthDelimited !== false) w.fork();
+			if (obj.Seconds != null) {
+				w.uint32(8);
+				w.int64(obj.Seconds);
+			}
+			if (obj.FractionalNanoseconds != null) {
+				w.uint32(21);
+				w.fixed32(obj.FractionalNanoseconds);
+			}
+			if (opts.lengthDelimited !== false) w.ldelim();
+		}, (reader, length, opts = {}) => {
+			const obj = {};
+			const end = length == null ? reader.len : reader.pos + length;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				switch (tag >>> 3) {
+					case 1:
+						obj.Seconds = reader.int64();
+						break;
+					case 2:
+						obj.FractionalNanoseconds = reader.fixed32();
+						break;
+					default:
+						reader.skipType(tag & 7);
+						break;
+				}
+			}
+			return obj;
+		}, function* (reader, length, prefix, opts = {}) {
+			const end = length == null ? reader.len : reader.pos + length;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				switch (tag >>> 3) {
+					case 1:
+						yield {
+							field: `${prefix}.Seconds`,
+							value: reader.int64()
+						};
+						break;
+					case 2:
+						yield {
+							field: `${prefix}.FractionalNanoseconds`,
+							value: reader.fixed32()
+						};
+						break;
+					default:
+						reader.skipType(tag & 7);
+						break;
+				}
+			}
+		});
+		return _codec;
+	};
+	function encode(obj) {
+		return encodeMessage(obj, UnixTime.codec());
+	}
+	UnixTime.encode = encode;
+	function decode(buf, opts) {
+		return decodeMessage(buf, UnixTime.codec(), opts);
+	}
+	UnixTime.decode = decode;
+	function stream(buf, opts) {
+		return streamMessage(buf, UnixTime.codec(), opts);
+	}
+	UnixTime.stream = stream;
+})(UnixTime || (UnixTime = {}));
+var Metadata;
+(function(Metadata) {
+	let _codec;
+	Metadata.codec = () => {
+		if (_codec == null) _codec = message((obj, w, opts = {}) => {
+			if (opts.lengthDelimited !== false) w.fork();
+			if (obj.MimeType != null) {
+				w.uint32(10);
+				w.string(obj.MimeType);
+			}
+			if (opts.lengthDelimited !== false) w.ldelim();
+		}, (reader, length, opts = {}) => {
+			const obj = {};
+			const end = length == null ? reader.len : reader.pos + length;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				switch (tag >>> 3) {
+					case 1:
+						obj.MimeType = reader.string();
+						break;
+					default:
+						reader.skipType(tag & 7);
+						break;
+				}
+			}
+			return obj;
+		}, function* (reader, length, prefix, opts = {}) {
+			const end = length == null ? reader.len : reader.pos + length;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				switch (tag >>> 3) {
+					case 1:
+						yield {
+							field: `${prefix}.MimeType`,
+							value: reader.string()
+						};
+						break;
+					default:
+						reader.skipType(tag & 7);
+						break;
+				}
+			}
+		});
+		return _codec;
+	};
+	function encode(obj) {
+		return encodeMessage(obj, Metadata.codec());
+	}
+	Metadata.encode = encode;
+	function decode(buf, opts) {
+		return decodeMessage(buf, Metadata.codec(), opts);
+	}
+	Metadata.decode = decode;
+	function stream(buf, opts) {
+		return streamMessage(buf, Metadata.codec(), opts);
+	}
+	Metadata.stream = stream;
+})(Metadata || (Metadata = {}));
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/node_modules/ipfs-unixfs/dist/src/index.js
+/**
+* @packageDocumentation
+*
+* This module contains the protobuf definition of the UnixFS data structure found at the root of all UnixFS DAGs.
+*
+* The UnixFS spec can be found in the [ipfs/specs repository](http://github.com/ipfs/specs)
+*
+* @example Create a file composed of several blocks
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+* data.addBlockSize(256n) // add the size of each block
+* data.addBlockSize(256n)
+* // ...
+* ```
+*
+* @example Create a directory that contains several files
+*
+* Creating a directory that contains several files is achieve by creating a unixfs element that identifies a MerkleDAG node as a directory. The links of that MerkleDAG node are the files that are contained in this directory.
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'directory' })
+* ```
+*
+* @example Create an unixfs Data element
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({
+*   // ...options
+* })
+* ```
+*
+* `options` is an optional object argument that might include the following keys:
+*
+* - type (string, default `file`): The type of UnixFS entry.  Can be:
+*   - `raw`
+*   - `directory`
+*   - `file`
+*   - `metadata`
+*   - `symlink`
+*   - `hamt-sharded-directory`
+* - data (Uint8Array): The optional data field for this node
+* - blockSizes (Array, default: `[]`): If this is a `file` node that is made up of multiple blocks, `blockSizes` is a list numbers that represent the size of the file chunks stored in each child node. It is used to calculate the total file size.
+* - mode (Number, default `0644` for files, `0755` for directories/hamt-sharded-directories) file mode
+* - mtime (`Date`, `{ secs, nsecs }`, `{ Seconds, FractionalNanoseconds }`, `[ secs, nsecs ]`): The modification time of this node
+*
+* @example Add and remove a block size to the block size list
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+* const sizeInBytes = 100n
+* data.addBlockSize(sizeInBytes)
+* ```
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+*
+* const index = 0
+* data.removeBlockSize(index)
+* ```
+*
+* @example Get total fileSize
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+* data.fileSize() // => size in bytes
+* ```
+*
+* @example Marshal and unmarshal
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+* const marshaled = data.marshal()
+* const unmarshaled = UnixFS.unmarshal(marshaled)
+* ```
+*
+* @example Is this UnixFS entry a directory?
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const dir = new UnixFS({ type: 'directory' })
+* dir.isDirectory() // true
+*
+* const file = new UnixFS({ type: 'file' })
+* file.isDirectory() // false
+* ```
+*
+* @example Has an mtime been set?
+*
+* If no modification time has been set, no `mtime` property will be present on the `Data` instance:
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const file = new UnixFS({ type: 'file' })
+* file.mtime // undefined
+*
+* Object.prototype.hasOwnProperty.call(file, 'mtime') // false
+*
+* const dir = new UnixFS({ type: 'directory', mtime: { secs: 5n } })
+* dir.mtime // { secs: Number, nsecs: Number }
+* ```
+*/
+const types = {
+	Raw: "raw",
+	Directory: "directory",
+	File: "file",
+	Metadata: "metadata",
+	Symlink: "symlink",
+	HAMTShard: "hamt-sharded-directory"
+};
+const dirTypes = ["directory", "hamt-sharded-directory"];
+const DEFAULT_FILE_MODE = parseInt("0644", 8);
+const DEFAULT_DIRECTORY_MODE = parseInt("0755", 8);
+var UnixFS = class UnixFS {
+	/**
+	* Decode from protobuf https://github.com/ipfs/specs/blob/master/UNIXFS.md
+	*/
+	static unmarshal(marshaled) {
+		const message = Data.decode(marshaled);
+		const data = new UnixFS({
+			type: types[message.Type != null ? message.Type.toString() : "File"],
+			data: message.Data,
+			blockSizes: message.blocksizes,
+			mode: message.mode,
+			mtime: message.mtime != null ? {
+				secs: message.mtime.Seconds ?? 0n,
+				nsecs: message.mtime.FractionalNanoseconds
+			} : void 0,
+			fanout: message.fanout
+		});
+		data._originalMode = message.mode ?? 0;
+		return data;
+	}
+	type;
+	data;
+	blockSizes;
+	hashType;
+	fanout;
+	mtime;
+	_mode;
+	_originalMode;
+	constructor(options = { type: "file" }) {
+		const { type, data, blockSizes, hashType, fanout, mtime, mode } = options;
+		if (type != null && !Object.values(types).includes(type)) throw new InvalidTypeError("Type: " + type + " is not valid");
+		this.type = type ?? "file";
+		this.data = data;
+		this.hashType = hashType;
+		this.fanout = fanout;
+		this.blockSizes = blockSizes ?? [];
+		this._originalMode = 0;
+		this.mode = mode;
+		this.mtime = mtime;
+	}
+	set mode(mode) {
+		if (mode == null) this._mode = this.isDirectory() ? DEFAULT_DIRECTORY_MODE : DEFAULT_FILE_MODE;
+		else this._mode = mode & 4095;
+	}
+	get mode() {
+		return this._mode;
+	}
+	isDirectory() {
+		return dirTypes.includes(this.type);
+	}
+	addBlockSize(size) {
+		this.blockSizes.push(size);
+	}
+	removeBlockSize(index) {
+		this.blockSizes.splice(index, 1);
+	}
+	/**
+	* Returns `0n` for directories or `data.length + sum(blockSizes)` for everything else
+	*/
+	fileSize() {
+		if (this.isDirectory()) return 0n;
+		let sum = 0n;
+		this.blockSizes.forEach((size) => {
+			sum += size;
+		});
+		if (this.data != null) sum += BigInt(this.data.length);
+		return sum;
+	}
+	/**
+	* encode to protobuf Uint8Array
+	*/
+	marshal() {
+		let type;
+		switch (this.type) {
+			case "raw":
+				type = Data.DataType.Raw;
+				break;
+			case "directory":
+				type = Data.DataType.Directory;
+				break;
+			case "file":
+				type = Data.DataType.File;
+				break;
+			case "metadata":
+				type = Data.DataType.Metadata;
+				break;
+			case "symlink":
+				type = Data.DataType.Symlink;
+				break;
+			case "hamt-sharded-directory":
+				type = Data.DataType.HAMTShard;
+				break;
+			default: throw new InvalidTypeError(`Type: ${type} is not valid`);
+		}
+		let data = this.data;
+		if (this.data == null || this.data.length === 0) data = void 0;
+		let mode;
+		if (this.mode != null) {
+			mode = this._originalMode & 4294963200 | (this.mode ?? 0);
+			if (mode === DEFAULT_FILE_MODE && !this.isDirectory()) mode = void 0;
+			if (mode === DEFAULT_DIRECTORY_MODE && this.isDirectory()) mode = void 0;
+		}
+		let mtime;
+		if (this.mtime != null) mtime = {
+			Seconds: this.mtime.secs,
+			FractionalNanoseconds: this.mtime.nsecs
+		};
+		return Data.encode({
+			Type: type,
+			Data: data,
+			filesize: this.isDirectory() ? void 0 : this.fileSize(),
+			blocksizes: this.blockSizes,
+			hashType: this.hashType,
+			fanout: this.fanout,
+			mode,
+			mtime
+		});
+	}
+};
+//#endregion
+//#region node_modules/progress-events/dist/src/index.js
+/**
+* An implementation of the ProgressEvent interface, this is essentially
+* a typed `CustomEvent` with a `type` property that lets us disambiguate
+* events passed to `progress` callbacks.
+*/
+var CustomProgressEvent = class extends Event {
+	type;
+	detail;
+	constructor(type, detail) {
+		super(type);
+		this.type = type;
+		this.detail = detail;
+	}
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/utils/persist.js
+const persist = async (buffer, blockstore, options) => {
+	if (options.codec == null) options.codec = src_exports;
+	const multihash = await sha256.digest(buffer);
+	const cid = CID.create(options.cidVersion ?? 1, options.codec.code, multihash);
+	await blockstore.put(cid, buffer, options);
+	return cid;
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/dag-builder/buffer-importer.js
+function defaultBufferImporter(options) {
+	return async function* bufferImporter(file, blockstore) {
+		let bytesWritten = 0n;
+		for await (let block of file.content) yield async () => {
+			let unixfs;
+			const opts = {
+				codec: src_exports,
+				cidVersion: options.cidVersion,
+				onProgress: options.onProgress
+			};
+			if (options.rawLeaves) {
+				opts.codec = raw;
+				opts.cidVersion = 1;
+			} else {
+				unixfs = new UnixFS({
+					type: options.leafType,
+					data: block
+				});
+				block = encode({
+					Data: unixfs.marshal(),
+					Links: []
+				});
+			}
+			const cid = await persist(block, blockstore, opts);
+			bytesWritten += BigInt(block.byteLength);
+			options.onProgress?.(new CustomProgressEvent("unixfs:importer:progress:file:write", {
+				bytesWritten,
+				cid,
+				path: file.path
+			}));
+			return {
+				cid,
+				unixfs,
+				size: BigInt(block.length),
+				block
+			};
+		};
+	};
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/errors.js
+var InvalidParametersError = class InvalidParametersError extends Error {
+	static name = "InvalidParametersError";
+	static code = "ERR_INVALID_PARAMS";
+	name = InvalidParametersError.name;
+	code = InvalidParametersError.code;
+	constructor(message = "Invalid parameters") {
+		super(message);
+	}
+};
+var InvalidContentError = class InvalidContentError extends Error {
+	static name = "InvalidContentError";
+	static code = "ERR_INVALID_CONTENT";
+	name = InvalidContentError.name;
+	code = InvalidContentError.code;
+	constructor(message = "Invalid content") {
+		super(message);
+	}
+};
+var InvalidShardingStrategyError = class extends Error {
+	static name = "InvalidShardingStrategyError";
+	static code = "ERR_SHARDING_STRATEGY";
+	name = InvalidContentError.name;
+	code = InvalidContentError.code;
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/dag-builder/dir.js
+const defaultDirBuilder = async (dir, blockstore, options) => {
+	const unixfs = new UnixFS({
+		type: "directory",
+		mtime: dir.mtime,
+		mode: dir.mode
+	});
+	const block = encode(prepare({ Data: unixfs.marshal() }));
+	return {
+		cid: await persist(block, blockstore, options),
+		path: dir.path,
+		unixfs,
+		size: BigInt(block.length),
+		originalPath: dir.originalPath,
+		block
+	};
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/dag-builder/file.js
+async function* buildFileBatch(file, blockstore, options) {
+	let count = -1;
+	let previous;
+	for await (const entry of parallelBatch(options.bufferImporter(file, blockstore), options.blockWriteConcurrency)) {
+		count++;
+		if (count === 0) {
+			previous = {
+				...entry,
+				single: true
+			};
+			continue;
+		} else if (count === 1 && previous != null) {
+			yield {
+				...previous,
+				block: void 0,
+				single: void 0
+			};
+			previous = void 0;
+		}
+		yield {
+			...entry,
+			block: void 0
+		};
+	}
+	if (previous != null) yield previous;
+}
+function isSingleBlockImport(result) {
+	return result.single === true;
+}
+const reduce = (file, blockstore, options) => {
+	const reducer = async function(leaves) {
+		if (leaves.length === 1 && isSingleBlockImport(leaves[0]) && options.reduceSingleLeafToSelf) {
+			const leaf = leaves[0];
+			let node = leaf.block;
+			if (isSingleBlockImport(leaf) && (file.mtime !== void 0 || file.mode !== void 0)) {
+				leaf.unixfs = new UnixFS({
+					type: "file",
+					mtime: file.mtime,
+					mode: file.mode,
+					data: leaf.block
+				});
+				node = {
+					Data: leaf.unixfs.marshal(),
+					Links: []
+				};
+				leaf.block = encode(prepare(node));
+				leaf.cid = await persist(leaf.block, blockstore, {
+					...options,
+					cidVersion: options.cidVersion
+				});
+				leaf.size = BigInt(leaf.block.length);
+			}
+			options.onProgress?.(new CustomProgressEvent("unixfs:importer:progress:file:layout", {
+				cid: leaf.cid,
+				path: file.originalPath
+			}));
+			return {
+				cid: leaf.cid,
+				path: file.path,
+				unixfs: leaf.unixfs,
+				size: leaf.size,
+				originalPath: file.originalPath
+			};
+		}
+		const f = new UnixFS({
+			type: "file",
+			mtime: file.mtime,
+			mode: file.mode
+		});
+		const links = leaves.filter((leaf) => {
+			if (leaf.cid.code === raw.code && leaf.size > 0) return true;
+			if (leaf.unixfs != null && leaf.unixfs.data == null && leaf.unixfs.fileSize() > 0n) return true;
+			return Boolean(leaf.unixfs?.data?.length);
+		}).map((leaf) => {
+			if (leaf.cid.code === raw.code) {
+				f.addBlockSize(leaf.size);
+				return {
+					Name: "",
+					Tsize: Number(leaf.size),
+					Hash: leaf.cid
+				};
+			}
+			if (leaf.unixfs?.data == null) f.addBlockSize(leaf.unixfs?.fileSize() ?? 0n);
+			else f.addBlockSize(BigInt(leaf.unixfs.data.length));
+			return {
+				Name: "",
+				Tsize: Number(leaf.size),
+				Hash: leaf.cid
+			};
+		});
+		const node = {
+			Data: f.marshal(),
+			Links: links
+		};
+		const block = encode(prepare(node));
+		const cid = await persist(block, blockstore, options);
+		options.onProgress?.(new CustomProgressEvent("unixfs:importer:progress:file:layout", {
+			cid,
+			path: file.originalPath
+		}));
+		return {
+			cid,
+			path: file.path,
+			unixfs: f,
+			size: BigInt(block.length + node.Links.reduce((acc, curr) => acc + (curr.Tsize ?? 0), 0)),
+			originalPath: file.originalPath,
+			block
+		};
+	};
+	return reducer;
+};
+const defaultFileBuilder = async (file, block, options) => {
+	return options.layout(buildFileBatch(file, block, options), reduce(file, block, options));
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/dag-builder/index.js
+function isIterable(thing) {
+	return Symbol.iterator in thing;
+}
+function isAsyncIterable(thing) {
+	return Symbol.asyncIterator in thing;
+}
+function contentAsAsyncIterable(content) {
+	try {
+		if (content instanceof Uint8Array) return (async function* () {
+			yield content;
+		})();
+		else if (isIterable(content)) return (async function* () {
+			yield* content;
+		})();
+		else if (isAsyncIterable(content)) return content;
+	} catch {
+		throw new InvalidContentError("Content was invalid");
+	}
+	throw new InvalidContentError("Content was invalid");
+}
+function defaultDagBuilder(options) {
+	return async function* dagBuilder(source, blockstore) {
+		for await (const entry of source) {
+			let originalPath;
+			if (entry.path != null) {
+				originalPath = entry.path;
+				entry.path = entry.path.split("/").filter((path) => path != null && path !== ".").join("/");
+			}
+			if (isFileCandidate(entry)) {
+				const file = {
+					path: entry.path,
+					mtime: entry.mtime,
+					mode: entry.mode,
+					content: (async function* () {
+						let bytesRead = 0n;
+						for await (const chunk of options.chunker(options.chunkValidator(contentAsAsyncIterable(entry.content)))) {
+							const currentChunkSize = BigInt(chunk.byteLength);
+							bytesRead += currentChunkSize;
+							options.onProgress?.(new CustomProgressEvent("unixfs:importer:progress:file:read", {
+								bytesRead,
+								chunkSize: currentChunkSize,
+								path: entry.path
+							}));
+							yield chunk;
+						}
+					})(),
+					originalPath
+				};
+				const fileBuilder = options.fileBuilder ?? defaultFileBuilder;
+				yield async () => fileBuilder(file, blockstore, options);
+			} else if (entry.path != null) {
+				const dir = {
+					path: entry.path,
+					mtime: entry.mtime,
+					mode: entry.mode,
+					originalPath
+				};
+				const dirBuilder = options.dirBuilder ?? defaultDirBuilder;
+				yield async () => dirBuilder(dir, blockstore, options);
+			} else throw new Error("Import candidate must have content or path or both");
+		}
+	};
+}
+function isFileCandidate(entry) {
+	return entry.content != null;
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/dag-builder/validate-chunks.js
+const defaultChunkValidator = () => {
+	return async function* validateChunks(source) {
+		for await (const content of source) {
+			if (content.length === void 0) throw new InvalidContentError("Content was invalid");
+			if (typeof content === "string" || content instanceof String) yield fromString(content.toString());
+			else if (Array.isArray(content)) yield Uint8Array.from(content);
+			else if (content instanceof Uint8Array) yield content;
+			else throw new InvalidContentError("Content was invalid");
+		}
+	};
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/layout/balanced.js
+const DEFAULT_MAX_CHILDREN_PER_NODE = 174;
+function balanced(options) {
+	const maxChildrenPerNode = options?.maxChildrenPerNode ?? DEFAULT_MAX_CHILDREN_PER_NODE;
+	return async function balancedLayout(source, reduce) {
+		const roots = [];
+		for await (const chunked of batch(source, maxChildrenPerNode)) roots.push(await reduce(chunked));
+		if (roots.length > 1) return balancedLayout(roots, reduce);
+		return roots[0];
+	};
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/dir.js
+var Dir = class {
+	options;
+	root;
+	dir;
+	path;
+	dirty;
+	flat;
+	parent;
+	parentKey;
+	unixfs;
+	mode;
+	mtime;
+	cid;
+	size;
+	nodeSize;
+	constructor(props, options) {
+		this.options = options ?? {};
+		this.root = props.root;
+		this.dir = props.dir;
+		this.path = props.path;
+		this.dirty = props.dirty;
+		this.flat = props.flat;
+		this.parent = props.parent;
+		this.parentKey = props.parentKey;
+		this.unixfs = props.unixfs;
+		this.mode = props.mode;
+		this.mtime = props.mtime;
+	}
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/utils/pb-size.js
+/**
+* Protobuf size calculation utilities for DAG-PB nodes.
+*
+* Computes exact serialized sizes matching @ipld/dag-pb's encoding
+* without allocating byte arrays. Used by DirFlat to avoid O(N)
+* re-serialization on every file insert.
+*
+* Ported from @ipld/dag-pb/src/pb-encode.js (sov, len64, sizeLink, sizeNode)
+* and boxo's directory.go estimatedSize logic.
+*/
+const maxInt32 = 2 ** 32;
+const len8tab = [
+	0,
+	1,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8
+];
+function len64(x) {
+	let n = 0;
+	if (x >= maxInt32) {
+		x = Math.floor(x / maxInt32);
+		n = 32;
+	}
+	if (x >= 65536) {
+		x >>>= 16;
+		n += 16;
+	}
+	if (x >= 256) {
+		x >>>= 8;
+		n += 8;
+	}
+	return n + len8tab[x];
+}
+/**
+* Protobuf varint byte size, matching @ipld/dag-pb's sov().
+*/
+function varintLen(x) {
+	if (x % 2 === 0) x++;
+	return Math.floor((len64(x) + 6) / 7);
+}
+/**
+* Compute UTF-8 byte length of a JS string without allocation.
+*
+* Safe to assume UTF-8 because @ipld/dag-pb always encodes PBLink.Name
+* via TextEncoder (UTF-8) and decodes via TextDecoder (UTF-8).
+* This produces the same result as textEncoder.encode(str).length
+* without the Uint8Array allocation on every put() call.
+*/
+function utf8ByteLength(str) {
+	let len = 0;
+	for (let i = 0; i < str.length; i++) {
+		const c = str.charCodeAt(i);
+		if (c < 128) len++;
+		else if (c < 2048) len += 2;
+		else if (c >= 55296 && c <= 56319 && i + 1 < str.length) {
+			i++;
+			len += 4;
+		} else len += 3;
+	}
+	return len;
+}
+/**
+* Exact bytes a single PBLink adds to the PBNode encoding.
+*
+* Matches sizeLink() + its wrapper in sizeNode() from pb-encode.js:
+* linkLen = Hash(1+sov(cidLen)+cidLen) + Name(1+sov(nameLen)+nameLen) + Tsize(1+sov(tsize))
+* total   = 1 + sov(linkLen) + linkLen
+*/
+function linkSerializedSize(nameByteLen, cidByteLength, tsize) {
+	let linkLen = 1 + varintLen(cidByteLength) + cidByteLength;
+	linkLen += 1 + varintLen(nameByteLen) + nameByteLen;
+	linkLen += 1 + varintLen(tsize);
+	return 1 + varintLen(linkLen) + linkLen;
+}
+const DIR_DEFAULT_MODE = 493;
+/**
+* Exact bytes the PBNode Data field adds for a UnixFS directory.
+*
+* Directory-only: the type field is hardcoded to directory (2 bytes) and
+* the default mode is 0o755. Do not use for file nodes (different type
+* byte, different default mode 0o644).
+*
+* For the common case (no mode, no mtime) this is always 4 bytes:
+* innerSize=2 [0x08,0x01], wrapper 1+1+2=4.
+*/
+function dataFieldSerializedSize(mode, mtime) {
+	let innerSize = 2;
+	if (mode !== void 0 && mode !== DIR_DEFAULT_MODE) innerSize += 1 + varintLen(mode);
+	if (mtime != null) {
+		let mtimeInner = 0;
+		const secs = Number(mtime.secs);
+		if (secs < 0) mtimeInner += 11;
+		else mtimeInner += 1 + varintLen(secs);
+		if (mtime.nsecs != null) mtimeInner += 5;
+		innerSize += 1 + varintLen(mtimeInner) + mtimeInner;
+	}
+	return 1 + varintLen(innerSize) + innerSize;
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/dir-flat.js
+function estimateLinkSize(nameBytes, child) {
+	if (child?.cid != null && child?.size != null) return nameBytes + child.cid.byteLength;
+	return 0;
+}
+function calculateLinkSize(nameBytes, child) {
+	if (child?.cid != null && child?.size != null) return linkSerializedSize(nameBytes, child.cid.byteLength, Number(child.size));
+	return 0;
+}
+var DirFlat = class extends Dir {
+	_children;
+	constructor(props, options) {
+		super(props, options);
+		this._children = /* @__PURE__ */ new Map();
+	}
+	async put(name, value) {
+		if (this.nodeSize !== void 0) {
+			const oldChild = this._children.get(name);
+			const nameBytes = utf8ByteLength(name);
+			const strategy = this.options?.shardSplitStrategy;
+			if (strategy === "links-bytes") {
+				this.nodeSize -= estimateLinkSize(nameBytes, oldChild);
+				this.nodeSize += estimateLinkSize(nameBytes, value);
+			} else if (strategy === "block-bytes") {
+				this.nodeSize -= calculateLinkSize(nameBytes, oldChild);
+				this.nodeSize += calculateLinkSize(nameBytes, value);
+			} else throw new InvalidShardingStrategyError(`Invalid shardSplitStrategy: ${strategy}`);
+			if (this.nodeSize < 0) this.nodeSize = void 0;
+		}
+		this.cid = void 0;
+		this.size = void 0;
+		this._children.set(name, value);
+	}
+	async get(name) {
+		return Promise.resolve(this._children.get(name));
+	}
+	childCount() {
+		return this._children.size;
+	}
+	directChildrenCount() {
+		return this.childCount();
+	}
+	onlyChild() {
+		return this._children.values().next().value;
+	}
+	*eachChildSeries() {
+		for (const [key, child] of this._children.entries()) yield {
+			key,
+			child
+		};
+	}
+	marshal() {
+		const unixfs = new UnixFS({
+			type: "directory",
+			mtime: this.mtime,
+			mode: this.mode
+		});
+		const links = [];
+		for (const [name, child] of this._children.entries()) {
+			if (child.size == null || child.cid == null) continue;
+			if (child.cid == null) throw new Error("Directory contents must be flushed before marshaling");
+			links.push({
+				Hash: child.cid,
+				Name: name,
+				Tsize: child.size == null ? void 0 : Number(child.size)
+			});
+		}
+		return encode(prepare({
+			Data: unixfs.marshal(),
+			Links: links
+		}));
+	}
+	async estimateNodeSize() {
+		if (this.nodeSize !== void 0) return this.nodeSize;
+		const strategy = this.options?.shardSplitStrategy;
+		if (strategy === "links-bytes") {
+			this.nodeSize = 0;
+			for (const [name, child] of this._children.entries()) this.nodeSize += estimateLinkSize(utf8ByteLength(name), child);
+		} else if (strategy === "block-bytes") {
+			this.nodeSize = dataFieldSerializedSize(this.mode, this.mtime);
+			for (const [name, child] of this._children.entries()) this.nodeSize += calculateLinkSize(utf8ByteLength(name), child);
+		} else throw new InvalidShardingStrategyError(`Invalid shardSplitStrategy: ${strategy}`);
+		return this.nodeSize;
+	}
+	async *flush(block) {
+		const links = [];
+		for (const [name, child] of this._children.entries()) {
+			let result = child;
+			if (child instanceof Dir) for await (const entry of child.flush(block)) {
+				result = entry;
+				yield entry;
+			}
+			if (result.size != null && result.cid != null) links.push({
+				Name: name,
+				Tsize: Number(result.size),
+				Hash: result.cid
+			});
+		}
+		const unixfs = new UnixFS({
+			type: "directory",
+			mtime: this.mtime,
+			mode: this.mode
+		});
+		const node = {
+			Data: unixfs.marshal(),
+			Links: links
+		};
+		const buffer = encode(prepare(node));
+		const cid = await persist(buffer, block, this.options);
+		const size = buffer.length + node.Links.reduce(
+			/**
+			* @param {number} acc
+			* @param {PBLink} curr
+			*/
+			(acc, curr) => acc + (curr.Tsize ?? 0),
+			0
+		);
+		this.cid = cid;
+		this.size = size;
+		yield {
+			cid,
+			unixfs,
+			path: this.path,
+			size: BigInt(size)
+		};
+	}
+};
+//#endregion
+//#region node_modules/hamt-sharding/dist/src/bucket.js
+var import_sparse_array = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const BITS_PER_BYTE = 7;
+	module.exports = class SparseArray {
+		constructor() {
+			this._bitArrays = [];
+			this._data = [];
+			this._length = 0;
+			this._changedLength = false;
+			this._changedData = false;
+		}
+		set(index, value) {
+			let pos = this._internalPositionFor(index, false);
+			if (value === void 0) {
+				if (pos !== -1) {
+					this._unsetInternalPos(pos);
+					this._unsetBit(index);
+					this._changedLength = true;
+					this._changedData = true;
+				}
+			} else {
+				let needsSort = false;
+				if (pos === -1) {
+					pos = this._data.length;
+					this._setBit(index);
+					this._changedData = true;
+				} else needsSort = true;
+				this._setInternalPos(pos, index, value, needsSort);
+				this._changedLength = true;
+			}
+		}
+		unset(index) {
+			this.set(index, void 0);
+		}
+		get(index) {
+			this._sortData();
+			const pos = this._internalPositionFor(index, true);
+			if (pos === -1) return;
+			return this._data[pos][1];
+		}
+		push(value) {
+			this.set(this.length, value);
+			return this.length;
+		}
+		get length() {
+			this._sortData();
+			if (this._changedLength) {
+				const last = this._data[this._data.length - 1];
+				this._length = last ? last[0] + 1 : 0;
+				this._changedLength = false;
+			}
+			return this._length;
+		}
+		forEach(iterator) {
+			let i = 0;
+			while (i < this.length) {
+				iterator(this.get(i), i, this);
+				i++;
+			}
+		}
+		map(iterator) {
+			let i = 0;
+			let mapped = new Array(this.length);
+			while (i < this.length) {
+				mapped[i] = iterator(this.get(i), i, this);
+				i++;
+			}
+			return mapped;
+		}
+		reduce(reducer, initialValue) {
+			let i = 0;
+			let acc = initialValue;
+			while (i < this.length) {
+				const value = this.get(i);
+				acc = reducer(acc, value, i);
+				i++;
+			}
+			return acc;
+		}
+		find(finder) {
+			let i = 0, found, last;
+			while (i < this.length && !found) {
+				last = this.get(i);
+				found = finder(last);
+				i++;
+			}
+			return found ? last : void 0;
+		}
+		_internalPositionFor(index, noCreate) {
+			const bytePos = this._bytePosFor(index, noCreate);
+			if (bytePos >= this._bitArrays.length) return -1;
+			const byte = this._bitArrays[bytePos];
+			const bitPos = index - bytePos * BITS_PER_BYTE;
+			if (!((byte & 1 << bitPos) > 0)) return -1;
+			return this._bitArrays.slice(0, bytePos).reduce(popCountReduce, 0) + popCount(byte & ~(4294967295 << bitPos + 1)) - 1;
+		}
+		_bytePosFor(index, noCreate) {
+			const bytePos = Math.floor(index / BITS_PER_BYTE);
+			const targetLength = bytePos + 1;
+			while (!noCreate && this._bitArrays.length < targetLength) this._bitArrays.push(0);
+			return bytePos;
+		}
+		_setBit(index) {
+			const bytePos = this._bytePosFor(index, false);
+			this._bitArrays[bytePos] |= 1 << index - bytePos * BITS_PER_BYTE;
+		}
+		_unsetBit(index) {
+			const bytePos = this._bytePosFor(index, false);
+			this._bitArrays[bytePos] &= ~(1 << index - bytePos * BITS_PER_BYTE);
+		}
+		_setInternalPos(pos, index, value, needsSort) {
+			const data = this._data;
+			const elem = [index, value];
+			if (needsSort) {
+				this._sortData();
+				data[pos] = elem;
+			} else {
+				if (data.length) if (data[data.length - 1][0] >= index) data.push(elem);
+				else if (data[0][0] <= index) data.unshift(elem);
+				else {
+					const randomIndex = Math.round(data.length / 2);
+					this._data = data.slice(0, randomIndex).concat(elem).concat(data.slice(randomIndex));
+				}
+				else this._data.push(elem);
+				this._changedData = true;
+				this._changedLength = true;
+			}
+		}
+		_unsetInternalPos(pos) {
+			this._data.splice(pos, 1);
+		}
+		_sortData() {
+			if (this._changedData) this._data.sort(sortInternal);
+			this._changedData = false;
+		}
+		bitField() {
+			const bytes = [];
+			let pendingBitsForResultingByte = 8;
+			let pendingBitsForNewByte = 0;
+			let resultingByte = 0;
+			let newByte;
+			const pending = this._bitArrays.slice();
+			while (pending.length || pendingBitsForNewByte) {
+				if (pendingBitsForNewByte === 0) {
+					newByte = pending.shift();
+					pendingBitsForNewByte = 7;
+				}
+				const usingBits = Math.min(pendingBitsForNewByte, pendingBitsForResultingByte);
+				const mask = ~(255 << usingBits);
+				const masked = newByte & mask;
+				resultingByte |= masked << 8 - pendingBitsForResultingByte;
+				newByte = newByte >>> usingBits;
+				pendingBitsForNewByte -= usingBits;
+				pendingBitsForResultingByte -= usingBits;
+				if (!pendingBitsForResultingByte || !pendingBitsForNewByte && !pending.length) {
+					bytes.push(resultingByte);
+					resultingByte = 0;
+					pendingBitsForResultingByte = 8;
+				}
+			}
+			for (var i = bytes.length - 1; i > 0; i--) if (bytes[i] === 0) bytes.pop();
+			else break;
+			return bytes;
+		}
+		compactArray() {
+			this._sortData();
+			return this._data.map(valueOnly);
+		}
+	};
+	function popCountReduce(count, byte) {
+		return count + popCount(byte);
+	}
+	function popCount(_v) {
+		let v = _v;
+		v = v - (v >> 1 & 1431655765);
+		v = (v & 858993459) + (v >> 2 & 858993459);
+		return (v + (v >> 4) & 252645135) * 16843009 >> 24;
+	}
+	function sortInternal(a, b) {
+		return a[0] - b[0];
+	}
+	function valueOnly(elem) {
+		return elem[1];
+	}
+})))(), 1);
+var Bucket = class Bucket {
+	_options;
+	_popCount;
+	_parent;
+	_posAtParent;
+	_children;
+	key;
+	constructor(options, parent, posAtParent = 0) {
+		this._options = options;
+		this._popCount = 0;
+		this._parent = parent;
+		this._posAtParent = posAtParent;
+		this._children = new import_sparse_array.default();
+		this.key = null;
+	}
+	async put(key, value) {
+		const place = await this._findNewBucketAndPos(key);
+		place.bucket._putAt(place, key, value);
+	}
+	async get(key) {
+		const child = await this._findChild(key);
+		if (child != null) return child.value;
+	}
+	async del(key) {
+		const place = await this._findPlace(key);
+		const child = place.bucket._at(place.pos);
+		if (child != null && child.key === key) place.bucket._delAt(place.pos);
+	}
+	leafCount() {
+		return this._children.compactArray().reduce((acc, child) => {
+			if (child instanceof Bucket) return acc + child.leafCount();
+			return acc + 1;
+		}, 0);
+	}
+	childrenCount() {
+		return this._children.length;
+	}
+	onlyChild() {
+		return this._children.get(0);
+	}
+	*eachLeafSeries() {
+		const children = this._children.compactArray();
+		for (const child of children) if (child instanceof Bucket) yield* child.eachLeafSeries();
+		else yield child;
+	}
+	serialize(map, reduce) {
+		return reduce(this._children.reduce((acc, child, index) => {
+			if (child != null) if (child instanceof Bucket) acc.push(child.serialize(map, reduce));
+			else acc.push(map(child, index));
+			return acc;
+		}, []));
+	}
+	async asyncTransform(asyncMap, asyncReduce) {
+		return asyncTransformBucket(this, asyncMap, asyncReduce);
+	}
+	toJSON() {
+		return this.serialize(mapNode, reduceNodes);
+	}
+	prettyPrint() {
+		return JSON.stringify(this.toJSON(), null, "  ");
+	}
+	tableSize() {
+		return Math.pow(2, this._options.bits);
+	}
+	async _findChild(key) {
+		const result = await this._findPlace(key);
+		const child = result.bucket._at(result.pos);
+		if (child instanceof Bucket) return;
+		if (child != null && child.key === key) return child;
+	}
+	async _findPlace(key) {
+		const hashValue = this._options.hash(typeof key === "string" ? fromString(key) : key);
+		const index = await hashValue.take(this._options.bits);
+		const child = this._children.get(index);
+		if (child instanceof Bucket) return child._findPlace(hashValue);
+		return {
+			bucket: this,
+			pos: index,
+			hash: hashValue,
+			existingChild: child
+		};
+	}
+	async _findNewBucketAndPos(key) {
+		const place = await this._findPlace(key);
+		if (place.existingChild != null && place.existingChild.key !== key) {
+			const bucket = new Bucket(this._options, place.bucket, place.pos);
+			place.bucket._putObjectAt(place.pos, bucket);
+			const newPlace = await bucket._findPlace(place.existingChild.hash);
+			newPlace.bucket._putAt(newPlace, place.existingChild.key, place.existingChild.value);
+			return bucket._findNewBucketAndPos(place.hash);
+		}
+		return place;
+	}
+	_putAt(place, key, value) {
+		this._putObjectAt(place.pos, {
+			key,
+			value,
+			hash: place.hash
+		});
+	}
+	_putObjectAt(pos, object) {
+		if (this._children.get(pos) == null) this._popCount++;
+		this._children.set(pos, object);
+	}
+	_delAt(pos) {
+		if (pos === -1) throw new Error("Invalid position");
+		if (this._children.get(pos) != null) this._popCount--;
+		this._children.unset(pos);
+		this._level();
+	}
+	_level() {
+		if (this._parent != null && this._popCount <= 1) if (this._popCount === 1) {
+			const onlyChild = this._children.find(exists);
+			if (onlyChild != null && !(onlyChild instanceof Bucket)) {
+				const hash = onlyChild.hash;
+				hash.untake(this._options.bits);
+				const place = {
+					pos: this._posAtParent,
+					hash,
+					bucket: this._parent
+				};
+				this._parent._putAt(place, onlyChild.key, onlyChild.value);
+			}
+		} else this._parent._delAt(this._posAtParent);
+	}
+	_at(index) {
+		return this._children.get(index);
+	}
+};
+function exists(o) {
+	return Boolean(o);
+}
+function mapNode(node, _) {
+	return node.key;
+}
+function reduceNodes(nodes) {
+	return nodes;
+}
+async function asyncTransformBucket(bucket, asyncMap, asyncReduce) {
+	const output = [];
+	for (const child of bucket._children.compactArray()) if (child instanceof Bucket) await asyncTransformBucket(child, asyncMap, asyncReduce);
+	else {
+		const mappedChildren = await asyncMap(child);
+		output.push({
+			bitField: bucket._children.bitField(),
+			children: mappedChildren
+		});
+	}
+	return asyncReduce(output);
+}
+//#endregion
+//#region node_modules/hamt-sharding/dist/src/consumable-buffer.js
+const START_MASKS = [
+	255,
+	254,
+	252,
+	248,
+	240,
+	224,
+	192,
+	128
+];
+const STOP_MASKS = [
+	1,
+	3,
+	7,
+	15,
+	31,
+	63,
+	127,
+	255
+];
+var ConsumableBuffer = class {
+	_value;
+	_currentBytePos;
+	_currentBitPos;
+	constructor(value) {
+		this._value = value;
+		this._currentBytePos = value.length - 1;
+		this._currentBitPos = 7;
+	}
+	availableBits() {
+		return this._currentBitPos + 1 + this._currentBytePos * 8;
+	}
+	totalBits() {
+		return this._value.length * 8;
+	}
+	take(bits) {
+		let pendingBits = bits;
+		let result = 0;
+		while (pendingBits > 0 && this._haveBits()) {
+			const byte = this._value[this._currentBytePos];
+			const availableBits = this._currentBitPos + 1;
+			const taking = Math.min(availableBits, pendingBits);
+			const value = byteBitsToInt(byte, availableBits - taking, taking);
+			result = (result << taking) + value;
+			pendingBits -= taking;
+			this._currentBitPos -= taking;
+			if (this._currentBitPos < 0) {
+				this._currentBitPos = 7;
+				this._currentBytePos--;
+			}
+		}
+		return result;
+	}
+	untake(bits) {
+		this._currentBitPos += bits;
+		while (this._currentBitPos > 7) {
+			this._currentBitPos -= 8;
+			this._currentBytePos += 1;
+		}
+	}
+	_haveBits() {
+		return this._currentBytePos >= 0;
+	}
+};
+function byteBitsToInt(byte, start, length) {
+	return (byte & maskFor(start, length)) >>> start;
+}
+function maskFor(start, length) {
+	return START_MASKS[start] & STOP_MASKS[Math.min(length + start - 1, 7)];
+}
+//#endregion
+//#region node_modules/hamt-sharding/dist/src/consumable-hash.js
+function wrapHash(hashFn) {
+	function hashing(value) {
+		if (value instanceof InfiniteHash) return value;
+		else return new InfiniteHash(value, hashFn);
+	}
+	return hashing;
+}
+var InfiniteHash = class {
+	_value;
+	_hashFn;
+	_depth;
+	_availableBits;
+	_currentBufferIndex;
+	_buffers;
+	constructor(value, hashFn) {
+		if (!(value instanceof Uint8Array)) throw new Error("can only hash Uint8Arrays");
+		this._value = value;
+		this._hashFn = hashFn;
+		this._depth = -1;
+		this._availableBits = 0;
+		this._currentBufferIndex = 0;
+		this._buffers = [];
+	}
+	async take(bits) {
+		let pendingBits = bits;
+		while (this._availableBits < pendingBits) await this._produceMoreBits();
+		let result = 0;
+		while (pendingBits > 0) {
+			const hash = this._buffers[this._currentBufferIndex];
+			const available = Math.min(hash.availableBits(), pendingBits);
+			const took = hash.take(available);
+			result = (result << available) + took;
+			pendingBits -= available;
+			this._availableBits -= available;
+			if (hash.availableBits() === 0) this._currentBufferIndex++;
+		}
+		return result;
+	}
+	untake(bits) {
+		let pendingBits = bits;
+		while (pendingBits > 0) {
+			const hash = this._buffers[this._currentBufferIndex];
+			const availableForUntake = Math.min(hash.totalBits() - hash.availableBits(), pendingBits);
+			hash.untake(availableForUntake);
+			pendingBits -= availableForUntake;
+			this._availableBits += availableForUntake;
+			if (this._currentBufferIndex > 0 && hash.totalBits() === hash.availableBits()) {
+				this._depth--;
+				this._currentBufferIndex--;
+			}
+		}
+	}
+	async _produceMoreBits() {
+		this._depth++;
+		const value = this._depth > 0 ? concat([this._value, Uint8Array.from([this._depth])]) : this._value;
+		const buffer = new ConsumableBuffer(await this._hashFn(value));
+		this._buffers.push(buffer);
+		this._availableBits += buffer.availableBits();
+	}
+};
+//#endregion
+//#region node_modules/hamt-sharding/dist/src/index.js
+/**
+* @packageDocumentation
+*
+* A [Hash Mapped Trie](https://en.wikipedia.org/wiki/Hash_array_mapped_trie) implementation for JavaScript.
+*
+* This is used by [@helia/unixfs](https://www.npmjs.com/package/@helia/unixfs) for it's HAMT-sharded directory implementation.
+*
+* @example
+*
+* ```TypeScript
+* import { createHAMT } from 'hamt-sharding'
+* import crypto from 'crypto-promise'
+*
+* // decide how to hash buffers made from keys, can return a Promise
+* const hashFn = async (buf) => {
+*   return crypto
+*     .createHash('sha256')
+*     .update(buf)
+*     .digest()
+* }
+*
+* const bucket = createHAMT({
+*   hashFn: hashFn
+* })
+*
+* await bucket.put('key', 'value')
+*
+* const output = await bucket.get('key')
+* // output === 'value'
+* ```
+*/
+function createHAMT(options) {
+	if (options == null || options.hashFn == null) throw new Error("please define an options.hashFn");
+	return new Bucket({
+		bits: options.bits ?? 8,
+		hash: wrapHash(options.hashFn)
+	});
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/dir-sharded.js
+async function hamtHashFn(buf) {
+	return (await murmur3128.encode(buf)).slice(0, 8).reverse();
+}
+var DirSharded = class extends Dir {
+	bucket;
+	constructor(props, options) {
+		super(props, options);
+		this.bucket = createHAMT({
+			hashFn: hamtHashFn,
+			bits: options.shardFanoutBits ?? 8
+		});
+	}
+	async put(name, value) {
+		this.cid = void 0;
+		this.size = void 0;
+		this.nodeSize = void 0;
+		await this.bucket.put(name, value);
+	}
+	async get(name) {
+		return this.bucket.get(name);
+	}
+	childCount() {
+		return this.bucket.leafCount();
+	}
+	directChildrenCount() {
+		return this.bucket.childrenCount();
+	}
+	onlyChild() {
+		return this.bucket.onlyChild();
+	}
+	*eachChildSeries() {
+		for (const { key, value } of this.bucket.eachLeafSeries()) yield {
+			key,
+			child: value
+		};
+	}
+	async estimateNodeSize() {
+		if (this.nodeSize !== void 0) return this.nodeSize;
+		const blockstore = new BlackHoleBlockstore();
+		const result = await calculateSize(this.bucket, this, blockstore, this.options);
+		this.nodeSize = result.size;
+		return this.nodeSize;
+	}
+	async *flush(blockstore) {
+		for await (const entry of flush(this.bucket, blockstore, this, this.options)) yield {
+			...entry,
+			path: this.path
+		};
+	}
+};
+async function* flush(bucket, blockstore, shardRoot, options) {
+	const children = bucket._children;
+	const padLength = (bucket.tableSize() - 1).toString(16).length;
+	const links = [];
+	let childrenSize = 0n;
+	for (let i = 0; i < children.length; i++) {
+		const child = children.get(i);
+		if (child == null) continue;
+		const labelPrefix = i.toString(16).toUpperCase().padStart(padLength, "0");
+		if (child instanceof Bucket) {
+			let shard;
+			for await (const subShard of flush(child, blockstore, null, options)) shard = subShard;
+			if (shard == null) throw new Error("Could not flush sharded directory, no sub-shard found");
+			links.push({
+				Name: labelPrefix,
+				Tsize: Number(shard.size),
+				Hash: shard.cid
+			});
+			childrenSize += shard.size;
+		} else if (isDir(child.value)) {
+			const dir = child.value;
+			let flushedDir;
+			for await (const entry of dir.flush(blockstore)) {
+				flushedDir = entry;
+				yield flushedDir;
+			}
+			if (flushedDir == null) throw new Error("Did not flush dir");
+			const label = labelPrefix + child.key;
+			links.push({
+				Name: label,
+				Tsize: Number(flushedDir.size),
+				Hash: flushedDir.cid
+			});
+			childrenSize += flushedDir.size;
+		} else {
+			const value = child.value;
+			if (value.cid == null) continue;
+			const label = labelPrefix + child.key;
+			const size = value.size;
+			links.push({
+				Name: label,
+				Tsize: Number(size),
+				Hash: value.cid
+			});
+			childrenSize += BigInt(size ?? 0);
+		}
+	}
+	const dir = new UnixFS({
+		type: "hamt-sharded-directory",
+		data: Uint8Array.from(children.bitField().reverse()),
+		fanout: BigInt(bucket.tableSize()),
+		hashType: DEFAULT_SHARD_HASH_CODE,
+		mtime: shardRoot?.mtime,
+		mode: shardRoot?.mode
+	});
+	const buffer = encode(prepare({
+		Data: dir.marshal(),
+		Links: links
+	}));
+	yield {
+		cid: await persist(buffer, blockstore, options),
+		unixfs: dir,
+		size: BigInt(buffer.byteLength) + childrenSize
+	};
+}
+function isDir(obj) {
+	return typeof obj.flush === "function";
+}
+async function calculateSize(bucket, shardRoot, blocks, options) {
+	const children = bucket._children;
+	const padLength = (bucket.tableSize() - 1).toString(16).length;
+	const links = [];
+	let sizeEstimate = 0;
+	for (let i = 0; i < children.length; i++) {
+		const child = children.get(i);
+		if (child == null) continue;
+		const labelPrefix = i.toString(16).toUpperCase().padStart(padLength, "0");
+		if (child instanceof Bucket) {
+			const { size, cid } = await calculateSize(child, null, blocks, options);
+			links.push({
+				Name: labelPrefix,
+				Tsize: Number(size),
+				Hash: cid
+			});
+			sizeEstimate += labelPrefix.length + cid.byteLength;
+		} else if (isDir(child.value)) {
+			const dir = child.value;
+			const size = dir.nodeSize;
+			if (dir.cid == null) throw new Error("Child directory has not been persisted");
+			links.push({
+				Name: labelPrefix + child.key,
+				Tsize: Number(size),
+				Hash: dir.cid
+			});
+			sizeEstimate += labelPrefix.length + dir.cid.byteLength;
+		} else {
+			const value = child.value;
+			const label = labelPrefix + child.key;
+			const size = value.size;
+			links.push({
+				Name: label,
+				Tsize: Number(size),
+				Hash: value.cid
+			});
+			sizeEstimate += labelPrefix.length + value.cid.byteLength;
+		}
+	}
+	const buffer = encode(prepare({
+		Data: new UnixFS({
+			type: "hamt-sharded-directory",
+			data: Uint8Array.from(children.bitField().reverse()),
+			fanout: BigInt(bucket.tableSize()),
+			hashType: DEFAULT_SHARD_HASH_CODE,
+			mtime: shardRoot?.mtime,
+			mode: shardRoot?.mode
+		}).marshal(),
+		Links: links
+	}));
+	return {
+		cid: await persist(buffer, blocks, options),
+		size: options.shardSplitStrategy === "links-bytes" ? sizeEstimate : buffer.length
+	};
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/flat-to-shard.js
+async function flatToShard(child, dir) {
+	let newDir = dir;
+	const shardSplitThresholdBytes = dir.options.shardSplitThresholdBytes ?? 262144;
+	if (dir instanceof DirFlat && await dir.estimateNodeSize() > shardSplitThresholdBytes) newDir = await convertToShard(dir);
+	const parent = newDir.parent;
+	if (parent != null) {
+		if (newDir !== dir) {
+			if (child != null) child.parent = newDir;
+			if (newDir.parentKey == null) throw new Error("No parent key found");
+			await parent.put(newDir.parentKey, newDir);
+		}
+		return flatToShard(newDir, parent);
+	}
+	return newDir;
+}
+async function convertToShard(oldDir) {
+	const newDir = new DirSharded({
+		root: oldDir.root,
+		dir: true,
+		parent: oldDir.parent,
+		parentKey: oldDir.parentKey,
+		path: oldDir.path,
+		dirty: oldDir.dirty,
+		flat: false,
+		mtime: oldDir.mtime,
+		mode: oldDir.mode
+	}, oldDir.options);
+	for (const { key, child } of oldDir.eachChildSeries()) await newDir.put(key, child);
+	return newDir;
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/utils/to-path-components.js
+const toPathComponents = (path = "") => {
+	return path.split(/(?<!\\)\//).filter(Boolean);
+};
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/tree-builder.js
+async function addToTree(elem, tree, options) {
+	const pathElems = toPathComponents(elem.path ?? "");
+	const lastIndex = pathElems.length - 1;
+	let parent = tree;
+	let currentPath = "";
+	for (let i = 0; i < pathElems.length; i++) {
+		const pathElem = pathElems[i];
+		currentPath += `${currentPath !== "" ? "/" : ""}${pathElem}`;
+		const last = i === lastIndex;
+		parent.dirty = true;
+		parent.cid = void 0;
+		parent.size = void 0;
+		if (last) {
+			await parent.put(pathElem, elem);
+			tree = await flatToShard(null, parent);
+		} else {
+			let dir = await parent.get(pathElem);
+			if (dir == null || !(dir instanceof Dir)) dir = new DirFlat({
+				root: false,
+				dir: true,
+				parent,
+				parentKey: pathElem,
+				path: currentPath,
+				dirty: true,
+				flat: true,
+				mtime: dir?.unixfs?.mtime,
+				mode: dir?.unixfs?.mode
+			}, options);
+			await parent.put(pathElem, dir);
+			parent = dir;
+		}
+	}
+	return tree;
+}
+async function* flushAndYield(tree, blockstore) {
+	if (!(tree instanceof Dir)) {
+		if (tree.unixfs?.isDirectory() === true) yield tree;
+		return;
+	}
+	yield* tree.flush(blockstore);
+}
+function defaultTreeBuilder(options) {
+	return async function* treeBuilder(source, block) {
+		let tree = new DirFlat({
+			root: true,
+			dir: true,
+			path: "",
+			dirty: true,
+			flat: true
+		}, options);
+		let rootDir;
+		let singleRoot = false;
+		for await (const entry of source) {
+			if (entry == null) continue;
+			const dir = `${entry.originalPath ?? ""}`.split("/")[0];
+			if (dir != null && dir !== "") {
+				if (rootDir == null) {
+					rootDir = dir;
+					singleRoot = true;
+				} else if (rootDir !== dir) singleRoot = false;
+			}
+			tree = await addToTree(entry, tree, options);
+			if (entry.unixfs?.isDirectory() !== true) yield entry;
+		}
+		if (options.wrapWithDirectory || singleRoot && tree.childCount() > 1) yield* flushAndYield(tree, block);
+		else for (const unwrapped of tree.eachChildSeries()) {
+			if (unwrapped == null) continue;
+			yield* flushAndYield(unwrapped.child, block);
+		}
+	};
+}
+//#endregion
+//#region node_modules/ipfs-unixfs-importer/dist/src/index.js
+/**
+* @packageDocumentation
+*
+* @example
+*
+* Let's create a little directory to import:
+*
+* ```console
+* > cd /tmp
+* > mkdir foo
+* > echo 'hello' > foo/bar
+* > echo 'world' > foo/quux
+* ```
+*
+* And write the importing logic:
+*
+* ```TypeScript
+* import { importer } from 'ipfs-unixfs-importer'
+* import { MemoryBlockstore } from 'blockstore-core/memory'
+* import * as fs from 'node:fs'
+*
+* // Where the blocks will be stored
+* const blockstore = new MemoryBlockstore()
+*
+* // Import path /tmp/foo/
+* const source = [{
+*   path: '/tmp/foo/bar',
+*   content: fs.createReadStream('/tmp/foo/bar')
+* }, {
+*   path: '/tmp/foo/quxx',
+*   content: fs.createReadStream('/tmp/foo/quux')
+* }]
+*
+* for await (const entry of importer(source, blockstore)) {
+*   console.info(entry)
+* }
+* ```
+*
+* When run, metadata about DAGNodes in the created tree is printed until the root:
+*
+* ```
+* {
+*   cid: CID, // see https://github.com/multiformats/js-cid
+*   path: 'tmp/foo/bar',
+*   unixfs: UnixFS // see https://github.com/ipfs/js-ipfs-unixfs
+* }
+* {
+*   cid: CID, // see https://github.com/multiformats/js-cid
+*   path: 'tmp/foo/quxx',
+*   unixfs: UnixFS // see https://github.com/ipfs/js-ipfs-unixfs
+* }
+* {
+*   cid: CID, // see https://github.com/multiformats/js-cid
+*   path: 'tmp/foo',
+*   unixfs: UnixFS // see https://github.com/ipfs/js-ipfs-unixfs
+* }
+* {
+*   cid: CID, // see https://github.com/multiformats/js-cid
+*   path: 'tmp',
+*   unixfs: UnixFS // see https://github.com/ipfs/js-ipfs-unixfs
+* }
+* ```
+*/
+/**
+* The importer creates UnixFS DAGs and stores the blocks that make
+* them up in the passed blockstore.
+*
+* @example
+*
+* ```typescript
+* import { importer } from 'ipfs-unixfs-importer'
+* import { MemoryBlockstore } from 'blockstore-core'
+*
+* // store blocks in memory, other blockstores are available
+* const blockstore = new MemoryBlockstore()
+*
+* const input = [{
+*   path: './foo.txt',
+*   content: Uint8Array.from([0, 1, 2, 3, 4])
+* }, {
+*   path: './bar.txt',
+*   content: Uint8Array.from([0, 1, 2, 3, 4])
+* }]
+*
+* for await (const entry of importer(input, blockstore)) {
+*   console.info(entry)
+*   // { cid: CID(), ... }
+* }
+* ```
+*/
+async function* importer(source, blockstore, options = {}) {
+	let candidates;
+	if (Symbol.asyncIterator in source || Symbol.iterator in source) candidates = source;
+	else candidates = [source];
+	let chunkSize;
+	let maxChildrenPerNode;
+	if (options.profile === "unixfs-v0-2015") {
+		options.shardSplitStrategy = options.shardSplitStrategy ?? "links-bytes";
+		options.cidVersion = options.cidVersion ?? 0;
+		options.rawLeaves = options.rawLeaves ?? false;
+		chunkSize = DEFAULT_CHUNK_SIZE_256KIB;
+		maxChildrenPerNode = 174;
+	} else if (options.profile === "unixfs-v1-2025") {
+		options.shardSplitStrategy = options.shardSplitStrategy ?? "block-bytes";
+		options.cidVersion = options.cidVersion ?? 1;
+		options.rawLeaves = options.rawLeaves ?? true;
+		chunkSize = DEFAULT_CHUNK_SIZE_1MIB;
+		maxChildrenPerNode = 1024;
+	}
+	const wrapWithDirectory = options.wrapWithDirectory ?? false;
+	const shardSplitThresholdBytes = options.shardSplitThresholdBytes ?? 262144;
+	const shardSplitStrategy = options.shardSplitStrategy ?? "links-bytes";
+	const shardFanoutBits = options.shardFanoutBits ?? 8;
+	const cidVersion = options.cidVersion ?? 1;
+	const rawLeaves = options.rawLeaves ?? true;
+	const leafType = options.leafType ?? "file";
+	const fileImportConcurrency = options.fileImportConcurrency ?? 50;
+	const blockWriteConcurrency = options.blockWriteConcurrency ?? 10;
+	const reduceSingleLeafToSelf = options.reduceSingleLeafToSelf ?? true;
+	const chunker = options.chunker ?? fixedSize({ chunkSize });
+	const chunkValidator = options.chunkValidator ?? defaultChunkValidator();
+	const buildDag = options.dagBuilder ?? defaultDagBuilder({
+		chunker,
+		chunkValidator,
+		wrapWithDirectory,
+		layout: options.layout ?? balanced({ maxChildrenPerNode }),
+		bufferImporter: options.bufferImporter ?? defaultBufferImporter({
+			cidVersion,
+			rawLeaves,
+			leafType,
+			onProgress: options.onProgress
+		}),
+		blockWriteConcurrency,
+		reduceSingleLeafToSelf,
+		cidVersion,
+		onProgress: options.onProgress,
+		dirBuilder: options.dirBuilder,
+		fileBuilder: options.fileBuilder
+	});
+	const buildTree = options.treeBuilder ?? defaultTreeBuilder({
+		wrapWithDirectory,
+		shardSplitThresholdBytes,
+		shardSplitStrategy,
+		shardFanoutBits,
+		cidVersion,
+		onProgress: options.onProgress
+	});
+	for await (const entry of buildTree(parallelBatch(buildDag(candidates, blockstore), fileImportConcurrency), blockstore)) yield {
+		cid: entry.cid,
+		path: entry.path,
+		unixfs: entry.unixfs,
+		size: entry.size
+	};
+}
+/**
+* `importFile` is similar to `importer` except it accepts a single
+* `FileCandidate` and returns a promise of a single `ImportResult`
+* instead of a stream of results.
+*
+* @example
+*
+* ```typescript
+* import { importFile } from 'ipfs-unixfs-importer'
+* import { MemoryBlockstore } from 'blockstore-core'
+*
+* // store blocks in memory, other blockstores are available
+* const blockstore = new MemoryBlockstore()
+*
+* const input: FileCandidate = {
+*   path: './foo.txt',
+*   content: Uint8Array.from([0, 1, 2, 3, 4])
+* }
+*
+* const entry = await importFile(input, blockstore)
+* ```
+*/
+async function importFile(content, blockstore, options = {}) {
+	const result = await first(importer([content], blockstore, options));
+	if (result == null) throw new InvalidParametersError("Nothing imported");
+	return result;
+}
+//#endregion
+export { importFile };