@pkcprotocol/pkc-js 0.0.87 → 0.0.89

package/dist/bundled/chunks/{src-WLgFbUwZ.js → src-629pKfxo.js}

@@ -20,6 +20,2475 @@ import { logger } from "@libp2p/logger";
 import https from "node:https";
 import { multiaddrToUri } from "@multiformats/multiaddr-to-uri";
 //#region node_modules/kubo-rpc-client/node_modules/cborg/lib/is.js
+const objectTypeNames$2 = [
+	"Object",
+	"RegExp",
+	"Date",
+	"Error",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"ArrayBuffer",
+	"SharedArrayBuffer",
+	"DataView",
+	"Promise",
+	"URL",
+	"HTMLElement",
+	"Int8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array",
+	"Tagged"
+];
+/**
+* @param {any} value
+* @returns {string}
+*/
+function is$2(value) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (value === true || value === false) return "boolean";
+	const typeOf = typeof value;
+	if (typeOf === "string" || typeOf === "number" || typeOf === "bigint" || typeOf === "symbol") return typeOf;
+	if (typeOf === "function") return "Function";
+	if (Array.isArray(value)) return "Array";
+	if (value instanceof Uint8Array) return "Uint8Array";
+	if (value.constructor === Object) return "Object";
+	const objectType = getObjectType$2(value);
+	if (objectType) return objectType;
+	return "Object";
+}
+/**
+* @param {any} value
+* @returns {string|undefined}
+*/
+function getObjectType$2(value) {
+	const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
+	if (objectTypeNames$2.includes(objectTypeName)) return objectTypeName;
+}
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/token.js
+var Type$2 = class {
+	/**
+	* @param {number} major
+	* @param {string} name
+	* @param {boolean} terminal
+	*/
+	constructor(major, name, terminal) {
+		this.major = major;
+		this.majorEncoded = major << 5;
+		this.name = name;
+		this.terminal = terminal;
+	}
+	toString() {
+		return `Type[${this.major}].${this.name}`;
+	}
+	/**
+	* @param {Type} typ
+	* @returns {number}
+	*/
+	compare(typ) {
+		return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
+	}
+	/**
+	* Check equality between two Type instances. Safe to use across different
+	* copies of the Type class (e.g., when bundlers duplicate the module).
+	* (major, name) uniquely identifies a Type; terminal is implied by these.
+	* @param {Type} a
+	* @param {Type} b
+	* @returns {boolean}
+	*/
+	static equals(a, b) {
+		return a === b || a.major === b.major && a.name === b.name;
+	}
+};
+Type$2.uint = new Type$2(0, "uint", true);
+Type$2.negint = new Type$2(1, "negint", true);
+Type$2.bytes = new Type$2(2, "bytes", true);
+Type$2.string = new Type$2(3, "string", true);
+Type$2.array = new Type$2(4, "array", false);
+Type$2.map = new Type$2(5, "map", false);
+Type$2.tag = new Type$2(6, "tag", false);
+Type$2.float = new Type$2(7, "float", true);
+Type$2.false = new Type$2(7, "false", true);
+Type$2.true = new Type$2(7, "true", true);
+Type$2.null = new Type$2(7, "null", true);
+Type$2.undefined = new Type$2(7, "undefined", true);
+Type$2.break = new Type$2(7, "break", true);
+var Token$2 = class {
+	/**
+	* @param {Type} type
+	* @param {any} [value]
+	* @param {number} [encodedLength]
+	*/
+	constructor(type, value, encodedLength) {
+		this.type = type;
+		this.value = value;
+		this.encodedLength = encodedLength;
+		/** @type {Uint8Array|undefined} */
+		this.encodedBytes = void 0;
+		/** @type {Uint8Array|undefined} */
+		this.byteValue = void 0;
+	}
+	toString() {
+		return `Token[${this.type}].${this.value}`;
+	}
+};
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/byte-utils.js
+const useBuffer$2 = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === "function";
+const textEncoder$2 = new TextEncoder();
+/**
+* @typedef {import('../interface.js').ByteView} ByteView
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
+*/
+/**
+* @param {Uint8Array} buf
+* @returns {boolean}
+*/
+function isBuffer$2(buf) {
+	return useBuffer$2 && globalThis.Buffer.isBuffer(buf);
+}
+/**
+* @param {ByteView|number[]} buf
+* @returns {ByteView}
+*/
+function asU8A$2(buf) {
+	if (!(buf instanceof Uint8Array)) return Uint8Array.from(buf);
+	return isBuffer$2(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf;
+}
+const FROM_STRING_THRESHOLD_BUFFER$2 = 24;
+const FROM_STRING_THRESHOLD_TEXTENCODER$2 = 200;
+const fromString$3 = useBuffer$2 ? (string) => {
+	return string.length >= FROM_STRING_THRESHOLD_BUFFER$2 ? globalThis.Buffer.from(string) : utf8ToBytes$2(string);
+} : 
+/**
+* @param {string} string
+*/
+(string) => {
+	return string.length >= FROM_STRING_THRESHOLD_TEXTENCODER$2 ? textEncoder$2.encode(string) : utf8ToBytes$2(string);
+};
+/**
+* Buffer variant not fast enough for what we need
+* @param {number[]} arr
+* @returns {AllocatedByteView}
+*/
+const fromArray$2 = (arr) => {
+	return Uint8Array.from(arr);
+};
+const slice$2 = useBuffer$2 ? (bytes, start, end) => {
+	if (isBuffer$2(bytes)) return new Uint8Array(bytes.subarray(start, end));
+	return bytes.slice(start, end);
+} : 
+/**
+* @param {Uint8Array} bytes
+* @param {number} start
+* @param {number} end
+*/
+(bytes, start, end) => {
+	return bytes.slice(start, end);
+};
+const concat$2 = useBuffer$2 ? (chunks, length) => {
+	chunks = chunks.map((c) => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
+	return asU8A$2(globalThis.Buffer.concat(chunks, length));
+} : 
+/**
+* @param {ByteView[]} chunks
+* @param {number} length
+* @returns {AllocatedByteView}
+*/
+(chunks, length) => {
+	const out = new Uint8Array(length);
+	let off = 0;
+	for (let b of chunks) {
+		if (off + b.length > out.length) b = b.subarray(0, out.length - off);
+		out.set(b, off);
+		off += b.length;
+	}
+	return out;
+};
+const alloc$2 = useBuffer$2 ? (size) => {
+	return globalThis.Buffer.allocUnsafe(size);
+} : 
+/**
+* @param {number} size
+* @returns {AllocatedByteView}
+*/
+(size) => {
+	return new Uint8Array(size);
+};
+/**
+* @param {Uint8Array} b1
+* @param {Uint8Array} b2
+* @returns {number}
+*/
+function compare$2(b1, b2) {
+	if (isBuffer$2(b1) && isBuffer$2(b2)) return b1.compare(b2);
+	for (let i = 0; i < b1.length; i++) {
+		if (b1[i] === b2[i]) continue;
+		return b1[i] < b2[i] ? -1 : 1;
+	}
+	return 0;
+}
+/**
+* @param {string} str
+* @returns {number[]}
+*/
+function utf8ToBytes$2(str) {
+	const out = [];
+	let p = 0;
+	for (let i = 0; i < str.length; i++) {
+		let c = str.charCodeAt(i);
+		if (c < 128) out[p++] = c;
+		else if (c < 2048) {
+			out[p++] = c >> 6 | 192;
+			out[p++] = c & 63 | 128;
+		} else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
+			c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
+			out[p++] = c >> 18 | 240;
+			out[p++] = c >> 12 & 63 | 128;
+			out[p++] = c >> 6 & 63 | 128;
+			out[p++] = c & 63 | 128;
+		} else {
+			if (c >= 55296 && c <= 57343) c = 65533;
+			out[p++] = c >> 12 | 224;
+			out[p++] = c >> 6 & 63 | 128;
+			out[p++] = c & 63 | 128;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/bl.js
+/**
+* Bl is a list of byte chunks, similar to https://github.com/rvagg/bl but for
+* writing rather than reading.
+* A Bl object accepts set() operations for individual bytes and copyTo() for
+* inserting byte arrays. These write operations don't automatically increment
+* the internal cursor so its "length" won't be changed. Instead, increment()
+* must be called to extend its length to cover the inserted data.
+* The toBytes() call will convert all internal memory to a single Uint8Array of
+* the correct length, truncating any data that is stored but hasn't been
+* included by an increment().
+* get() can retrieve a single byte.
+* All operations (except toBytes()) take an "offset" argument that will perform
+* the write at the offset _from the current cursor_. For most operations this
+* will be `0` to write at the current cursor position but it can be ahead of
+* the current cursor. Negative offsets probably work but are untested.
+*/
+/**
+* @typedef {import('../interface.js').ByteView} ByteView
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
+*/
+const defaultChunkSize$2 = 256;
+var Bl$2 = class {
+	/**
+	* @param {number} [chunkSize]
+	*/
+	constructor(chunkSize = defaultChunkSize$2) {
+		this.chunkSize = chunkSize;
+		/** @type {number} */
+		this.cursor = 0;
+		/** @type {number} */
+		this.maxCursor = -1;
+		/** @type {(ByteView|number[])[]} */
+		this.chunks = [];
+		/** @type {ByteView|number[]|null} */
+		this._initReuseChunk = null;
+	}
+	reset() {
+		this.cursor = 0;
+		this.maxCursor = -1;
+		if (this.chunks.length) this.chunks = [];
+		if (this._initReuseChunk !== null) {
+			this.chunks.push(this._initReuseChunk);
+			this.maxCursor = this._initReuseChunk.length - 1;
+		}
+	}
+	/**
+	* @param {number} byte
+	*/
+	pushByte(byte) {
+		let topChunk = this.chunks[this.chunks.length - 1];
+		if (this.cursor > this.maxCursor) {
+			topChunk = alloc$2(this.chunkSize);
+			this.chunks.push(topChunk);
+			this.maxCursor += topChunk.length;
+			if (this._initReuseChunk === null) this._initReuseChunk = topChunk;
+		}
+		const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
+		topChunk[chunkPos] = byte;
+		this.cursor++;
+	}
+	/**
+	* @param {ByteView|number[]} bytes
+	*/
+	push(bytes) {
+		let topChunk = this.chunks[this.chunks.length - 1];
+		if (this.cursor + bytes.length <= this.maxCursor + 1) {
+			const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
+			topChunk.set(bytes, chunkPos);
+		} else {
+			if (topChunk) {
+				const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
+				if (chunkPos < topChunk.length) {
+					this.chunks[this.chunks.length - 1] = topChunk.subarray(0, chunkPos);
+					this.maxCursor = this.cursor - 1;
+				}
+			}
+			if (bytes.length < 64 && bytes.length < this.chunkSize) {
+				topChunk = alloc$2(this.chunkSize);
+				this.chunks.push(topChunk);
+				this.maxCursor += topChunk.length;
+				if (this._initReuseChunk === null) this._initReuseChunk = topChunk;
+				topChunk.set(bytes, 0);
+			} else {
+				this.chunks.push(bytes);
+				this.maxCursor += bytes.length;
+			}
+		}
+		this.cursor += bytes.length;
+	}
+	/**
+	* @param {boolean} [reset]
+	* @returns {AllocatedByteView}
+	*/
+	toBytes(reset = false) {
+		let byts;
+		if (this.chunks.length === 1) {
+			const chunk = this.chunks[0];
+			if (reset && this.cursor > chunk.length / 2) {
+				byts = this.cursor === chunk.length ? chunk : chunk.subarray(0, this.cursor);
+				this._initReuseChunk = null;
+				this.chunks = [];
+			} else byts = slice$2(chunk, 0, this.cursor);
+		} else byts = concat$2(this.chunks, this.cursor);
+		if (reset) this.reset();
+		return byts;
+	}
+};
+/**
+* U8Bl is a buffer list that writes directly to a user-provided Uint8Array.
+* It provides the same interface as Bl but writes to a fixed destination.
+* @template {ArrayBufferLike} T
+*/
+var U8Bl$2 = class {
+	/**
+	* @param {Uint8Array<T>} dest
+	*/
+	constructor(dest) {
+		this.dest = dest;
+		/** @type {number} */
+		this.cursor = 0;
+		/** @type {Array<Uint8Array<T>>} */
+		this.chunks = [dest];
+	}
+	reset() {
+		this.cursor = 0;
+	}
+	/**
+	* @param {number} byte
+	*/
+	pushByte(byte) {
+		if (this.cursor >= this.dest.length) throw new Error("write out of bounds, destination buffer is too small");
+		this.dest[this.cursor++] = byte;
+	}
+	/**
+	* @param {ByteView|number[]} bytes
+	*/
+	push(bytes) {
+		if (this.cursor + bytes.length > this.dest.length) throw new Error("write out of bounds, destination buffer is too small");
+		this.dest.set(bytes, this.cursor);
+		this.cursor += bytes.length;
+	}
+	/**
+	* @param {boolean} [reset]
+	* @returns {Uint8Array<T>}
+	*/
+	toBytes(reset = false) {
+		const byts = this.dest.subarray(0, this.cursor);
+		if (reset) this.reset();
+		return byts;
+	}
+};
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/common.js
+const decodeErrPrefix$2 = "CBOR decode error:";
+const encodeErrPrefix$2 = "CBOR encode error:";
+const uintMinorPrefixBytes$2 = [];
+uintMinorPrefixBytes$2[23] = 1;
+uintMinorPrefixBytes$2[24] = 2;
+uintMinorPrefixBytes$2[25] = 3;
+uintMinorPrefixBytes$2[26] = 5;
+uintMinorPrefixBytes$2[27] = 9;
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} need
+*/
+function assertEnoughData$2(data, pos, need) {
+	if (data.length - pos < need) throw new Error(`${decodeErrPrefix$2} not enough data for type`);
+}
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/0uint.js
+const uintBoundaries$2 = [
+	24,
+	256,
+	65536,
+	4294967296,
+	BigInt("18446744073709551616")
+];
+/**
+* @typedef {import('../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+*/
+/**
+* @param {Uint8Array} data
+* @param {number} offset
+* @param {DecodeOptions} options
+* @returns {number}
+*/
+function readUint8$2(data, offset, options) {
+	assertEnoughData$2(data, offset, 1);
+	const value = data[offset];
+	if (options.strict === true && value < uintBoundaries$2[0]) throw new Error(`${decodeErrPrefix$2} integer encoded in more bytes than necessary (strict decode)`);
+	return value;
+}
+/**
+* @param {Uint8Array} data
+* @param {number} offset
+* @param {DecodeOptions} options
+* @returns {number}
+*/
+function readUint16$2(data, offset, options) {
+	assertEnoughData$2(data, offset, 2);
+	const value = data[offset] << 8 | data[offset + 1];
+	if (options.strict === true && value < uintBoundaries$2[1]) throw new Error(`${decodeErrPrefix$2} integer encoded in more bytes than necessary (strict decode)`);
+	return value;
+}
+/**
+* @param {Uint8Array} data
+* @param {number} offset
+* @param {DecodeOptions} options
+* @returns {number}
+*/
+function readUint32$2(data, offset, options) {
+	assertEnoughData$2(data, offset, 4);
+	const value = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
+	if (options.strict === true && value < uintBoundaries$2[2]) throw new Error(`${decodeErrPrefix$2} integer encoded in more bytes than necessary (strict decode)`);
+	return value;
+}
+/**
+* @param {Uint8Array} data
+* @param {number} offset
+* @param {DecodeOptions} options
+* @returns {number|bigint}
+*/
+function readUint64$2(data, offset, options) {
+	assertEnoughData$2(data, offset, 8);
+	const hi = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
+	const lo = data[offset + 4] * 16777216 + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7];
+	const value = (BigInt(hi) << BigInt(32)) + BigInt(lo);
+	if (options.strict === true && value < uintBoundaries$2[3]) throw new Error(`${decodeErrPrefix$2} integer encoded in more bytes than necessary (strict decode)`);
+	if (value <= Number.MAX_SAFE_INTEGER) return Number(value);
+	if (options.allowBigInt === true) return value;
+	throw new Error(`${decodeErrPrefix$2} integers outside of the safe integer range are not supported`);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeUint8$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.uint, readUint8$2(data, pos + 1, options), 2);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeUint16$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.uint, readUint16$2(data, pos + 1, options), 3);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeUint32$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.uint, readUint32$2(data, pos + 1, options), 5);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeUint64$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.uint, readUint64$2(data, pos + 1, options), 9);
+}
+/**
+* @param {ByteWriter} writer
+* @param {Token} token
+*/
+function encodeUint$2(writer, token) {
+	return encodeUintValue$2(writer, 0, token.value);
+}
+/**
+* @param {ByteWriter} writer
+* @param {number} major
+* @param {number|bigint} uint
+*/
+function encodeUintValue$2(writer, major, uint) {
+	if (uint < uintBoundaries$2[0]) {
+		const nuint = Number(uint);
+		writer.pushByte(major | nuint);
+	} else if (uint < uintBoundaries$2[1]) {
+		const nuint = Number(uint);
+		writer.push([major | 24, nuint]);
+	} else if (uint < uintBoundaries$2[2]) {
+		const nuint = Number(uint);
+		writer.push([
+			major | 25,
+			nuint >>> 8,
+			nuint & 255
+		]);
+	} else if (uint < uintBoundaries$2[3]) {
+		const nuint = Number(uint);
+		writer.push([
+			major | 26,
+			nuint >>> 24 & 255,
+			nuint >>> 16 & 255,
+			nuint >>> 8 & 255,
+			nuint & 255
+		]);
+	} else {
+		const buint = BigInt(uint);
+		if (buint < uintBoundaries$2[4]) {
+			const set = [
+				major | 27,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0,
+				0
+			];
+			let lo = Number(buint & BigInt(4294967295));
+			let hi = Number(buint >> BigInt(32) & BigInt(4294967295));
+			set[8] = lo & 255;
+			lo = lo >> 8;
+			set[7] = lo & 255;
+			lo = lo >> 8;
+			set[6] = lo & 255;
+			lo = lo >> 8;
+			set[5] = lo & 255;
+			set[4] = hi & 255;
+			hi = hi >> 8;
+			set[3] = hi & 255;
+			hi = hi >> 8;
+			set[2] = hi & 255;
+			hi = hi >> 8;
+			set[1] = hi & 255;
+			writer.push(set);
+		} else throw new Error(`${decodeErrPrefix$2} encountered BigInt larger than allowable range`);
+	}
+}
+/**
+* @param {Token} token
+* @returns {number}
+*/
+encodeUint$2.encodedSize = function encodedSize(token) {
+	return encodeUintValue$2.encodedSize(token.value);
+};
+/**
+* @param {number} uint
+* @returns {number}
+*/
+encodeUintValue$2.encodedSize = function encodedSize(uint) {
+	if (uint < uintBoundaries$2[0]) return 1;
+	if (uint < uintBoundaries$2[1]) return 2;
+	if (uint < uintBoundaries$2[2]) return 3;
+	if (uint < uintBoundaries$2[3]) return 5;
+	return 9;
+};
+/**
+* @param {Token} tok1
+* @param {Token} tok2
+* @returns {number}
+*/
+encodeUint$2.compareTokens = function compareTokens(tok1, tok2) {
+	return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 0;
+};
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/1negint.js
+/**
+* @typedef {import('../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+*/
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeNegint8$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.negint, -1 - readUint8$2(data, pos + 1, options), 2);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeNegint16$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.negint, -1 - readUint16$2(data, pos + 1, options), 3);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeNegint32$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.negint, -1 - readUint32$2(data, pos + 1, options), 5);
+}
+const neg1b$4 = BigInt(-1);
+const pos1b$4 = BigInt(1);
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeNegint64$2(data, pos, _minor, options) {
+	const int = readUint64$2(data, pos + 1, options);
+	if (typeof int !== "bigint") {
+		const value = -1 - int;
+		if (value >= Number.MIN_SAFE_INTEGER) return new Token$2(Type$2.negint, value, 9);
+	}
+	if (options.allowBigInt !== true) throw new Error(`${decodeErrPrefix$2} integers outside of the safe integer range are not supported`);
+	return new Token$2(Type$2.negint, neg1b$4 - BigInt(int), 9);
+}
+/**
+* @param {ByteWriter} writer
+* @param {Token} token
+*/
+function encodeNegint$2(writer, token) {
+	const negint = token.value;
+	const unsigned = typeof negint === "bigint" ? negint * neg1b$4 - pos1b$4 : negint * -1 - 1;
+	encodeUintValue$2(writer, token.type.majorEncoded, unsigned);
+}
+/**
+* @param {Token} token
+* @returns {number}
+*/
+encodeNegint$2.encodedSize = function encodedSize(token) {
+	const negint = token.value;
+	const unsigned = typeof negint === "bigint" ? negint * neg1b$4 - pos1b$4 : negint * -1 - 1;
+	if (unsigned < uintBoundaries$2[0]) return 1;
+	if (unsigned < uintBoundaries$2[1]) return 2;
+	if (unsigned < uintBoundaries$2[2]) return 3;
+	if (unsigned < uintBoundaries$2[3]) return 5;
+	return 9;
+};
+/**
+* @param {Token} tok1
+* @param {Token} tok2
+* @returns {number}
+*/
+encodeNegint$2.compareTokens = function compareTokens(tok1, tok2) {
+	return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : 0;
+};
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/2bytes.js
+/**
+* @typedef {import('../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+*/
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} prefix
+* @param {number} length
+* @returns {Token}
+*/
+function toToken$11(data, pos, prefix, length) {
+	assertEnoughData$2(data, pos, prefix + length);
+	const buf = data.slice(pos + prefix, pos + prefix + length);
+	return new Token$2(Type$2.bytes, buf, prefix + length);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} minor
+* @param {DecodeOptions} _options
+* @returns {Token}
+*/
+function decodeBytesCompact$2(data, pos, minor, _options) {
+	return toToken$11(data, pos, 1, minor);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeBytes8$2(data, pos, _minor, options) {
+	return toToken$11(data, pos, 2, readUint8$2(data, pos + 1, options));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeBytes16$2(data, pos, _minor, options) {
+	return toToken$11(data, pos, 3, readUint16$2(data, pos + 1, options));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeBytes32$2(data, pos, _minor, options) {
+	return toToken$11(data, pos, 5, readUint32$2(data, pos + 1, options));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeBytes64$2(data, pos, _minor, options) {
+	const l = readUint64$2(data, pos + 1, options);
+	if (typeof l === "bigint") throw new Error(`${decodeErrPrefix$2} 64-bit integer bytes lengths not supported`);
+	return toToken$11(data, pos, 9, l);
+}
+/**
+* `encodedBytes` allows for caching when we do a byte version of a string
+* for key sorting purposes
+* @param {Token} token
+* @returns {Uint8Array}
+*/
+function tokenBytes$2(token) {
+	if (token.encodedBytes === void 0) token.encodedBytes = Type$2.equals(token.type, Type$2.string) ? fromString$3(token.value) : token.value;
+	return token.encodedBytes;
+}
+/**
+* @param {ByteWriter} writer
+* @param {Token} token
+*/
+function encodeBytes$2(writer, token) {
+	const bytes = tokenBytes$2(token);
+	encodeUintValue$2(writer, token.type.majorEncoded, bytes.length);
+	writer.push(bytes);
+}
+/**
+* @param {Token} token
+* @returns {number}
+*/
+encodeBytes$2.encodedSize = function encodedSize(token) {
+	const bytes = tokenBytes$2(token);
+	return encodeUintValue$2.encodedSize(bytes.length) + bytes.length;
+};
+/**
+* @param {Token} tok1
+* @param {Token} tok2
+* @returns {number}
+*/
+encodeBytes$2.compareTokens = function compareTokens(tok1, tok2) {
+	return compareBytes$2(tokenBytes$2(tok1), tokenBytes$2(tok2));
+};
+/**
+* @param {Uint8Array} b1
+* @param {Uint8Array} b2
+* @returns {number}
+*/
+function compareBytes$2(b1, b2) {
+	return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare$2(b1, b2);
+}
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/3string.js
+const textDecoder$2 = new TextDecoder();
+const ASCII_THRESHOLD$2 = 32;
+/**
+* @typedef {import('../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+*/
+/**
+* Decode UTF-8 bytes to string. For short ASCII strings (common case for map keys),
+* a simple loop is faster than TextDecoder.
+* @param {Uint8Array} bytes
+* @param {number} start
+* @param {number} end
+* @returns {string}
+*/
+function toStr$2(bytes, start, end) {
+	if (end - start < ASCII_THRESHOLD$2) {
+		let str = "";
+		for (let i = start; i < end; i++) {
+			const c = bytes[i];
+			if (c & 128) return textDecoder$2.decode(bytes.subarray(start, end));
+			str += String.fromCharCode(c);
+		}
+		return str;
+	}
+	return textDecoder$2.decode(bytes.subarray(start, end));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} prefix
+* @param {number} length
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function toToken$10(data, pos, prefix, length, options) {
+	const totLength = prefix + length;
+	assertEnoughData$2(data, pos, totLength);
+	const tok = new Token$2(Type$2.string, toStr$2(data, pos + prefix, pos + totLength), totLength);
+	if (options.retainStringBytes === true) tok.byteValue = data.slice(pos + prefix, pos + totLength);
+	return tok;
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeStringCompact$2(data, pos, minor, options) {
+	return toToken$10(data, pos, 1, minor, options);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeString8$2(data, pos, _minor, options) {
+	return toToken$10(data, pos, 2, readUint8$2(data, pos + 1, options), options);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeString16$2(data, pos, _minor, options) {
+	return toToken$10(data, pos, 3, readUint16$2(data, pos + 1, options), options);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeString32$2(data, pos, _minor, options) {
+	return toToken$10(data, pos, 5, readUint32$2(data, pos + 1, options), options);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeString64$2(data, pos, _minor, options) {
+	const l = readUint64$2(data, pos + 1, options);
+	if (typeof l === "bigint") throw new Error(`${decodeErrPrefix$2} 64-bit integer string lengths not supported`);
+	return toToken$10(data, pos, 9, l, options);
+}
+const encodeString$2 = encodeBytes$2;
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/4array.js
+/**
+* @typedef {import('../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+*/
+/**
+* @param {Uint8Array} _data
+* @param {number} _pos
+* @param {number} prefix
+* @param {number} length
+* @returns {Token}
+*/
+function toToken$9(_data, _pos, prefix, length) {
+	return new Token$2(Type$2.array, length, prefix);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} minor
+* @param {DecodeOptions} _options
+* @returns {Token}
+*/
+function decodeArrayCompact$2(data, pos, minor, _options) {
+	return toToken$9(data, pos, 1, minor);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeArray8$2(data, pos, _minor, options) {
+	return toToken$9(data, pos, 2, readUint8$2(data, pos + 1, options));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeArray16$2(data, pos, _minor, options) {
+	return toToken$9(data, pos, 3, readUint16$2(data, pos + 1, options));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeArray32$2(data, pos, _minor, options) {
+	return toToken$9(data, pos, 5, readUint32$2(data, pos + 1, options));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeArray64$2(data, pos, _minor, options) {
+	const l = readUint64$2(data, pos + 1, options);
+	if (typeof l === "bigint") throw new Error(`${decodeErrPrefix$2} 64-bit integer array lengths not supported`);
+	return toToken$9(data, pos, 9, l);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeArrayIndefinite$2(data, pos, _minor, options) {
+	if (options.allowIndefinite === false) throw new Error(`${decodeErrPrefix$2} indefinite length items not allowed`);
+	return toToken$9(data, pos, 1, Infinity);
+}
+/**
+* @param {ByteWriter} writer
+* @param {Token} token
+*/
+function encodeArray$2(writer, token) {
+	encodeUintValue$2(writer, Type$2.array.majorEncoded, token.value);
+}
+encodeArray$2.compareTokens = encodeUint$2.compareTokens;
+/**
+* @param {Token} token
+* @returns {number}
+*/
+encodeArray$2.encodedSize = function encodedSize(token) {
+	return encodeUintValue$2.encodedSize(token.value);
+};
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/5map.js
+/**
+* @typedef {import('../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+*/
+/**
+* @param {Uint8Array} _data
+* @param {number} _pos
+* @param {number} prefix
+* @param {number} length
+* @returns {Token}
+*/
+function toToken$8(_data, _pos, prefix, length) {
+	return new Token$2(Type$2.map, length, prefix);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} minor
+* @param {DecodeOptions} _options
+* @returns {Token}
+*/
+function decodeMapCompact$2(data, pos, minor, _options) {
+	return toToken$8(data, pos, 1, minor);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeMap8$2(data, pos, _minor, options) {
+	return toToken$8(data, pos, 2, readUint8$2(data, pos + 1, options));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeMap16$2(data, pos, _minor, options) {
+	return toToken$8(data, pos, 3, readUint16$2(data, pos + 1, options));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeMap32$2(data, pos, _minor, options) {
+	return toToken$8(data, pos, 5, readUint32$2(data, pos + 1, options));
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeMap64$2(data, pos, _minor, options) {
+	const l = readUint64$2(data, pos + 1, options);
+	if (typeof l === "bigint") throw new Error(`${decodeErrPrefix$2} 64-bit integer map lengths not supported`);
+	return toToken$8(data, pos, 9, l);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeMapIndefinite$2(data, pos, _minor, options) {
+	if (options.allowIndefinite === false) throw new Error(`${decodeErrPrefix$2} indefinite length items not allowed`);
+	return toToken$8(data, pos, 1, Infinity);
+}
+/**
+* @param {ByteWriter} writer
+* @param {Token} token
+*/
+function encodeMap$2(writer, token) {
+	encodeUintValue$2(writer, Type$2.map.majorEncoded, token.value);
+}
+encodeMap$2.compareTokens = encodeUint$2.compareTokens;
+/**
+* @param {Token} token
+* @returns {number}
+*/
+encodeMap$2.encodedSize = function encodedSize(token) {
+	return encodeUintValue$2.encodedSize(token.value);
+};
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/6tag.js
+/**
+* @typedef {import('../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+*/
+/**
+* @param {Uint8Array} _data
+* @param {number} _pos
+* @param {number} minor
+* @param {DecodeOptions} _options
+* @returns {Token}
+*/
+function decodeTagCompact$2(_data, _pos, minor, _options) {
+	return new Token$2(Type$2.tag, minor, 1);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeTag8$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.tag, readUint8$2(data, pos + 1, options), 2);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeTag16$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.tag, readUint16$2(data, pos + 1, options), 3);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeTag32$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.tag, readUint32$2(data, pos + 1, options), 5);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeTag64$2(data, pos, _minor, options) {
+	return new Token$2(Type$2.tag, readUint64$2(data, pos + 1, options), 9);
+}
+/**
+* @param {ByteWriter} writer
+* @param {Token} token
+*/
+function encodeTag$2(writer, token) {
+	encodeUintValue$2(writer, Type$2.tag.majorEncoded, token.value);
+}
+encodeTag$2.compareTokens = encodeUint$2.compareTokens;
+/**
+* @param {Token} token
+* @returns {number}
+*/
+encodeTag$2.encodedSize = function encodedSize(token) {
+	return encodeUintValue$2.encodedSize(token.value);
+};
+/**
+* @param {Uint8Array} _data
+* @param {number} _pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeUndefined$2(_data, _pos, _minor, options) {
+	if (options.allowUndefined === false) throw new Error(`${decodeErrPrefix$2} undefined values are not supported`);
+	else if (options.coerceUndefinedToNull === true) return new Token$2(Type$2.null, null, 1);
+	return new Token$2(Type$2.undefined, void 0, 1);
+}
+/**
+* @param {Uint8Array} _data
+* @param {number} _pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeBreak$2(_data, _pos, _minor, options) {
+	if (options.allowIndefinite === false) throw new Error(`${decodeErrPrefix$2} indefinite length items not allowed`);
+	return new Token$2(Type$2.break, void 0, 1);
+}
+/**
+* @param {number} value
+* @param {number} bytes
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function createToken$2(value, bytes, options) {
+	if (options) {
+		if (options.allowNaN === false && Number.isNaN(value)) throw new Error(`${decodeErrPrefix$2} NaN values are not supported`);
+		if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) throw new Error(`${decodeErrPrefix$2} Infinity values are not supported`);
+	}
+	return new Token$2(Type$2.float, value, bytes);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeFloat16$2(data, pos, _minor, options) {
+	return createToken$2(readFloat16$2(data, pos + 1), 3, options);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeFloat32$2(data, pos, _minor, options) {
+	return createToken$2(readFloat32$2(data, pos + 1), 5, options);
+}
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} _minor
+* @param {DecodeOptions} options
+* @returns {Token}
+*/
+function decodeFloat64$2(data, pos, _minor, options) {
+	return createToken$2(readFloat64$2(data, pos + 1), 9, options);
+}
+/**
+* @param {ByteWriter} writer
+* @param {Token} token
+* @param {EncodeOptions} options
+*/
+function encodeFloat$2(writer, token, options) {
+	const float = token.value;
+	if (float === false) writer.pushByte(Type$2.float.majorEncoded | 20);
+	else if (float === true) writer.pushByte(Type$2.float.majorEncoded | 21);
+	else if (float === null) writer.pushByte(Type$2.float.majorEncoded | 22);
+	else if (float === void 0) writer.pushByte(Type$2.float.majorEncoded | 23);
+	else {
+		let decoded;
+		let success = false;
+		if (!options || options.float64 !== true) {
+			encodeFloat16$2(float);
+			decoded = readFloat16$2(ui8a$2, 1);
+			if (float === decoded || Number.isNaN(float)) {
+				ui8a$2[0] = 249;
+				writer.push(ui8a$2.slice(0, 3));
+				success = true;
+			} else {
+				encodeFloat32$2(float);
+				decoded = readFloat32$2(ui8a$2, 1);
+				if (float === decoded) {
+					ui8a$2[0] = 250;
+					writer.push(ui8a$2.slice(0, 5));
+					success = true;
+				}
+			}
+		}
+		if (!success) {
+			encodeFloat64$2(float);
+			decoded = readFloat64$2(ui8a$2, 1);
+			ui8a$2[0] = 251;
+			writer.push(ui8a$2.slice(0, 9));
+		}
+	}
+}
+/**
+* @param {Token} token
+* @param {EncodeOptions} options
+* @returns {number}
+*/
+encodeFloat$2.encodedSize = function encodedSize(token, options) {
+	const float = token.value;
+	if (float === false || float === true || float === null || float === void 0) return 1;
+	if (!options || options.float64 !== true) {
+		encodeFloat16$2(float);
+		let decoded = readFloat16$2(ui8a$2, 1);
+		if (float === decoded || Number.isNaN(float)) return 3;
+		encodeFloat32$2(float);
+		decoded = readFloat32$2(ui8a$2, 1);
+		if (float === decoded) return 5;
+	}
+	return 9;
+};
+const buffer$2 = /* @__PURE__ */ new ArrayBuffer(9);
+const dataView$2 = new DataView(buffer$2, 1);
+const ui8a$2 = new Uint8Array(buffer$2, 0);
+/**
+* @param {number} inp
+*/
+function encodeFloat16$2(inp) {
+	if (inp === Infinity) dataView$2.setUint16(0, 31744, false);
+	else if (inp === -Infinity) dataView$2.setUint16(0, 64512, false);
+	else if (Number.isNaN(inp)) dataView$2.setUint16(0, 32256, false);
+	else {
+		dataView$2.setFloat32(0, inp);
+		const valu32 = dataView$2.getUint32(0);
+		const exponent = (valu32 & 2139095040) >> 23;
+		const mantissa = valu32 & 8388607;
+		if (exponent === 255) dataView$2.setUint16(0, 31744, false);
+		else if (exponent === 0) dataView$2.setUint16(0, (valu32 & 2147483648) >> 16 | mantissa >> 13, false);
+		else {
+			const logicalExponent = exponent - 127;
+			if (logicalExponent < -24) dataView$2.setUint16(0, 0);
+			else if (logicalExponent < -14) dataView$2.setUint16(0, (valu32 & 2147483648) >> 16 | 1 << 24 + logicalExponent, false);
+			else dataView$2.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
+		}
+	}
+}
+/**
+* @param {Uint8Array} ui8a
+* @param {number} pos
+* @returns {number}
+*/
+function readFloat16$2(ui8a, pos) {
+	if (ui8a.length - pos < 2) throw new Error(`${decodeErrPrefix$2} not enough data for float16`);
+	const half = (ui8a[pos] << 8) + ui8a[pos + 1];
+	if (half === 31744) return Infinity;
+	if (half === 64512) return -Infinity;
+	if (half === 32256) return NaN;
+	const exp = half >> 10 & 31;
+	const mant = half & 1023;
+	let val;
+	if (exp === 0) val = mant * 2 ** -24;
+	else if (exp !== 31) val = (mant + 1024) * 2 ** (exp - 25);
+	else val = mant === 0 ? Infinity : NaN;
+	return half & 32768 ? -val : val;
+}
+/**
+* @param {number} inp
+*/
+function encodeFloat32$2(inp) {
+	dataView$2.setFloat32(0, inp, false);
+}
+/**
+* @param {Uint8Array} ui8a
+* @param {number} pos
+* @returns {number}
+*/
+function readFloat32$2(ui8a, pos) {
+	if (ui8a.length - pos < 4) throw new Error(`${decodeErrPrefix$2} not enough data for float32`);
+	const offset = (ui8a.byteOffset || 0) + pos;
+	return new DataView(ui8a.buffer, offset, 4).getFloat32(0, false);
+}
+/**
+* @param {number} inp
+*/
+function encodeFloat64$2(inp) {
+	dataView$2.setFloat64(0, inp, false);
+}
+/**
+* @param {Uint8Array} ui8a
+* @param {number} pos
+* @returns {number}
+*/
+function readFloat64$2(ui8a, pos) {
+	if (ui8a.length - pos < 8) throw new Error(`${decodeErrPrefix$2} not enough data for float64`);
+	const offset = (ui8a.byteOffset || 0) + pos;
+	return new DataView(ui8a.buffer, offset, 8).getFloat64(0, false);
+}
+/**
+* @typedef {Token & {
+*   _keyBytes?: Uint8Array,
+*   _keyBytesFloat64?: Uint8Array
+* }} TokenEx
+*/
+/**
+* The canonical CBOR bytes for a major 7 map key. The four simple values encode
+* to a single byte and every float to its 3, 5 or 9 byte form, exactly as
+* {@link encodeFloat} writes them. This mirrors the width selection in
+* `encodeFloat` because the sorter needs the bytes in hand to compare.
+* @param {Token} token
+* @param {boolean} float64
+* @returns {Uint8Array}
+*/
+function encodeMajorSevenBytes$1(token, float64) {
+	const float = token.value;
+	if (float === false) return Uint8Array.of(Type$2.float.majorEncoded | 20);
+	if (float === true) return Uint8Array.of(Type$2.float.majorEncoded | 21);
+	if (float === null) return Uint8Array.of(Type$2.float.majorEncoded | 22);
+	if (float === void 0) return Uint8Array.of(Type$2.float.majorEncoded | 23);
+	if (!float64) {
+		encodeFloat16$2(float);
+		if (float === readFloat16$2(ui8a$2, 1) || Number.isNaN(float)) {
+			ui8a$2[0] = 249;
+			return ui8a$2.slice(0, 3);
+		}
+		encodeFloat32$2(float);
+		if (float === readFloat32$2(ui8a$2, 1)) {
+			ui8a$2[0] = 250;
+			return ui8a$2.slice(0, 5);
+		}
+	}
+	encodeFloat64$2(float);
+	ui8a$2[0] = 251;
+	return ui8a$2.slice(0, 9);
+}
+/**
+* Get the canonical CBOR bytes for a major 7 map key, honouring
+* `options.float64`. Bytes are cached because Array.sort compares each key
+* multiple times.
+* @param {Token} token
+* @param {EncodeOptions} [options]
+* @returns {Uint8Array}
+*/
+function majorSevenBytes$1(token, options) {
+	const tokenEx = token;
+	const float64 = options?.float64 === true;
+	const cached = float64 ? tokenEx._keyBytesFloat64 : tokenEx._keyBytes;
+	if (cached !== void 0) return cached;
+	const bytes = encodeMajorSevenBytes$1(token, float64);
+	if (float64) tokenEx._keyBytesFloat64 = bytes;
+	else tokenEx._keyBytes = bytes;
+	return bytes;
+}
+/**
+* Order two major 7 map keys by RFC 7049 §3.9 canonical order: shorter encoding
+* first, then bytewise. Because the four simple values encode to one byte they
+* sort ahead of every float, and comparing the `float64`-honouring encoded bytes
+* (rather than the numeric value) makes negative floats, mixed encoding widths
+* and `NaN` deterministic regardless of insertion order.
+* @param {Token} tok1
+* @param {Token} tok2
+* @param {EncodeOptions} [options]
+* @returns {number}
+*/
+encodeFloat$2.compareTokens = function compareTokens(tok1, tok2, options) {
+	const b1 = majorSevenBytes$1(tok1, options);
+	const b2 = majorSevenBytes$1(tok2, options);
+	if (b1.length !== b2.length) return b1.length < b2.length ? -1 : 1;
+	return compare$2(b1, b2);
+};
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/jump.js
+/**
+* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
+*/
+/**
+* @param {Uint8Array} data
+* @param {number} pos
+* @param {number} minor
+*/
+function invalidMinor$2(data, pos, minor) {
+	throw new Error(`${decodeErrPrefix$2} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`);
+}
+/**
+* @param {string} msg
+* @returns {()=>any}
+*/
+function errorer$2(msg) {
+	return () => {
+		throw new Error(`${decodeErrPrefix$2} ${msg}`);
+	};
+}
+/** @type {((data:Uint8Array, pos:number, minor:number, options?:DecodeOptions) => any)[]} */
+const jump$2 = [];
+for (let i = 0; i <= 23; i++) jump$2[i] = invalidMinor$2;
+jump$2[24] = decodeUint8$2;
+jump$2[25] = decodeUint16$2;
+jump$2[26] = decodeUint32$2;
+jump$2[27] = decodeUint64$2;
+jump$2[28] = invalidMinor$2;
+jump$2[29] = invalidMinor$2;
+jump$2[30] = invalidMinor$2;
+jump$2[31] = invalidMinor$2;
+for (let i = 32; i <= 55; i++) jump$2[i] = invalidMinor$2;
+jump$2[56] = decodeNegint8$2;
+jump$2[57] = decodeNegint16$2;
+jump$2[58] = decodeNegint32$2;
+jump$2[59] = decodeNegint64$2;
+jump$2[60] = invalidMinor$2;
+jump$2[61] = invalidMinor$2;
+jump$2[62] = invalidMinor$2;
+jump$2[63] = invalidMinor$2;
+for (let i = 64; i <= 87; i++) jump$2[i] = decodeBytesCompact$2;
+jump$2[88] = decodeBytes8$2;
+jump$2[89] = decodeBytes16$2;
+jump$2[90] = decodeBytes32$2;
+jump$2[91] = decodeBytes64$2;
+jump$2[92] = invalidMinor$2;
+jump$2[93] = invalidMinor$2;
+jump$2[94] = invalidMinor$2;
+jump$2[95] = errorer$2("indefinite length bytes/strings are not supported");
+for (let i = 96; i <= 119; i++) jump$2[i] = decodeStringCompact$2;
+jump$2[120] = decodeString8$2;
+jump$2[121] = decodeString16$2;
+jump$2[122] = decodeString32$2;
+jump$2[123] = decodeString64$2;
+jump$2[124] = invalidMinor$2;
+jump$2[125] = invalidMinor$2;
+jump$2[126] = invalidMinor$2;
+jump$2[127] = errorer$2("indefinite length bytes/strings are not supported");
+for (let i = 128; i <= 151; i++) jump$2[i] = decodeArrayCompact$2;
+jump$2[152] = decodeArray8$2;
+jump$2[153] = decodeArray16$2;
+jump$2[154] = decodeArray32$2;
+jump$2[155] = decodeArray64$2;
+jump$2[156] = invalidMinor$2;
+jump$2[157] = invalidMinor$2;
+jump$2[158] = invalidMinor$2;
+jump$2[159] = decodeArrayIndefinite$2;
+for (let i = 160; i <= 183; i++) jump$2[i] = decodeMapCompact$2;
+jump$2[184] = decodeMap8$2;
+jump$2[185] = decodeMap16$2;
+jump$2[186] = decodeMap32$2;
+jump$2[187] = decodeMap64$2;
+jump$2[188] = invalidMinor$2;
+jump$2[189] = invalidMinor$2;
+jump$2[190] = invalidMinor$2;
+jump$2[191] = decodeMapIndefinite$2;
+for (let i = 192; i <= 215; i++) jump$2[i] = decodeTagCompact$2;
+jump$2[216] = decodeTag8$2;
+jump$2[217] = decodeTag16$2;
+jump$2[218] = decodeTag32$2;
+jump$2[219] = decodeTag64$2;
+jump$2[220] = invalidMinor$2;
+jump$2[221] = invalidMinor$2;
+jump$2[222] = invalidMinor$2;
+jump$2[223] = invalidMinor$2;
+for (let i = 224; i <= 243; i++) jump$2[i] = errorer$2("simple values are not supported");
+jump$2[244] = invalidMinor$2;
+jump$2[245] = invalidMinor$2;
+jump$2[246] = invalidMinor$2;
+jump$2[247] = decodeUndefined$2;
+jump$2[248] = errorer$2("simple values are not supported");
+jump$2[249] = decodeFloat16$2;
+jump$2[250] = decodeFloat32$2;
+jump$2[251] = decodeFloat64$2;
+jump$2[252] = invalidMinor$2;
+jump$2[253] = invalidMinor$2;
+jump$2[254] = invalidMinor$2;
+jump$2[255] = decodeBreak$2;
+/** @type {Token[]} */
+const quick$2 = [];
+for (let i = 0; i < 24; i++) quick$2[i] = new Token$2(Type$2.uint, i, 1);
+for (let i = -1; i >= -24; i--) quick$2[31 - i] = new Token$2(Type$2.negint, i, 1);
+quick$2[64] = new Token$2(Type$2.bytes, new Uint8Array(0), 1);
+quick$2[96] = new Token$2(Type$2.string, "", 1);
+quick$2[128] = new Token$2(Type$2.array, 0, 1);
+quick$2[160] = new Token$2(Type$2.map, 0, 1);
+quick$2[244] = new Token$2(Type$2.false, false, 1);
+quick$2[245] = new Token$2(Type$2.true, true, 1);
+quick$2[246] = new Token$2(Type$2.null, null, 1);
+/**
+* @param {Token} token
+* @returns {AllocatedByteView|undefined}
+*/
+function quickEncodeToken$2(token) {
+	switch (token.type) {
+		case Type$2.false: return fromArray$2([244]);
+		case Type$2.true: return fromArray$2([245]);
+		case Type$2.null: return fromArray$2([246]);
+		case Type$2.bytes:
+			if (!token.value.length) return fromArray$2([64]);
+			return;
+		case Type$2.string:
+			if (token.value === "") return fromArray$2([96]);
+			return;
+		case Type$2.array:
+			if (token.value === 0) return fromArray$2([128]);
+			return;
+		case Type$2.map:
+			if (token.value === 0) return fromArray$2([160]);
+			return;
+		case Type$2.uint:
+			if (token.value < 24) return fromArray$2([Number(token.value)]);
+			return;
+		case Type$2.negint: if (token.value >= -24) return fromArray$2([31 - Number(token.value)]);
+	}
+}
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/encode.js
+/**
+* @typedef {import('../interface.js').EncodeOptions} EncodeOptions
+* @typedef {import('../interface.js').OptionalTypeEncoder} OptionalTypeEncoder
+* @typedef {import('../interface.js').Reference} Reference
+* @typedef {import('../interface.js').StrictTypeEncoder} StrictTypeEncoder
+* @typedef {import('../interface.js').TokenTypeEncoder} TokenTypeEncoder
+* @typedef {import('../interface.js').TokenOrNestedTokens} TokenOrNestedTokens
+* @typedef {import('../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../interface.js').ByteView} ByteView
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
+*/
+/** @type {EncodeOptions} */
+const defaultEncodeOptions$2 = {
+	float64: false,
+	mapSorter: mapSorter$2,
+	quickEncodeToken: quickEncodeToken$2
+};
+/** @type {EncodeOptions} */
+const rfc8949EncodeOptions$2 = Object.freeze({
+	mapSorter: rfc8949MapSorter$2,
+	quickEncodeToken: quickEncodeToken$2
+});
+/** @returns {TokenTypeEncoder[]} */
+function makeCborEncoders$2() {
+	const encoders = [];
+	encoders[Type$2.uint.major] = encodeUint$2;
+	encoders[Type$2.negint.major] = encodeNegint$2;
+	encoders[Type$2.bytes.major] = encodeBytes$2;
+	encoders[Type$2.string.major] = encodeString$2;
+	encoders[Type$2.array.major] = encodeArray$2;
+	encoders[Type$2.map.major] = encodeMap$2;
+	encoders[Type$2.tag.major] = encodeTag$2;
+	encoders[Type$2.float.major] = encodeFloat$2;
+	return encoders;
+}
+const cborEncoders$2 = makeCborEncoders$2();
+const defaultWriter$2 = new Bl$2();
+/** @implements {Reference} */
+var Ref$2 = class Ref$2 {
+	/**
+	* @param {object|any[]} obj
+	* @param {Reference|undefined} parent
+	*/
+	constructor(obj, parent) {
+		this.obj = obj;
+		this.parent = parent;
+	}
+	/**
+	* @param {object|any[]} obj
+	* @returns {boolean}
+	*/
+	includes(obj) {
+		/** @type {Reference|undefined} */
+		let p = this;
+		do
+			if (p.obj === obj) return true;
+		while (p = p.parent);
+		return false;
+	}
+	/**
+	* @param {Reference|undefined} stack
+	* @param {object|any[]} obj
+	* @returns {Reference}
+	*/
+	static createCheck(stack, obj) {
+		if (stack && stack.includes(obj)) throw new Error(`${encodeErrPrefix$2} object contains circular references`);
+		return new Ref$2(obj, stack);
+	}
+};
+const simpleTokens$2 = {
+	null: new Token$2(Type$2.null, null),
+	undefined: new Token$2(Type$2.undefined, void 0),
+	true: new Token$2(Type$2.true, true),
+	false: new Token$2(Type$2.false, false),
+	emptyArray: new Token$2(Type$2.array, 0),
+	emptyMap: new Token$2(Type$2.map, 0)
+};
+/** @type {{[typeName: string]: StrictTypeEncoder}} */
+const typeEncoders$2 = {
+	/**
+	* @param {any} obj
+	* @param {string} _typ
+	* @param {EncodeOptions} _options
+	* @param {Reference} [_refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	number(obj, _typ, _options, _refStack) {
+		if (!Number.isInteger(obj) || !Number.isSafeInteger(obj)) return new Token$2(Type$2.float, obj);
+		else if (obj >= 0) return new Token$2(Type$2.uint, obj);
+		else return new Token$2(Type$2.negint, obj);
+	},
+	/**
+	* @param {any} obj
+	* @param {string} _typ
+	* @param {EncodeOptions} _options
+	* @param {Reference} [_refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	bigint(obj, _typ, _options, _refStack) {
+		if (obj >= BigInt(0)) return new Token$2(Type$2.uint, obj);
+		else return new Token$2(Type$2.negint, obj);
+	},
+	/**
+	* @param {any} obj
+	* @param {string} _typ
+	* @param {EncodeOptions} _options
+	* @param {Reference} [_refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	Uint8Array(obj, _typ, _options, _refStack) {
+		return new Token$2(Type$2.bytes, obj);
+	},
+	/**
+	* @param {any} obj
+	* @param {string} _typ
+	* @param {EncodeOptions} _options
+	* @param {Reference} [_refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	string(obj, _typ, _options, _refStack) {
+		return new Token$2(Type$2.string, obj);
+	},
+	/**
+	* @param {any} obj
+	* @param {string} _typ
+	* @param {EncodeOptions} _options
+	* @param {Reference} [_refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	boolean(obj, _typ, _options, _refStack) {
+		return obj ? simpleTokens$2.true : simpleTokens$2.false;
+	},
+	/**
+	* @param {any} _obj
+	* @param {string} _typ
+	* @param {EncodeOptions} _options
+	* @param {Reference} [_refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	null(_obj, _typ, _options, _refStack) {
+		return simpleTokens$2.null;
+	},
+	/**
+	* @param {any} _obj
+	* @param {string} _typ
+	* @param {EncodeOptions} _options
+	* @param {Reference} [_refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	undefined(_obj, _typ, _options, _refStack) {
+		return simpleTokens$2.undefined;
+	},
+	/**
+	* @param {any} obj
+	* @param {string} _typ
+	* @param {EncodeOptions} _options
+	* @param {Reference} [_refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	ArrayBuffer(obj, _typ, _options, _refStack) {
+		return new Token$2(Type$2.bytes, new Uint8Array(obj));
+	},
+	/**
+	* @param {any} obj
+	* @param {string} _typ
+	* @param {EncodeOptions} _options
+	* @param {Reference} [_refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	DataView(obj, _typ, _options, _refStack) {
+		return new Token$2(Type$2.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
+	},
+	/**
+	* @param {any} obj
+	* @param {string} _typ
+	* @param {EncodeOptions} options
+	* @param {Reference} [refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	Array(obj, _typ, options, refStack) {
+		if (!obj.length) {
+			if (options.addBreakTokens === true) return [simpleTokens$2.emptyArray, new Token$2(Type$2.break)];
+			return simpleTokens$2.emptyArray;
+		}
+		refStack = Ref$2.createCheck(refStack, obj);
+		const entries = [];
+		let i = 0;
+		for (const e of obj) entries[i++] = objectToTokens$2(e, options, refStack);
+		if (options.addBreakTokens) return [
+			new Token$2(Type$2.array, obj.length),
+			entries,
+			new Token$2(Type$2.break)
+		];
+		return [new Token$2(Type$2.array, obj.length), entries];
+	},
+	/**
+	* @param {any} obj
+	* @param {string} typ
+	* @param {EncodeOptions} options
+	* @param {Reference} [refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	Object(obj, typ, options, refStack) {
+		const isMap = typ !== "Object";
+		const keys = isMap ? obj.keys() : Object.keys(obj);
+		const maxLength = isMap ? obj.size : keys.length;
+		/** @type {undefined | [TokenOrNestedTokens, TokenOrNestedTokens][]} */
+		let entries;
+		if (maxLength) {
+			entries = new Array(maxLength);
+			refStack = Ref$2.createCheck(refStack, obj);
+			const skipUndefined = !isMap && options.ignoreUndefinedProperties;
+			let i = 0;
+			for (const key of keys) {
+				const value = isMap ? obj.get(key) : obj[key];
+				if (skipUndefined && value === void 0) continue;
+				entries[i++] = [objectToTokens$2(key, options, refStack), objectToTokens$2(value, options, refStack)];
+			}
+			if (i < maxLength) entries.length = i;
+		}
+		if (!entries?.length) {
+			if (options.addBreakTokens === true) return [simpleTokens$2.emptyMap, new Token$2(Type$2.break)];
+			return simpleTokens$2.emptyMap;
+		}
+		sortMapEntries$2(entries, options);
+		if (options.addBreakTokens) return [
+			new Token$2(Type$2.map, entries.length),
+			entries,
+			new Token$2(Type$2.break)
+		];
+		return [new Token$2(Type$2.map, entries.length), entries];
+	},
+	/**
+	* Encode a `Tagged` wrapper as a CBOR tag header followed by the encoded
+	* form of the wrapped value. The value is recursively tokenised through
+	* `objectToTokens()` so any registered `typeEncoders` apply to it.
+	*
+	* @param {any} obj
+	* @param {string} _typ
+	* @param {EncodeOptions} options
+	* @param {Reference} [refStack]
+	* @returns {TokenOrNestedTokens}
+	*/
+	Tagged(obj, _typ, options, refStack) {
+		return [new Token$2(Type$2.tag, obj.tag), objectToTokens$2(obj.value, options, refStack)];
+	}
+};
+typeEncoders$2.Map = typeEncoders$2.Object;
+typeEncoders$2.Buffer = typeEncoders$2.Uint8Array;
+for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) typeEncoders$2[`${typ}Array`] = typeEncoders$2.DataView;
+/**
+* @param {any} obj
+* @param {EncodeOptions} [options]
+* @param {Reference} [refStack]
+* @returns {TokenOrNestedTokens}
+*/
+function objectToTokens$2(obj, options = {}, refStack) {
+	const typ = is$2(obj);
+	const customTypeEncoder = options && options.typeEncoders && options.typeEncoders[typ] || typeEncoders$2[typ];
+	if (typeof customTypeEncoder === "function") {
+		const tokens = customTypeEncoder(obj, typ, options, refStack);
+		if (tokens != null) return tokens;
+	}
+	const typeEncoder = typeEncoders$2[typ];
+	if (!typeEncoder) throw new Error(`${encodeErrPrefix$2} unsupported type: ${typ}`);
+	return typeEncoder(obj, typ, options, refStack);
+}
+/**
+* @param {TokenOrNestedTokens[]} entries
+* @param {EncodeOptions} options
+*/
+function sortMapEntries$2(entries, options) {
+	const mapSorter = options.mapSorter;
+	if (mapSorter) entries.sort((e1, e2) => mapSorter(e1, e2, options));
+}
+/**
+* @param {(Token|Token[])[]} e1
+* @param {(Token|Token[])[]} e2
+* @param {EncodeOptions} [options]
+* @returns {number}
+*/
+function mapSorter$2(e1, e2, options) {
+	const keyToken1 = Array.isArray(e1[0]) ? e1[0][0] : e1[0];
+	const keyToken2 = Array.isArray(e2[0]) ? e2[0][0] : e2[0];
+	if (keyToken1.type.major !== keyToken2.type.major) return keyToken1.type.compare(keyToken2.type);
+	const tcmp = cborEncoders$2[keyToken1.type.major].compareTokens(keyToken1, keyToken2, options);
+	if (tcmp === 0) console.warn("WARNING: complex key types used, CBOR key sorting guarantees are gone");
+	return tcmp;
+}
+/**
+* @typedef {Token & { _keyBytes?: AllocatedByteView }} TokenEx
+*
+* @param {(Token|Token[])[]} e1
+* @param {(Token|Token[])[]} e2
+* @returns {number}
+*/
+function rfc8949MapSorter$2(e1, e2) {
+	if (e1[0] instanceof Token$2 && e2[0] instanceof Token$2) {
+		const t1 = e1[0];
+		const t2 = e2[0];
+		if (!t1._keyBytes) t1._keyBytes = encodeRfc8949$2(t1.value);
+		if (!t2._keyBytes) t2._keyBytes = encodeRfc8949$2(t2.value);
+		return compare$2(t1._keyBytes, t2._keyBytes);
+	}
+	throw new Error("rfc8949MapSorter: complex key types are not supported yet");
+}
+/**
+* @param {any} data
+* @returns {AllocatedByteView}
+*/
+function encodeRfc8949$2(data) {
+	return encodeCustom$2(data, cborEncoders$2, rfc8949EncodeOptions$2);
+}
+/**
+* @param {ByteWriter} writer
+* @param {TokenOrNestedTokens} tokens
+* @param {TokenTypeEncoder[]} encoders
+* @param {EncodeOptions} options
+*/
+function tokensToEncoded$2(writer, tokens, encoders, options) {
+	if (Array.isArray(tokens)) for (const token of tokens) tokensToEncoded$2(writer, token, encoders, options);
+	else encoders[tokens.type.major](writer, tokens, options);
+}
+const MAJOR_UINT$2 = Type$2.uint.majorEncoded;
+const MAJOR_NEGINT$2 = Type$2.negint.majorEncoded;
+const MAJOR_BYTES$2 = Type$2.bytes.majorEncoded;
+const MAJOR_STRING$2 = Type$2.string.majorEncoded;
+const MAJOR_ARRAY$2 = Type$2.array.majorEncoded;
+const MAJOR_MAP$1 = Type$2.map.majorEncoded;
+const SIMPLE_FALSE$2 = Type$2.float.majorEncoded | 20;
+const SIMPLE_TRUE$2 = Type$2.float.majorEncoded | 21;
+const SIMPLE_NULL$2 = Type$2.float.majorEncoded | 22;
+const SIMPLE_UNDEFINED$2 = Type$2.float.majorEncoded | 23;
+const neg1b$3 = BigInt(-1);
+const pos1b$3 = BigInt(1);
+/**
+* Compact direct-path writes avoid the full uint boundary chain.
+* @param {ByteWriter} writer
+* @param {number} major
+* @param {number|bigint} uint
+*/
+function directEncodeUintValue(writer, major, uint) {
+	if (uint < 24) writer.pushByte(major | Number(uint));
+	else encodeUintValue$2(writer, major, uint);
+}
+/**
+* Check if direct encoding can be used for the given options.
+* Direct encoding bypasses token creation for most values.
+* @param {EncodeOptions} options
+* @returns {boolean}
+*/
+function canDirectEncode$1(options) {
+	return options.addBreakTokens !== true;
+}
+/**
+* Encode a map through the default deterministic sorter while keeping values
+* on the direct path. Only keys need tokens for comparison.
+* @param {ByteWriter} writer
+* @param {any} data
+* @param {string} typ
+* @param {EncodeOptions} options
+* @param {Reference|undefined} refStack
+*/
+function directEncodeMap(writer, data, typ, options, refStack) {
+	const isMap = typ === "Map";
+	const keys = isMap ? data.keys() : Object.keys(data);
+	const maxLength = isMap ? data.size : keys.length;
+	if (!maxLength) {
+		writer.pushByte(MAJOR_MAP$1);
+		return;
+	}
+	refStack = Ref$2.createCheck(refStack, data);
+	const skipUndefined = !isMap && options.ignoreUndefinedProperties;
+	const entries = new Array(maxLength);
+	let length = 0;
+	for (const key of keys) {
+		const value = isMap ? data.get(key) : data[key];
+		if (skipUndefined && value === void 0) continue;
+		entries[length++] = [objectToTokens$2(key, options, refStack), value];
+	}
+	if (length === 0) {
+		writer.pushByte(MAJOR_MAP$1);
+		return;
+	}
+	if (length < maxLength) entries.length = length;
+	entries.sort((e1, e2) => mapSorter$2(e1, e2, options));
+	directEncodeUintValue(writer, MAJOR_MAP$1, length);
+	for (const [key, value] of entries) {
+		tokensToEncoded$2(writer, key, cborEncoders$2, options);
+		directEncode$1(writer, value, options, refStack);
+	}
+}
+/**
+* Direct encode a value to the writer, bypassing token creation for most types.
+* Falls back to token-based encoding for custom type encoders.
+* @param {ByteWriter} writer
+* @param {any} data
+* @param {EncodeOptions} options
+* @param {Reference|undefined} refStack
+*/
+function directEncode$1(writer, data, options, refStack) {
+	const typ = is$2(data);
+	const customEncoder = options.typeEncoders && options.typeEncoders[typ];
+	if (customEncoder) {
+		const tokens = customEncoder(data, typ, options, refStack);
+		if (tokens != null) {
+			tokensToEncoded$2(writer, tokens, cborEncoders$2, options);
+			return;
+		}
+	}
+	switch (typ) {
+		case "null":
+			writer.pushByte(SIMPLE_NULL$2);
+			return;
+		case "undefined":
+			writer.pushByte(SIMPLE_UNDEFINED$2);
+			return;
+		case "boolean":
+			writer.pushByte(data ? SIMPLE_TRUE$2 : SIMPLE_FALSE$2);
+			return;
+		case "number":
+			if (!Number.isInteger(data) || !Number.isSafeInteger(data)) encodeFloat$2(writer, new Token$2(Type$2.float, data), options);
+			else if (data >= 0) directEncodeUintValue(writer, MAJOR_UINT$2, data);
+			else directEncodeUintValue(writer, MAJOR_NEGINT$2, data * -1 - 1);
+			return;
+		case "bigint":
+			if (data >= BigInt(0)) directEncodeUintValue(writer, MAJOR_UINT$2, data);
+			else directEncodeUintValue(writer, MAJOR_NEGINT$2, data * neg1b$3 - pos1b$3);
+			return;
+		case "string": {
+			const bytes = fromString$3(data);
+			directEncodeUintValue(writer, MAJOR_STRING$2, bytes.length);
+			writer.push(bytes);
+			return;
+		}
+		case "Uint8Array":
+			directEncodeUintValue(writer, MAJOR_BYTES$2, data.length);
+			writer.push(data);
+			return;
+		case "Array":
+			if (!data.length) {
+				writer.pushByte(MAJOR_ARRAY$2);
+				return;
+			}
+			refStack = Ref$2.createCheck(refStack, data);
+			directEncodeUintValue(writer, MAJOR_ARRAY$2, data.length);
+			for (const elem of data) directEncode$1(writer, elem, options, refStack);
+			return;
+		case "Object":
+		case "Map":
+			if (options.mapSorter === mapSorter$2) directEncodeMap(writer, data, typ, options, refStack);
+			else tokensToEncoded$2(writer, typeEncoders$2.Object(data, typ, options, refStack), cborEncoders$2, options);
+			return;
+		default: {
+			const typeEncoder = typeEncoders$2[typ];
+			if (!typeEncoder) throw new Error(`${encodeErrPrefix$2} unsupported type: ${typ}`);
+			tokensToEncoded$2(writer, typeEncoder(data, typ, options, refStack), cborEncoders$2, options);
+		}
+	}
+}
+/**
+* @template {ArrayBufferLike} T
+* @overload
+* @param {any} data
+* @param {TokenTypeEncoder[]} encoders
+* @param {EncodeOptions} options
+* @param {Uint8Array<T>} destination
+* @returns {Uint8Array<T>}
+*/
+/**
+* @overload
+* @param {any} data
+* @param {TokenTypeEncoder[]} encoders
+* @param {EncodeOptions} options
+* @returns {AllocatedByteView}
+*/
+/**
+* @param {any} data
+* @param {TokenTypeEncoder[]} encoders
+* @param {EncodeOptions} options
+* @param {ByteView} [destination]
+* @returns {ByteView}
+*/
+function encodeCustom$2(data, encoders, options, destination) {
+	const hasDest = destination instanceof Uint8Array;
+	let writeTo = hasDest ? new U8Bl$2(destination) : defaultWriter$2;
+	const tokens = objectToTokens$2(data, options);
+	if (!Array.isArray(tokens) && options.quickEncodeToken) {
+		const quickBytes = options.quickEncodeToken(tokens);
+		if (quickBytes) {
+			if (hasDest) {
+				writeTo.push(quickBytes);
+				return writeTo.toBytes();
+			}
+			return quickBytes;
+		}
+		const encoder = encoders[tokens.type.major];
+		if (encoder.encodedSize) {
+			const size = encoder.encodedSize(tokens, options);
+			if (!hasDest) writeTo = new Bl$2(size);
+			encoder(writeTo, tokens, options);
+			if (writeTo.chunks.length !== 1) throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
+			return hasDest ? writeTo.toBytes() : asU8A$2(writeTo.chunks[0]);
+		}
+	}
+	writeTo.reset();
+	tokensToEncoded$2(writeTo, tokens, encoders, options);
+	return writeTo.toBytes(true);
+}
+/**
+* @param {any} data
+* @param {EncodeOptions} [options]
+* @returns {AllocatedByteView}
+*/
+function encode$8(data, options) {
+	options = Object.assign({}, defaultEncodeOptions$2, options);
+	if (canDirectEncode$1(options)) {
+		defaultWriter$2.reset();
+		directEncode$1(defaultWriter$2, data, options, void 0);
+		return defaultWriter$2.toBytes(true);
+	}
+	return encodeCustom$2(data, cborEncoders$2, options);
+}
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/decode.js
+/**
+* @typedef {import('./token.js').Token} Token
+* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+* @typedef {import('../interface.js').DecodeTokenizer} DecodeTokenizer
+* @typedef {import('../interface.js').TagDecodeControl} TagDecodeControl
+*/
+const defaultDecodeOptions$2 = {
+	strict: false,
+	allowIndefinite: true,
+	allowUndefined: true,
+	allowBigInt: true
+};
+/**
+* @implements {DecodeTokenizer}
+*/
+var Tokeniser$2 = class {
+	/**
+	* @param {Uint8Array} data
+	* @param {DecodeOptions} options
+	*/
+	constructor(data, options = {}) {
+		this._pos = 0;
+		this.data = data;
+		this.options = options;
+	}
+	pos() {
+		return this._pos;
+	}
+	done() {
+		return this._pos >= this.data.length;
+	}
+	next() {
+		const byt = this.data[this._pos];
+		let token = quick$2[byt];
+		if (token === void 0) {
+			const decoder = jump$2[byt];
+			if (!decoder) throw new Error(`${decodeErrPrefix$2} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, "0")})`);
+			const minor = byt & 31;
+			token = decoder(this.data, this._pos, minor, this.options);
+		}
+		this._pos += token.encodedLength;
+		return token;
+	}
+};
+const DONE$2 = Symbol.for("DONE");
+const BREAK$2 = Symbol.for("BREAK");
+/**
+* @param {Token} token
+* @param {DecodeTokenizer} tokeniser
+* @param {DecodeOptions} options
+* @returns {any|typeof BREAK|typeof DONE}
+*/
+function tokenToArray$2(token, tokeniser, options) {
+	const arr = [];
+	for (let i = 0; i < token.value; i++) {
+		const value = tokensToObject$2(tokeniser, options);
+		if (value === BREAK$2) {
+			if (token.value === Infinity) break;
+			throw new Error(`${decodeErrPrefix$2} got unexpected break to lengthed array`);
+		}
+		if (value === DONE$2) throw new Error(`${decodeErrPrefix$2} found array but not enough entries (got ${i}, expected ${token.value})`);
+		arr[i] = value;
+	}
+	return arr;
+}
+/**
+* @param {Token} token
+* @param {DecodeTokenizer} tokeniser
+* @param {DecodeOptions} options
+* @returns {any|typeof BREAK|typeof DONE}
+*/
+function tokenToMap$2(token, tokeniser, options) {
+	const useMaps = options.useMaps === true;
+	const rejectDuplicateMapKeys = options.rejectDuplicateMapKeys === true;
+	const obj = useMaps ? void 0 : {};
+	const m = useMaps ? /* @__PURE__ */ new Map() : void 0;
+	for (let i = 0; i < token.value; i++) {
+		const key = tokensToObject$2(tokeniser, options);
+		if (key === BREAK$2) {
+			if (token.value === Infinity) break;
+			throw new Error(`${decodeErrPrefix$2} got unexpected break to lengthed map`);
+		}
+		if (key === DONE$2) throw new Error(`${decodeErrPrefix$2} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
+		if (!useMaps && typeof key !== "string") throw new Error(`${decodeErrPrefix$2} non-string keys not supported (got ${typeof key})`);
+		if (rejectDuplicateMapKeys) {
+			if (useMaps && m.has(key) || !useMaps && Object.hasOwn(obj, key)) throw new Error(`${decodeErrPrefix$2} found repeat map key "${key}"`);
+		}
+		const value = tokensToObject$2(tokeniser, options);
+		if (value === DONE$2) throw new Error(`${decodeErrPrefix$2} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
+		if (useMaps) m.set(key, value);
+		else obj[key] = value;
+	}
+	return useMaps ? m : obj;
+}
+/**
+* Generator that yields [key, value] entries from a CBOR map token.
+* Used by tag decoders that need to preserve key types (e.g., Tag 259 Map).
+* @param {Token} token - The map token
+* @param {DecodeTokenizer} tokeniser
+* @param {DecodeOptions} options
+* @returns {Generator<[any, any], void, unknown>}
+*/
+function* tokenToMapEntries$2(token, tokeniser, options) {
+	for (let i = 0; i < token.value; i++) {
+		const key = tokensToObject$2(tokeniser, options);
+		if (key === BREAK$2) {
+			if (token.value === Infinity) break;
+			throw new Error(`${decodeErrPrefix$2} got unexpected break to lengthed map`);
+		}
+		if (key === DONE$2) throw new Error(`${decodeErrPrefix$2} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
+		const value = tokensToObject$2(tokeniser, options);
+		if (value === DONE$2) throw new Error(`${decodeErrPrefix$2} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
+		yield [key, value];
+	}
+}
+/**
+* Creates a TagDecodeControl object for tag decoders.
+* @param {DecodeTokenizer} tokeniser
+* @param {DecodeOptions} options
+* @returns {TagDecodeControl}
+*/
+function createTagDecodeControl$2(tokeniser, options) {
+	/** @type {TagDecodeControl & {_called: boolean}} */
+	const decode = function() {
+		if (decode._called) throw new Error(`${decodeErrPrefix$2} tag decode() may only be called once`);
+		decode._called = true;
+		const value = tokensToObject$2(tokeniser, options);
+		if (value === DONE$2) throw new Error(`${decodeErrPrefix$2} tag content missing`);
+		if (value === BREAK$2) throw new Error(`${decodeErrPrefix$2} got unexpected break in tag content`);
+		return value;
+	};
+	decode.entries = function() {
+		if (decode._called) throw new Error(`${decodeErrPrefix$2} tag decode() may only be called once`);
+		decode._called = true;
+		const token = tokeniser.next();
+		if (!Type$2.equals(token.type, Type$2.map)) throw new Error(`${decodeErrPrefix$2} entries() requires map content, got ${token.type.name}`);
+		const entries = [];
+		for (const entry of tokenToMapEntries$2(token, tokeniser, options)) entries.push(entry);
+		return entries;
+	};
+	decode._called = false;
+	return decode;
+}
+/**
+* @param {DecodeTokenizer} tokeniser
+* @param {DecodeOptions} options
+* @returns {any|typeof BREAK|typeof DONE}
+*/
+function tokensToObject$2(tokeniser, options) {
+	if (tokeniser.done()) return DONE$2;
+	const token = tokeniser.next();
+	if (Type$2.equals(token.type, Type$2.break)) return BREAK$2;
+	if (token.type.terminal) return token.value;
+	if (Type$2.equals(token.type, Type$2.array)) return tokenToArray$2(token, tokeniser, options);
+	if (Type$2.equals(token.type, Type$2.map)) return tokenToMap$2(token, tokeniser, options);
+	if (Type$2.equals(token.type, Type$2.tag)) {
+		if (options.tags && typeof options.tags[token.value] === "function") {
+			const decodeControl = createTagDecodeControl$2(tokeniser, options);
+			const result = options.tags[token.value](decodeControl);
+			if (!decodeControl._called) throw new Error(`${decodeErrPrefix$2} tag decoder must call decode() or entries()`);
+			return result;
+		}
+		throw new Error(`${decodeErrPrefix$2} tag not supported (${token.value})`);
+	}
+	throw new Error("unsupported");
+}
+/**
+* @param {Uint8Array} data
+* @param {DecodeOptions} [options]
+* @returns {[any, Uint8Array]}
+*/
+function decodeFirst$2(data, options) {
+	if (!(data instanceof Uint8Array)) throw new Error(`${decodeErrPrefix$2} data to decode must be a Uint8Array`);
+	options = Object.assign({}, defaultDecodeOptions$2, options);
+	const u8aData = asU8A$2(data);
+	const tokeniser = options.tokenizer || new Tokeniser$2(u8aData, options);
+	const decoded = tokensToObject$2(tokeniser, options);
+	if (decoded === DONE$2) throw new Error(`${decodeErrPrefix$2} did not find any content to decode`);
+	if (decoded === BREAK$2) throw new Error(`${decodeErrPrefix$2} got unexpected break`);
+	return [decoded, data.subarray(tokeniser.pos())];
+}
+/**
+* @param {Uint8Array} data
+* @param {DecodeOptions} [options]
+* @returns {any}
+*/
+function decode$9(data, options) {
+	const [decoded, remainder] = decodeFirst$2(data, options);
+	if (remainder.length > 0) throw new Error(`${decodeErrPrefix$2} too many terminals, data makes no sense`);
+	return decoded;
+}
+Object.defineProperty(class Tagged$2 {
+	/**
+	* @param {number} tag - CBOR tag number, a non-negative integer
+	* @param {any} value - The value to be tagged; encoded recursively
+	*/
+	constructor(tag, value) {
+		if (typeof tag !== "number" || !Number.isInteger(tag) || tag < 0) throw new TypeError("Tagged: tag must be a non-negative integer");
+		this.tag = tag;
+		this.value = value;
+	}
+	/**
+	* Build a tag decoder for use in `decode()`'s `tags` option that returns the
+	* decoded content wrapped in a `Tagged` instance, preserving the tag number
+	* for the caller to inspect.
+	*
+	* @param {number} tag - The CBOR tag number this decoder will be registered for
+	* @returns {TaggedTagDecoder}
+	*
+	* @example
+	* import { decode, Tagged } from 'cborg'
+	* const value = decode(bytes, { tags: { 16: Tagged.decoder(16) } })
+	* // value instanceof Tagged; value.tag === 16
+	*/
+	static decoder(tag) {
+		return (decode) => new Tagged$2(tag, decode());
+	}
+	/**
+	* Build a `tags` option for `decode()` that wraps each listed tag number in
+	* a `Tagged` instance, preserving those tags through decode without
+	* registering a dedicated decoder per tag.
+	*
+	* @param {...number} tagNumbers - One or more CBOR tag numbers to preserve
+	* @returns {{[tagNumber: number]: TaggedTagDecoder}}
+	*
+	* @example
+	* import { decode, Tagged } from 'cborg'
+	* const value = decode(bytes, { tags: Tagged.preserve(16, 96) })
+	*/
+	static preserve(...tagNumbers) {
+		/** @type {{[tagNumber: number]: TaggedTagDecoder}} */
+		const tags = {};
+		for (const tag of tagNumbers) tags[tag] = Tagged$2.decoder(tag);
+		return tags;
+	}
+}.prototype, Symbol.toStringTag, { value: "Tagged" });
+//#endregion
+//#region node_modules/kubo-rpc-client/node_modules/@ipld/dag-cbor/src/index.js
+var src_exports$1 = /* @__PURE__ */ __exportAll({
+	code: () => 113,
+	decode: () => decode$8,
+	decodeOptions: () => decodeOptions$2,
+	encode: () => encode$7,
+	encodeOptions: () => encodeOptions$2,
+	name: () => name$2,
+	toByteView: () => toByteView$2
+});
+const CID_CBOR_TAG$1 = 42;
+/**
+* @template T
+* @typedef {import('multiformats/codecs/interface').ByteView<T>} ByteView
+*/
+/**
+* @template T
+* @typedef {import('multiformats/codecs/interface').ArrayBufferView<T>} ArrayBufferView
+*/
+/**
+* @template T
+* @param {ByteView<T> | ArrayBufferView<T>} buf
+* @returns {ByteView<T>}
+*/
+function toByteView$2(buf) {
+	if (buf instanceof ArrayBuffer) return new Uint8Array(buf, 0, buf.byteLength);
+	return buf;
+}
+/**
+* cidEncoder will receive all Objects during encode, it needs to filter out
+* anything that's not a CID and return `null` for that so it's encoded as
+* normal.
+*
+* @param {any} obj
+* @returns {cborg.Token[]|null}
+*/
+function cidEncoder$2(obj) {
+	if (obj.asCID !== obj && obj["/"] !== obj.bytes) return null;
+	const cid = CID.asCID(obj);
+	/* c8 ignore next 4 */
+	if (!cid) return null;
+	const bytes = new Uint8Array(cid.bytes.byteLength + 1);
+	bytes.set(cid.bytes, 1);
+	return [new Token$2(Type$2.tag, CID_CBOR_TAG$1), new Token$2(Type$2.bytes, bytes)];
+}
+/**
+* Intercept all `undefined` values from an object walk and reject the entire
+* object if we find one.
+*
+* @returns {null}
+*/
+function undefinedEncoder$2() {
+	throw new Error("`undefined` is not supported by the IPLD Data Model and cannot be encoded");
+}
+/**
+* Intercept all `number` values from an object walk and reject the entire
+* object if we find something that doesn't fit the IPLD data model (NaN &
+* Infinity).
+*
+* @param {number} num
+* @returns {null}
+*/
+function numberEncoder$2(num) {
+	if (Number.isNaN(num)) throw new Error("`NaN` is not supported by the IPLD Data Model and cannot be encoded");
+	if (num === Infinity || num === -Infinity) throw new Error("`Infinity` and `-Infinity` is not supported by the IPLD Data Model and cannot be encoded");
+	return null;
+}
+/**
+* @param {Map<any, any>} map
+* @returns {null}
+*/
+function mapEncoder$1(map) {
+	for (const key of map.keys()) if (typeof key !== "string" || key.length === 0) throw new Error("Non-string Map keys are not supported by the IPLD Data Model and cannot be encoded");
+	return null;
+}
+const _encodeOptions$1 = {
+	float64: true,
+	typeEncoders: {
+		Map: mapEncoder$1,
+		Object: cidEncoder$2,
+		undefined: undefinedEncoder$2,
+		number: numberEncoder$2
+	}
+};
+const encodeOptions$2 = {
+	..._encodeOptions$1,
+	typeEncoders: { ..._encodeOptions$1.typeEncoders }
+};
+/**
+* @param {import('cborg').TagDecodeControl} decode
+* @returns {CID}
+*/
+function cidDecoder$1(decode) {
+	const bytes = decode();
+	if (bytes[0] !== 0) throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
+	return CID.decode(bytes.subarray(1));
+}
+const _decodeOptions$1 = {
+	allowIndefinite: false,
+	coerceUndefinedToNull: true,
+	allowNaN: false,
+	allowInfinity: false,
+	allowBigInt: true,
+	strict: true,
+	useMaps: false,
+	rejectDuplicateMapKeys: true,
+	/** @type {{ [tagNumber: number]: import('cborg').TagDecoder }} */
+	tags: { [CID_CBOR_TAG$1]: cidDecoder$1 }
+};
+const decodeOptions$2 = {
+	..._decodeOptions$1,
+	tags: { ..._decodeOptions$1.tags }
+};
+const name$2 = "dag-cbor";
+/**
+* @template T
+* @param {T} node
+* @returns {ByteView<T>}
+*/
+const encode$7 = (node) => encode$8(node, _encodeOptions$1);
+/**
+* @template T
+* @param {ByteView<T> | ArrayBufferView<T>} data
+* @returns {T}
+*/
+const decode$8 = (data) => decode$9(toByteView$2(data), _decodeOptions$1);
+//#endregion
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/is.js
 const objectTypeNames$1 = [
 	"Object",
 	"RegExp",
@@ -57,14 +2526,12 @@ function is$1(value) {
 	if (value === true || value === false) return "boolean";
 	const typeOf = typeof value;
 	if (typeOf === "string" || typeOf === "number" || typeOf === "bigint" || typeOf === "symbol") return typeOf;
-	/* c8 ignore next 3 */
 	if (typeOf === "function") return "Function";
 	if (Array.isArray(value)) return "Array";
 	if (value instanceof Uint8Array) return "Uint8Array";
 	if (value.constructor === Object) return "Object";
 	const objectType = getObjectType$1(value);
 	if (objectType) return objectType;
-	/* c8 ignore next */
 	return "Object";
 }
 /**
@@ -76,7 +2543,7 @@ function getObjectType$1(value) {
 	if (objectTypeNames$1.includes(objectTypeName)) return objectTypeName;
 }
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/token.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/token.js
 var Type$1 = class {
 	/**
 	* @param {number} major
@@ -89,7 +2556,6 @@ var Type$1 = class {
 		this.name = name;
 		this.terminal = terminal;
 	}
-	/* c8 ignore next 3 */
 	toString() {
 		return `Type[${this.major}].${this.name}`;
 	}
@@ -98,7 +2564,6 @@ var Type$1 = class {
 	* @returns {number}
 	*/
 	compare(typ) {
-		/* c8 ignore next 1 */
 		return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
 	}
 	/**
@@ -141,16 +2606,19 @@ var Token$1 = class {
 		/** @type {Uint8Array|undefined} */
 		this.byteValue = void 0;
 	}
-	/* c8 ignore next 3 */
 	toString() {
 		return `Token[${this.type}].${this.value}`;
 	}
 };
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/byte-utils.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/byte-utils.js
 const useBuffer$1 = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === "function";
 const textEncoder$1 = new TextEncoder();
 /**
+* @typedef {import('../interface.js').ByteView} ByteView
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
+*/
+/**
 * @param {Uint8Array} buf
 * @returns {boolean}
 */
@@ -158,11 +2626,10 @@ function isBuffer$1(buf) {
 	return useBuffer$1 && globalThis.Buffer.isBuffer(buf);
 }
 /**
-* @param {Uint8Array|number[]} buf
-* @returns {Uint8Array}
+* @param {ByteView|number[]} buf
+* @returns {ByteView}
 */
 function asU8A$1(buf) {
-	/* c8 ignore next */
 	if (!(buf instanceof Uint8Array)) return Uint8Array.from(buf);
 	return isBuffer$1(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf;
 }
@@ -180,7 +2647,7 @@ const fromString$2 = useBuffer$1 ? (string) => {
 /**
 * Buffer variant not fast enough for what we need
 * @param {number[]} arr
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 const fromArray$1 = (arr) => {
 	return Uint8Array.from(arr);
@@ -198,14 +2665,13 @@ const slice$1 = useBuffer$1 ? (bytes, start, end) => {
 	return bytes.slice(start, end);
 };
 const concat$1 = useBuffer$1 ? (chunks, length) => {
-	/* c8 ignore next 1 */
 	chunks = chunks.map((c) => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
 	return asU8A$1(globalThis.Buffer.concat(chunks, length));
 } : 
 /**
-* @param {Uint8Array[]} chunks
+* @param {ByteView[]} chunks
 * @param {number} length
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 (chunks, length) => {
 	const out = new Uint8Array(length);
@@ -222,7 +2688,7 @@ const alloc$1 = useBuffer$1 ? (size) => {
 } : 
 /**
 * @param {number} size
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 (size) => {
 	return new Uint8Array(size);
@@ -233,7 +2699,6 @@ const alloc$1 = useBuffer$1 ? (size) => {
 * @returns {number}
 */
 function compare$1(b1, b2) {
-	/* c8 ignore next 5 */
 	if (isBuffer$1(b1) && isBuffer$1(b2)) return b1.compare(b2);
 	for (let i = 0; i < b1.length; i++) {
 		if (b1[i] === b2[i]) continue;
@@ -277,14 +2742,13 @@ const MAX_ARGUMENTS_LENGTH = 4096;
 function decodeCodePointsArray(codePoints) {
 	const len = codePoints.length;
 	if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
-	/* c8 ignore next 10 */
 	let res = "";
 	let i = 0;
 	while (i < len) res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
 	return res;
 }
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/bl.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/bl.js
 /**
 * Bl is a list of byte chunks, similar to https://github.com/rvagg/bl but for
 * writing rather than reading.
@@ -301,6 +2765,10 @@ function decodeCodePointsArray(codePoints) {
 * will be `0` to write at the current cursor position but it can be ahead of
 * the current cursor. Negative offsets probably work but are untested.
 */
+/**
+* @typedef {import('../interface.js').ByteView} ByteView
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
+*/
 const defaultChunkSize$1 = 256;
 var Bl$1 = class {
 	/**
@@ -312,9 +2780,9 @@ var Bl$1 = class {
 		this.cursor = 0;
 		/** @type {number} */
 		this.maxCursor = -1;
-		/** @type {(Uint8Array|number[])[]} */
+		/** @type {(ByteView|number[])[]} */
 		this.chunks = [];
-		/** @type {Uint8Array|number[]|null} */
+		/** @type {ByteView|number[]|null} */
 		this._initReuseChunk = null;
 	}
 	reset() {
@@ -327,7 +2795,22 @@ var Bl$1 = class {
 		}
 	}
 	/**
-	* @param {Uint8Array|number[]} bytes
+	* @param {number} byte
+	*/
+	pushByte(byte) {
+		let topChunk = this.chunks[this.chunks.length - 1];
+		if (this.cursor > this.maxCursor) {
+			topChunk = alloc$1(this.chunkSize);
+			this.chunks.push(topChunk);
+			this.maxCursor += topChunk.length;
+			if (this._initReuseChunk === null) this._initReuseChunk = topChunk;
+		}
+		const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
+		topChunk[chunkPos] = byte;
+		this.cursor++;
+	}
+	/**
+	* @param {ByteView|number[]} bytes
 	*/
 	push(bytes) {
 		let topChunk = this.chunks[this.chunks.length - 1];
@@ -357,14 +2840,13 @@ var Bl$1 = class {
 	}
 	/**
 	* @param {boolean} [reset]
-	* @returns {Uint8Array}
+	* @returns {AllocatedByteView}
 	*/
 	toBytes(reset = false) {
 		let byts;
 		if (this.chunks.length === 1) {
 			const chunk = this.chunks[0];
 			if (reset && this.cursor > chunk.length / 2) {
-				/* c8 ignore next 2 */
 				byts = this.cursor === chunk.length ? chunk : chunk.subarray(0, this.cursor);
 				this._initReuseChunk = null;
 				this.chunks = [];
@@ -377,23 +2859,31 @@ var Bl$1 = class {
 /**
 * U8Bl is a buffer list that writes directly to a user-provided Uint8Array.
 * It provides the same interface as Bl but writes to a fixed destination.
+* @template {ArrayBufferLike} T
 */
 var U8Bl$1 = class {
 	/**
-	* @param {Uint8Array} dest
+	* @param {Uint8Array<T>} dest
 	*/
 	constructor(dest) {
 		this.dest = dest;
 		/** @type {number} */
 		this.cursor = 0;
-		/** @type {Uint8Array[]} */
+		/** @type {Array<Uint8Array<T>>} */
 		this.chunks = [dest];
 	}
 	reset() {
 		this.cursor = 0;
 	}
 	/**
-	* @param {Uint8Array|number[]} bytes
+	* @param {number} byte
+	*/
+	pushByte(byte) {
+		if (this.cursor >= this.dest.length) throw new Error("write out of bounds, destination buffer is too small");
+		this.dest[this.cursor++] = byte;
+	}
+	/**
+	* @param {ByteView|number[]} bytes
 	*/
 	push(bytes) {
 		if (this.cursor + bytes.length > this.dest.length) throw new Error("write out of bounds, destination buffer is too small");
@@ -402,7 +2892,7 @@ var U8Bl$1 = class {
 	}
 	/**
 	* @param {boolean} [reset]
-	* @returns {Uint8Array}
+	* @returns {Uint8Array<T>}
 	*/
 	toBytes(reset = false) {
 		const byts = this.dest.subarray(0, this.cursor);
@@ -411,7 +2901,7 @@ var U8Bl$1 = class {
 	}
 };
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/common.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/common.js
 const decodeErrPrefix$1 = "CBOR decode error:";
 const encodeErrPrefix$1 = "CBOR encode error:";
 const uintMinorPrefixBytes$1 = [];
@@ -429,7 +2919,7 @@ function assertEnoughData$1(data, pos, need) {
 	if (data.length - pos < need) throw new Error(`${decodeErrPrefix$1} not enough data for type`);
 }
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/0uint.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/0uint.js
 const uintBoundaries$1 = [
 	24,
 	256,
@@ -548,7 +3038,7 @@ function encodeUint$1(writer, token) {
 function encodeUintValue$1(writer, major, uint) {
 	if (uint < uintBoundaries$1[0]) {
 		const nuint = Number(uint);
-		writer.push([major | nuint]);
+		writer.pushByte(major | nuint);
 	} else if (uint < uintBoundaries$1[1]) {
 		const nuint = Number(uint);
 		writer.push([major | 24, nuint]);
@@ -625,10 +3115,10 @@ encodeUintValue$1.encodedSize = function encodedSize(uint) {
 * @returns {number}
 */
 encodeUint$1.compareTokens = function compareTokens(tok1, tok2) {
-	return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 	/* c8 ignore next */ 0;
+	return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 0;
 };
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/1negint.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/1negint.js
 /**
 * @typedef {import('../interface.js').ByteWriter} ByteWriter
 * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
@@ -663,8 +3153,8 @@ function decodeNegint16$1(data, pos, _minor, options) {
 function decodeNegint32$1(data, pos, _minor, options) {
 	return new Token$1(Type$1.negint, -1 - readUint32$1(data, pos + 1, options), 5);
 }
-const neg1b$3 = BigInt(-1);
-const pos1b$3 = BigInt(1);
+const neg1b$2 = BigInt(-1);
+const pos1b$2 = BigInt(1);
 /**
 * @param {Uint8Array} data
 * @param {number} pos
@@ -679,7 +3169,7 @@ function decodeNegint64$1(data, pos, _minor, options) {
 		if (value >= Number.MIN_SAFE_INTEGER) return new Token$1(Type$1.negint, value, 9);
 	}
 	if (options.allowBigInt !== true) throw new Error(`${decodeErrPrefix$1} integers outside of the safe integer range are not supported`);
-	return new Token$1(Type$1.negint, neg1b$3 - BigInt(int), 9);
+	return new Token$1(Type$1.negint, neg1b$2 - BigInt(int), 9);
 }
 /**
 * @param {ByteWriter} writer
@@ -687,7 +3177,7 @@ function decodeNegint64$1(data, pos, _minor, options) {
 */
 function encodeNegint$1(writer, token) {
 	const negint = token.value;
-	const unsigned = typeof negint === "bigint" ? negint * neg1b$3 - pos1b$3 : negint * -1 - 1;
+	const unsigned = typeof negint === "bigint" ? negint * neg1b$2 - pos1b$2 : negint * -1 - 1;
 	encodeUintValue$1(writer, token.type.majorEncoded, unsigned);
 }
 /**
@@ -696,8 +3186,7 @@ function encodeNegint$1(writer, token) {
 */
 encodeNegint$1.encodedSize = function encodedSize(token) {
 	const negint = token.value;
-	const unsigned = typeof negint === "bigint" ? negint * neg1b$3 - pos1b$3 : negint * -1 - 1;
-	/* c8 ignore next 4 */
+	const unsigned = typeof negint === "bigint" ? negint * neg1b$2 - pos1b$2 : negint * -1 - 1;
 	if (unsigned < uintBoundaries$1[0]) return 1;
 	if (unsigned < uintBoundaries$1[1]) return 2;
 	if (unsigned < uintBoundaries$1[2]) return 3;
@@ -710,10 +3199,10 @@ encodeNegint$1.encodedSize = function encodedSize(token) {
 * @returns {number}
 */
 encodeNegint$1.compareTokens = function compareTokens(tok1, tok2) {
-	return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : 	/* c8 ignore next */ 0;
+	return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : 0;
 };
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/2bytes.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/2bytes.js
 /**
 * @typedef {import('../interface.js').ByteWriter} ByteWriter
 * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
@@ -826,7 +3315,7 @@ function compareBytes$1(b1, b2) {
 	return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare$1(b1, b2);
 }
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/3string.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/3string.js
 const textDecoder$1 = new TextDecoder();
 const ASCII_THRESHOLD$1 = 32;
 /**
@@ -922,7 +3411,7 @@ function decodeString64$1(data, pos, _minor, options) {
 }
 const encodeString$1 = encodeBytes$1;
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/4array.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/4array.js
 /**
 * @typedef {import('../interface.js').ByteWriter} ByteWriter
 * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
@@ -1016,7 +3505,7 @@ encodeArray$1.encodedSize = function encodedSize(token) {
 	return encodeUintValue$1.encodedSize(token.value);
 };
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/5map.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/5map.js
 /**
 * @typedef {import('../interface.js').ByteWriter} ByteWriter
 * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
@@ -1110,7 +3599,7 @@ encodeMap$1.encodedSize = function encodedSize(token) {
 	return encodeUintValue$1.encodedSize(token.value);
 };
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/6tag.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/6tag.js
 /**
 * @typedef {import('../interface.js').ByteWriter} ByteWriter
 * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
@@ -1253,10 +3742,10 @@ function decodeFloat64$1(data, pos, _minor, options) {
 */
 function encodeFloat$1(writer, token, options) {
 	const float = token.value;
-	if (float === false) writer.push([Type$1.float.majorEncoded | 20]);
-	else if (float === true) writer.push([Type$1.float.majorEncoded | 21]);
-	else if (float === null) writer.push([Type$1.float.majorEncoded | 22]);
-	else if (float === void 0) writer.push([Type$1.float.majorEncoded | 23]);
+	if (float === false) writer.pushByte(Type$1.float.majorEncoded | 20);
+	else if (float === true) writer.pushByte(Type$1.float.majorEncoded | 21);
+	else if (float === null) writer.pushByte(Type$1.float.majorEncoded | 22);
+	else if (float === void 0) writer.pushByte(Type$1.float.majorEncoded | 23);
 	else {
 		let decoded;
 		let success = false;
@@ -1318,12 +3807,10 @@ function encodeFloat16$1(inp) {
 		const valu32 = dataView$1.getUint32(0);
 		const exponent = (valu32 & 2139095040) >> 23;
 		const mantissa = valu32 & 8388607;
-		/* c8 ignore next 6 */
 		if (exponent === 255) dataView$1.setUint16(0, 31744, false);
 		else if (exponent === 0) dataView$1.setUint16(0, (valu32 & 2147483648) >> 16 | mantissa >> 13, false);
 		else {
 			const logicalExponent = exponent - 127;
-			/* c8 ignore next 6 */
 			if (logicalExponent < -24) dataView$1.setUint16(0, 0);
 			else if (logicalExponent < -14) dataView$1.setUint16(0, (valu32 & 2147483648) >> 16 | 1 << 24 + logicalExponent, false);
 			else dataView$1.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
@@ -1382,15 +3869,82 @@ function readFloat64$1(ui8a, pos) {
 	return new DataView(ui8a.buffer, offset, 8).getFloat64(0, false);
 }
 /**
-* @param {Token} _tok1
-* @param {Token} _tok2
+* @typedef {Token & {
+*   _keyBytes?: Uint8Array,
+*   _keyBytesFloat64?: Uint8Array
+* }} TokenEx
+*/
+/**
+* The canonical CBOR bytes for a major 7 map key. The four simple values encode
+* to a single byte and every float to its 3, 5 or 9 byte form, exactly as
+* {@link encodeFloat} writes them. This mirrors the width selection in
+* `encodeFloat` because the sorter needs the bytes in hand to compare.
+* @param {Token} token
+* @param {boolean} float64
+* @returns {Uint8Array}
+*/
+function encodeMajorSevenBytes(token, float64) {
+	const float = token.value;
+	if (float === false) return Uint8Array.of(Type$1.float.majorEncoded | 20);
+	if (float === true) return Uint8Array.of(Type$1.float.majorEncoded | 21);
+	if (float === null) return Uint8Array.of(Type$1.float.majorEncoded | 22);
+	if (float === void 0) return Uint8Array.of(Type$1.float.majorEncoded | 23);
+	if (!float64) {
+		encodeFloat16$1(float);
+		if (float === readFloat16$1(ui8a$1, 1) || Number.isNaN(float)) {
+			ui8a$1[0] = 249;
+			return ui8a$1.slice(0, 3);
+		}
+		encodeFloat32$1(float);
+		if (float === readFloat32$1(ui8a$1, 1)) {
+			ui8a$1[0] = 250;
+			return ui8a$1.slice(0, 5);
+		}
+	}
+	encodeFloat64$1(float);
+	ui8a$1[0] = 251;
+	return ui8a$1.slice(0, 9);
+}
+/**
+* Get the canonical CBOR bytes for a major 7 map key, honouring
+* `options.float64`. Bytes are cached because Array.sort compares each key
+* multiple times.
+* @param {Token} token
+* @param {EncodeOptions} [options]
+* @returns {Uint8Array}
+*/
+function majorSevenBytes(token, options) {
+	const tokenEx = token;
+	const float64 = options?.float64 === true;
+	const cached = float64 ? tokenEx._keyBytesFloat64 : tokenEx._keyBytes;
+	if (cached !== void 0) return cached;
+	const bytes = encodeMajorSevenBytes(token, float64);
+	if (float64) tokenEx._keyBytesFloat64 = bytes;
+	else tokenEx._keyBytes = bytes;
+	return bytes;
+}
+/**
+* Order two major 7 map keys by RFC 7049 §3.9 canonical order: shorter encoding
+* first, then bytewise. Because the four simple values encode to one byte they
+* sort ahead of every float, and comparing the `float64`-honouring encoded bytes
+* (rather than the numeric value) makes negative floats, mixed encoding widths
+* and `NaN` deterministic regardless of insertion order.
+* @param {Token} tok1
+* @param {Token} tok2
+* @param {EncodeOptions} [options]
 * @returns {number}
 */
-encodeFloat$1.compareTokens = encodeUint$1.compareTokens;
+encodeFloat$1.compareTokens = function compareTokens(tok1, tok2, options) {
+	const b1 = majorSevenBytes(tok1, options);
+	const b2 = majorSevenBytes(tok2, options);
+	if (b1.length !== b2.length) return b1.length < b2.length ? -1 : 1;
+	return compare$1(b1, b2);
+};
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/jump.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/jump.js
 /**
 * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
 */
 /**
 * @param {Uint8Array} data
@@ -1500,7 +4054,7 @@ quick$1[245] = new Token$1(Type$1.true, true, 1);
 quick$1[246] = new Token$1(Type$1.null, null, 1);
 /**
 * @param {Token} token
-* @returns {Uint8Array|undefined}
+* @returns {AllocatedByteView|undefined}
 */
 function quickEncodeToken$1(token) {
 	switch (token.type) {
@@ -1514,39 +4068,21 @@ function quickEncodeToken$1(token) {
 			if (token.value === "") return fromArray$1([96]);
 			return;
 		case Type$1.array:
-			if (token.value === 0) return fromArray$1([128]);
-			/* c8 ignore next 2 */
-			return;
-		case Type$1.map:
-			if (token.value === 0) return fromArray$1([160]);
-			/* c8 ignore next 2 */
-			return;
-		case Type$1.uint:
-			if (token.value < 24) return fromArray$1([Number(token.value)]);
-			return;
-		case Type$1.negint: if (token.value >= -24) return fromArray$1([31 - Number(token.value)]);
-	}
-}
-//#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/encode.js
-/**
-* @typedef {import('../interface.js').EncodeOptions} EncodeOptions
-* @typedef {import('../interface.js').OptionalTypeEncoder} OptionalTypeEncoder
-* @typedef {import('../interface.js').Reference} Reference
-* @typedef {import('../interface.js').StrictTypeEncoder} StrictTypeEncoder
-* @typedef {import('../interface.js').TokenTypeEncoder} TokenTypeEncoder
-* @typedef {import('../interface.js').TokenOrNestedTokens} TokenOrNestedTokens
-* @typedef {import('../interface.js').ByteWriter} ByteWriter
-*/
-/** @type {EncodeOptions} */
-const defaultEncodeOptions$2 = {
-	float64: false,
-	mapSorter: mapSorter$2,
-	quickEncodeToken: quickEncodeToken$1
-};
+			if (token.value === 0) return fromArray$1([128]);
+			return;
+		case Type$1.map:
+			if (token.value === 0) return fromArray$1([160]);
+			return;
+		case Type$1.uint:
+			if (token.value < 24) return fromArray$1([Number(token.value)]);
+			return;
+		case Type$1.negint: if (token.value >= -24) return fromArray$1([31 - Number(token.value)]);
+	}
+}
+//#endregion
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/encode.js
 /** @type {EncodeOptions} */
 const rfc8949EncodeOptions$1 = Object.freeze({
-	float64: true,
 	mapSorter: rfc8949MapSorter$1,
 	quickEncodeToken: quickEncodeToken$1
 });
@@ -1800,25 +4336,11 @@ function objectToTokens$1(obj, options = {}, refStack) {
 * @param {EncodeOptions} options
 */
 function sortMapEntries$1(entries, options) {
-	if (options.mapSorter) entries.sort(options.mapSorter);
-}
-/**
-* @param {(Token|Token[])[]} e1
-* @param {(Token|Token[])[]} e2
-* @returns {number}
-*/
-function mapSorter$2(e1, e2) {
-	/* c8 ignore next 2 */
-	const keyToken1 = Array.isArray(e1[0]) ? e1[0][0] : e1[0];
-	const keyToken2 = Array.isArray(e2[0]) ? e2[0][0] : e2[0];
-	if (keyToken1.type !== keyToken2.type) return keyToken1.type.compare(keyToken2.type);
-	const tcmp = cborEncoders$1[keyToken1.type.major].compareTokens(keyToken1, keyToken2);
-	/* c8 ignore next 5 */
-	if (tcmp === 0) console.warn("WARNING: complex key types used, CBOR key sorting guarantees are gone");
-	return tcmp;
+	const mapSorter = options.mapSorter;
+	if (mapSorter) entries.sort((e1, e2) => mapSorter(e1, e2, options));
 }
 /**
-* @typedef {Token & { _keyBytes?: Uint8Array }} TokenEx
+* @typedef {Token & { _keyBytes?: AllocatedByteView }} TokenEx
 *
 * @param {(Token|Token[])[]} e1
 * @param {(Token|Token[])[]} e2
@@ -1836,7 +4358,7 @@ function rfc8949MapSorter$1(e1, e2) {
 }
 /**
 * @param {any} data
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 function encodeRfc8949$1(data) {
 	return encodeCustom$1(data, cborEncoders$1, rfc8949EncodeOptions$1);
@@ -1851,99 +4373,38 @@ function tokensToEncoded$1(writer, tokens, encoders, options) {
 	if (Array.isArray(tokens)) for (const token of tokens) tokensToEncoded$1(writer, token, encoders, options);
 	else encoders[tokens.type.major](writer, tokens, options);
 }
-const MAJOR_UINT$1 = Type$1.uint.majorEncoded;
-const MAJOR_NEGINT$1 = Type$1.negint.majorEncoded;
-const MAJOR_BYTES$1 = Type$1.bytes.majorEncoded;
-const MAJOR_STRING$1 = Type$1.string.majorEncoded;
-const MAJOR_ARRAY$1 = Type$1.array.majorEncoded;
-const SIMPLE_FALSE$1 = Type$1.float.majorEncoded | 20;
-const SIMPLE_TRUE$1 = Type$1.float.majorEncoded | 21;
-const SIMPLE_NULL$1 = Type$1.float.majorEncoded | 22;
-const SIMPLE_UNDEFINED$1 = Type$1.float.majorEncoded | 23;
-const neg1b$2 = BigInt(-1);
-const pos1b$2 = BigInt(1);
-/**
-* Check if direct encoding can be used for the given options.
-* Direct encoding bypasses token creation for most values.
+Type$1.uint.majorEncoded;
+Type$1.negint.majorEncoded;
+Type$1.bytes.majorEncoded;
+Type$1.string.majorEncoded;
+Type$1.array.majorEncoded;
+Type$1.map.majorEncoded;
+Type$1.float.majorEncoded | 20;
+Type$1.float.majorEncoded | 21;
+Type$1.float.majorEncoded | 22;
+Type$1.float.majorEncoded | 23;
+/**
+* @template {ArrayBufferLike} T
+* @overload
+* @param {any} data
+* @param {TokenTypeEncoder[]} encoders
 * @param {EncodeOptions} options
-* @returns {boolean}
+* @param {Uint8Array<T>} destination
+* @returns {Uint8Array<T>}
 */
-function canDirectEncode$1(options) {
-	return options.addBreakTokens !== true;
-}
 /**
-* Direct encode a value to the writer, bypassing token creation for most types.
-* Falls back to token-based encoding for custom type encoders.
-* @param {ByteWriter} writer
+* @overload
 * @param {any} data
+* @param {TokenTypeEncoder[]} encoders
 * @param {EncodeOptions} options
-* @param {Reference|undefined} refStack
+* @returns {AllocatedByteView}
 */
-function directEncode$1(writer, data, options, refStack) {
-	const typ = is$1(data);
-	const customEncoder = options.typeEncoders && options.typeEncoders[typ];
-	if (customEncoder) {
-		const tokens = customEncoder(data, typ, options, refStack);
-		if (tokens != null) {
-			tokensToEncoded$1(writer, tokens, cborEncoders$1, options);
-			return;
-		}
-	}
-	switch (typ) {
-		case "null":
-			writer.push([SIMPLE_NULL$1]);
-			return;
-		case "undefined":
-			writer.push([SIMPLE_UNDEFINED$1]);
-			return;
-		case "boolean":
-			writer.push([data ? SIMPLE_TRUE$1 : SIMPLE_FALSE$1]);
-			return;
-		case "number":
-			if (!Number.isInteger(data) || !Number.isSafeInteger(data)) encodeFloat$1(writer, new Token$1(Type$1.float, data), options);
-			else if (data >= 0) encodeUintValue$1(writer, MAJOR_UINT$1, data);
-			else encodeUintValue$1(writer, MAJOR_NEGINT$1, data * -1 - 1);
-			return;
-		case "bigint":
-			if (data >= BigInt(0)) encodeUintValue$1(writer, MAJOR_UINT$1, data);
-			else encodeUintValue$1(writer, MAJOR_NEGINT$1, data * neg1b$2 - pos1b$2);
-			return;
-		case "string": {
-			const bytes = fromString$2(data);
-			encodeUintValue$1(writer, MAJOR_STRING$1, bytes.length);
-			writer.push(bytes);
-			return;
-		}
-		case "Uint8Array":
-			encodeUintValue$1(writer, MAJOR_BYTES$1, data.length);
-			writer.push(data);
-			return;
-		case "Array":
-			if (!data.length) {
-				writer.push([MAJOR_ARRAY$1]);
-				return;
-			}
-			refStack = Ref$1.createCheck(refStack, data);
-			encodeUintValue$1(writer, MAJOR_ARRAY$1, data.length);
-			for (const elem of data) directEncode$1(writer, elem, options, refStack);
-			return;
-		case "Object":
-		case "Map":
-			tokensToEncoded$1(writer, typeEncoders$1.Object(data, typ, options, refStack), cborEncoders$1, options);
-			return;
-		default: {
-			const typeEncoder = typeEncoders$1[typ];
-			if (!typeEncoder) throw new Error(`${encodeErrPrefix$1} unsupported type: ${typ}`);
-			tokensToEncoded$1(writer, typeEncoder(data, typ, options, refStack), cborEncoders$1, options);
-		}
-	}
-}
 /**
 * @param {any} data
 * @param {TokenTypeEncoder[]} encoders
 * @param {EncodeOptions} options
-* @param {Uint8Array} [destination]
-* @returns {Uint8Array}
+* @param {ByteView} [destination]
+* @returns {ByteView}
 */
 function encodeCustom$1(data, encoders, options, destination) {
 	const hasDest = destination instanceof Uint8Array;
@@ -1963,7 +4424,6 @@ function encodeCustom$1(data, encoders, options, destination) {
 			const size = encoder.encodedSize(tokens, options);
 			if (!hasDest) writeTo = new Bl$1(size);
 			encoder(writeTo, tokens, options);
-			/* c8 ignore next 4 */
 			if (writeTo.chunks.length !== 1) throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
 			return hasDest ? writeTo.toBytes() : asU8A$1(writeTo.chunks[0]);
 		}
@@ -1972,22 +4432,8 @@ function encodeCustom$1(data, encoders, options, destination) {
 	tokensToEncoded$1(writeTo, tokens, encoders, options);
 	return writeTo.toBytes(true);
 }
-/**
-* @param {any} data
-* @param {EncodeOptions} [options]
-* @returns {Uint8Array}
-*/
-function encode$8(data, options) {
-	options = Object.assign({}, defaultEncodeOptions$2, options);
-	if (canDirectEncode$1(options)) {
-		defaultWriter$1.reset();
-		directEncode$1(defaultWriter$1, data, options, void 0);
-		return defaultWriter$1.toBytes(true);
-	}
-	return encodeCustom$1(data, cborEncoders$1, options);
-}
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/decode.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/decode.js
 /**
 * @typedef {import('./token.js').Token} Token
 * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
@@ -2024,7 +4470,6 @@ var Tokeniser$1 = class {
 		let token = quick$1[byt];
 		if (token === void 0) {
 			const decoder = jump$1[byt];
-			/* c8 ignore next 4 */
 			if (!decoder) throw new Error(`${decodeErrPrefix$1} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, "0")})`);
 			const minor = byt & 31;
 			token = decoder(this.data, this._pos, minor, this.options);
@@ -2039,7 +4484,7 @@ const BREAK$1 = Symbol.for("BREAK");
 * @param {Token} token
 * @param {DecodeTokenizer} tokeniser
 * @param {DecodeOptions} options
-* @returns {any|BREAK|DONE}
+* @returns {any|typeof BREAK|typeof DONE}
 */
 function tokenToArray$1(token, tokeniser, options) {
 	const arr = [];
@@ -2058,7 +4503,7 @@ function tokenToArray$1(token, tokeniser, options) {
 * @param {Token} token
 * @param {DecodeTokenizer} tokeniser
 * @param {DecodeOptions} options
-* @returns {any|BREAK|DONE}
+* @returns {any|typeof BREAK|typeof DONE}
 */
 function tokenToMap$1(token, tokeniser, options) {
 	const useMaps = options.useMaps === true;
@@ -2111,39 +4556,31 @@ function* tokenToMapEntries$1(token, tokeniser, options) {
 * @returns {TagDecodeControl}
 */
 function createTagDecodeControl$1(tokeniser, options) {
-	let called = false;
-	/**
-	* @type {TagDecodeControl}
-	*/
+	/** @type {TagDecodeControl & {_called: boolean}} */
 	const decode = function() {
-		if (called) throw new Error(`${decodeErrPrefix$1} tag decode() may only be called once`);
-		called = true;
+		if (decode._called) throw new Error(`${decodeErrPrefix$1} tag decode() may only be called once`);
+		decode._called = true;
 		const value = tokensToObject$1(tokeniser, options);
 		if (value === DONE$1) throw new Error(`${decodeErrPrefix$1} tag content missing`);
 		if (value === BREAK$1) throw new Error(`${decodeErrPrefix$1} got unexpected break in tag content`);
 		return value;
 	};
 	decode.entries = function() {
-		if (called) throw new Error(`${decodeErrPrefix$1} tag decode() may only be called once`);
-		called = true;
+		if (decode._called) throw new Error(`${decodeErrPrefix$1} tag decode() may only be called once`);
+		decode._called = true;
 		const token = tokeniser.next();
 		if (!Type$1.equals(token.type, Type$1.map)) throw new Error(`${decodeErrPrefix$1} entries() requires map content, got ${token.type.name}`);
 		const entries = [];
 		for (const entry of tokenToMapEntries$1(token, tokeniser, options)) entries.push(entry);
 		return entries;
 	};
-	Object.defineProperty(decode, "_called", {
-		get() {
-			return called;
-		},
-		enumerable: false
-	});
+	decode._called = false;
 	return decode;
 }
 /**
 * @param {DecodeTokenizer} tokeniser
 * @param {DecodeOptions} options
-* @returns {any|BREAK|DONE}
+* @returns {any|typeof BREAK|typeof DONE}
 */
 function tokensToObject$1(tokeniser, options) {
 	if (tokeniser.done()) return DONE$1;
@@ -2161,7 +4598,6 @@ function tokensToObject$1(tokeniser, options) {
 		}
 		throw new Error(`${decodeErrPrefix$1} tag not supported (${token.value})`);
 	}
-	/* c8 ignore next */
 	throw new Error("unsupported");
 }
 /**
@@ -2184,7 +4620,7 @@ function decodeFirst$1(data, options) {
 * @param {DecodeOptions} [options]
 * @returns {any}
 */
-function decode$8(data, options) {
+function decode$7(data, options) {
 	const [decoded, remainder] = decodeFirst$1(data, options);
 	if (remainder.length > 0) throw new Error(`${decodeErrPrefix$1} too many terminals, data makes no sense`);
 	return decoded;
@@ -2235,137 +4671,11 @@ Object.defineProperty(class Tagged$1 {
 	}
 }.prototype, Symbol.toStringTag, { value: "Tagged" });
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/@ipld/dag-cbor/src/index.js
-var src_exports$1 = /* @__PURE__ */ __exportAll({
-	code: () => 113,
-	decode: () => decode$7,
-	decodeOptions: () => decodeOptions$2,
-	encode: () => encode$7,
-	encodeOptions: () => encodeOptions$2,
-	name: () => name$2,
-	toByteView: () => toByteView$2
-});
-const CID_CBOR_TAG$1 = 42;
-/**
-* @template T
-* @typedef {import('multiformats/codecs/interface').ByteView<T>} ByteView
-*/
-/**
-* @template T
-* @typedef {import('multiformats/codecs/interface').ArrayBufferView<T>} ArrayBufferView
-*/
-/**
-* @template T
-* @param {ByteView<T> | ArrayBufferView<T>} buf
-* @returns {ByteView<T>}
-*/
-function toByteView$2(buf) {
-	if (buf instanceof ArrayBuffer) return new Uint8Array(buf, 0, buf.byteLength);
-	return buf;
-}
-/**
-* cidEncoder will receive all Objects during encode, it needs to filter out
-* anything that's not a CID and return `null` for that so it's encoded as
-* normal.
-*
-* @param {any} obj
-* @returns {cborg.Token[]|null}
-*/
-function cidEncoder$2(obj) {
-	if (obj.asCID !== obj && obj["/"] !== obj.bytes) return null;
-	const cid = CID.asCID(obj);
-	/* c8 ignore next 4 */
-	if (!cid) return null;
-	const bytes = new Uint8Array(cid.bytes.byteLength + 1);
-	bytes.set(cid.bytes, 1);
-	return [new Token$1(Type$1.tag, CID_CBOR_TAG$1), new Token$1(Type$1.bytes, bytes)];
-}
-/**
-* Intercept all `undefined` values from an object walk and reject the entire
-* object if we find one.
-*
-* @returns {null}
-*/
-function undefinedEncoder$2() {
-	throw new Error("`undefined` is not supported by the IPLD Data Model and cannot be encoded");
-}
-/**
-* Intercept all `number` values from an object walk and reject the entire
-* object if we find something that doesn't fit the IPLD data model (NaN &
-* Infinity).
-*
-* @param {number} num
-* @returns {null}
-*/
-function numberEncoder$2(num) {
-	if (Number.isNaN(num)) throw new Error("`NaN` is not supported by the IPLD Data Model and cannot be encoded");
-	if (num === Infinity || num === -Infinity) throw new Error("`Infinity` and `-Infinity` is not supported by the IPLD Data Model and cannot be encoded");
-	return null;
-}
-/**
-* @param {Map<any, any>} map
-* @returns {null}
-*/
-function mapEncoder$1(map) {
-	for (const key of map.keys()) if (typeof key !== "string" || key.length === 0) throw new Error("Non-string Map keys are not supported by the IPLD Data Model and cannot be encoded");
-	return null;
-}
-const _encodeOptions$1 = {
-	float64: true,
-	typeEncoders: {
-		Map: mapEncoder$1,
-		Object: cidEncoder$2,
-		undefined: undefinedEncoder$2,
-		number: numberEncoder$2
-	}
-};
-const encodeOptions$2 = {
-	..._encodeOptions$1,
-	typeEncoders: { ..._encodeOptions$1.typeEncoders }
-};
-/**
-* @param {import('cborg').TagDecodeControl} decode
-* @returns {CID}
-*/
-function cidDecoder$1(decode) {
-	const bytes = decode();
-	if (bytes[0] !== 0) throw new Error("Invalid CID for CBOR tag 42; expected leading 0x00");
-	return CID.decode(bytes.subarray(1));
-}
-const _decodeOptions$1 = {
-	allowIndefinite: false,
-	coerceUndefinedToNull: true,
-	allowNaN: false,
-	allowInfinity: false,
-	allowBigInt: true,
-	strict: true,
-	useMaps: false,
-	rejectDuplicateMapKeys: true,
-	/** @type {{ [tagNumber: number]: import('cborg').TagDecoder }} */
-	tags: { [CID_CBOR_TAG$1]: cidDecoder$1 }
-};
-const decodeOptions$2 = {
-	..._decodeOptions$1,
-	tags: { ..._decodeOptions$1.tags }
-};
-const name$2 = "dag-cbor";
-/**
-* @template T
-* @param {T} node
-* @returns {ByteView<T>}
-*/
-const encode$7 = (node) => encode$8(node, _encodeOptions$1);
-/**
-* @template T
-* @param {ByteView<T> | ArrayBufferView<T>} data
-* @returns {T}
-*/
-const decode$7 = (data) => decode$8(toByteView$2(data), _decodeOptions$1);
-//#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/json/encode.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/json/encode.js
 /**
 * @typedef {import('../../interface.js').EncodeOptions} EncodeOptions
 * @typedef {import('../../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../../interface.js').AllocatedByteView} AllocatedByteView
 * @typedef {import('../token.js').Token} Token
 */
 var JSONEncoder = class extends Array {
@@ -2467,7 +4777,6 @@ var JSONEncoder = class extends Array {
 				else throw new Error("Unexpected recursive type; this should not happen!");
 				return;
 			}
-			/* c8 ignore next 2 */
 			throw new Error("Unexpected break; this should not happen!");
 		}
 		if (token.value === void 0) throw new Error(`${encodeErrPrefix$1} unsupported type: undefined`);
@@ -2524,7 +4833,6 @@ function mapSorter$1(e1, e2) {
 	if (keyToken1.type !== Type$1.string || keyToken2.type !== Type$1.string) throw new Error(`${encodeErrPrefix$1} non-string map keys are not supported`);
 	if (keyToken1 < keyToken2) return -1;
 	if (keyToken1 > keyToken2) return 1;
-	/* c8 ignore next 1 */
 	throw new Error(`${encodeErrPrefix$1} unexpected duplicate map keys, this is not supported`);
 }
 const defaultEncodeOptions$1 = {
@@ -2534,14 +4842,14 @@ const defaultEncodeOptions$1 = {
 /**
 * @param {any} data
 * @param {EncodeOptions} [options]
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 function encode$6(data, options) {
 	options = Object.assign({}, defaultEncodeOptions$1, options);
 	return encodeCustom$1(data, new JSONEncoder(), options);
 }
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/cborg/lib/json/decode.js
+//#region node_modules/@ipld/dag-json/node_modules/cborg/lib/json/decode.js
 /**
 * @typedef {import('../../interface.js').DecodeOptions} DecodeOptions
 * @typedef {import('../../interface.js').DecodeTokenizer} DecodeTokenizer
@@ -2676,7 +4984,6 @@ var Tokenizer = class {
 	* @returns {Token}
 	*/
 	parseString() {
-		/* c8 ignore next 4 */
 		if (this.ch() !== 34) throw new Error(`${decodeErrPrefix$1} unexpected character at position ${this._pos}; this shouldn't happen`);
 		this._pos++;
 		for (let i = this._pos, l = 0; i < this.data.length && l < 65536; i++, l++) {
@@ -2707,12 +5014,10 @@ var Tokenizer = class {
 		const readUtf8Char = () => {
 			const firstByte = this.ch();
 			let codePoint = null;
-			/* c8 ignore next 1 */
 			let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
 			if (this._pos + bytesPerSequence > this.data.length) throw new Error(`${decodeErrPrefix$1} unexpected unicode sequence at position ${this._pos}`);
 			let secondByte, thirdByte, fourthByte, tempCodePoint;
 			switch (bytesPerSequence) {
-				/* c8 ignore next 6 */
 				case 1:
 					if (firstByte < 128) codePoint = firstByte;
 					break;
@@ -2728,7 +5033,6 @@ var Tokenizer = class {
 					thirdByte = this.data[this._pos + 2];
 					if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
 						tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
-						/* c8 ignore next 3 */
 						if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) codePoint = tempCodePoint;
 					}
 					break;
@@ -2741,7 +5045,6 @@ var Tokenizer = class {
 						if (tempCodePoint > 65535 && tempCodePoint < 1114112) codePoint = tempCodePoint;
 					}
 			}
-			/* c8 ignore next 5 */
 			if (codePoint === null) {
 				codePoint = 65533;
 				bytesPerSequence = 1;
@@ -2915,7 +5218,6 @@ var Tokenizer = class {
 				this.modeStack.push("obj-key");
 				this.skipWhitespace();
 				return this.parseValue();
-			/* c8 ignore next 2 */
 			default: throw new Error(`${decodeErrPrefix$1} unexpected parse state at position ${this._pos}; this shouldn't happen`);
 		}
 	}
@@ -2927,10 +5229,10 @@ var Tokenizer = class {
 */
 function decode$6(data, options) {
 	options = Object.assign({ tokenizer: new Tokenizer(data, options) }, options);
-	return decode$8(data, options);
+	return decode$7(data, options);
 }
 //#endregion
-//#region node_modules/kubo-rpc-client/node_modules/@ipld/dag-json/src/index.js
+//#region node_modules/@ipld/dag-json/src/index.js
 var src_exports = /* @__PURE__ */ __exportAll({
 	code: () => 297,
 	decode: () => decode$5,
@@ -3335,14 +5637,12 @@ function is(value) {
 	if (value === true || value === false) return "boolean";
 	const typeOf = typeof value;
 	if (typeOf === "string" || typeOf === "number" || typeOf === "bigint" || typeOf === "symbol") return typeOf;
-	/* c8 ignore next 3 */
 	if (typeOf === "function") return "Function";
 	if (Array.isArray(value)) return "Array";
 	if (value instanceof Uint8Array) return "Uint8Array";
 	if (value.constructor === Object) return "Object";
 	const objectType = getObjectType(value);
 	if (objectType) return objectType;
-	/* c8 ignore next */
 	return "Object";
 }
 /**
@@ -3367,7 +5667,6 @@ var Type = class {
 		this.name = name;
 		this.terminal = terminal;
 	}
-	/* c8 ignore next 3 */
 	toString() {
 		return `Type[${this.major}].${this.name}`;
 	}
@@ -3376,7 +5675,6 @@ var Type = class {
 	* @returns {number}
 	*/
 	compare(typ) {
-		/* c8 ignore next 1 */
 		return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
 	}
 	/**
@@ -3419,7 +5717,6 @@ var Token = class {
 		/** @type {Uint8Array|undefined} */
 		this.byteValue = void 0;
 	}
-	/* c8 ignore next 3 */
 	toString() {
 		return `Token[${this.type}].${this.value}`;
 	}
@@ -3429,6 +5726,10 @@ var Token = class {
 const useBuffer = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === "function";
 const textEncoder = new TextEncoder();
 /**
+* @typedef {import('../interface.js').ByteView} ByteView
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
+*/
+/**
 * @param {Uint8Array} buf
 * @returns {boolean}
 */
@@ -3436,11 +5737,10 @@ function isBuffer(buf) {
 	return useBuffer && globalThis.Buffer.isBuffer(buf);
 }
 /**
-* @param {Uint8Array|number[]} buf
-* @returns {Uint8Array}
+* @param {ByteView|number[]} buf
+* @returns {ByteView}
 */
 function asU8A(buf) {
-	/* c8 ignore next */
 	if (!(buf instanceof Uint8Array)) return Uint8Array.from(buf);
 	return isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf;
 }
@@ -3458,7 +5758,7 @@ const fromString$1 = useBuffer ? (string) => {
 /**
 * Buffer variant not fast enough for what we need
 * @param {number[]} arr
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 const fromArray = (arr) => {
 	return Uint8Array.from(arr);
@@ -3476,14 +5776,13 @@ const slice = useBuffer ? (bytes, start, end) => {
 	return bytes.slice(start, end);
 };
 const concat = useBuffer ? (chunks, length) => {
-	/* c8 ignore next 1 */
 	chunks = chunks.map((c) => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
 	return asU8A(globalThis.Buffer.concat(chunks, length));
 } : 
 /**
-* @param {Uint8Array[]} chunks
+* @param {ByteView[]} chunks
 * @param {number} length
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 (chunks, length) => {
 	const out = new Uint8Array(length);
@@ -3500,7 +5799,7 @@ const alloc = useBuffer ? (size) => {
 } : 
 /**
 * @param {number} size
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 (size) => {
 	return new Uint8Array(size);
@@ -3511,7 +5810,6 @@ const alloc = useBuffer ? (size) => {
 * @returns {number}
 */
 function compare(b1, b2) {
-	/* c8 ignore next 5 */
 	if (isBuffer(b1) && isBuffer(b2)) return b1.compare(b2);
 	for (let i = 0; i < b1.length; i++) {
 		if (b1[i] === b2[i]) continue;
@@ -3565,6 +5863,10 @@ function utf8ToBytes(str) {
 * will be `0` to write at the current cursor position but it can be ahead of
 * the current cursor. Negative offsets probably work but are untested.
 */
+/**
+* @typedef {import('../interface.js').ByteView} ByteView
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
+*/
 const defaultChunkSize = 256;
 var Bl = class {
 	/**
@@ -3576,9 +5878,9 @@ var Bl = class {
 		this.cursor = 0;
 		/** @type {number} */
 		this.maxCursor = -1;
-		/** @type {(Uint8Array|number[])[]} */
+		/** @type {(ByteView|number[])[]} */
 		this.chunks = [];
-		/** @type {Uint8Array|number[]|null} */
+		/** @type {ByteView|number[]|null} */
 		this._initReuseChunk = null;
 	}
 	reset() {
@@ -3591,7 +5893,7 @@ var Bl = class {
 		}
 	}
 	/**
-	* @param {Uint8Array|number[]} bytes
+	* @param {ByteView|number[]} bytes
 	*/
 	push(bytes) {
 		let topChunk = this.chunks[this.chunks.length - 1];
@@ -3621,14 +5923,13 @@ var Bl = class {
 	}
 	/**
 	* @param {boolean} [reset]
-	* @returns {Uint8Array}
+	* @returns {AllocatedByteView}
 	*/
 	toBytes(reset = false) {
 		let byts;
 		if (this.chunks.length === 1) {
 			const chunk = this.chunks[0];
 			if (reset && this.cursor > chunk.length / 2) {
-				/* c8 ignore next 2 */
 				byts = this.cursor === chunk.length ? chunk : chunk.subarray(0, this.cursor);
 				this._initReuseChunk = null;
 				this.chunks = [];
@@ -3641,23 +5942,24 @@ var Bl = class {
 /**
 * U8Bl is a buffer list that writes directly to a user-provided Uint8Array.
 * It provides the same interface as Bl but writes to a fixed destination.
+* @template {ArrayBufferLike} T
 */
 var U8Bl = class {
 	/**
-	* @param {Uint8Array} dest
+	* @param {Uint8Array<T>} dest
 	*/
 	constructor(dest) {
 		this.dest = dest;
 		/** @type {number} */
 		this.cursor = 0;
-		/** @type {Uint8Array[]} */
+		/** @type {Array<Uint8Array<T>>} */
 		this.chunks = [dest];
 	}
 	reset() {
 		this.cursor = 0;
 	}
 	/**
-	* @param {Uint8Array|number[]} bytes
+	* @param {ByteView|number[]} bytes
 	*/
 	push(bytes) {
 		if (this.cursor + bytes.length > this.dest.length) throw new Error("write out of bounds, destination buffer is too small");
@@ -3666,7 +5968,7 @@ var U8Bl = class {
 	}
 	/**
 	* @param {boolean} [reset]
-	* @returns {Uint8Array}
+	* @returns {Uint8Array<T>}
 	*/
 	toBytes(reset = false) {
 		const byts = this.dest.subarray(0, this.cursor);
@@ -3889,7 +6191,7 @@ encodeUintValue.encodedSize = function encodedSize(uint) {
 * @returns {number}
 */
 encodeUint.compareTokens = function compareTokens(tok1, tok2) {
-	return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 	/* c8 ignore next */ 0;
+	return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 0;
 };
 //#endregion
 //#region node_modules/@ipld/dag-cbor/node_modules/cborg/lib/1negint.js
@@ -3961,7 +6263,6 @@ function encodeNegint(writer, token) {
 encodeNegint.encodedSize = function encodedSize(token) {
 	const negint = token.value;
 	const unsigned = typeof negint === "bigint" ? negint * neg1b$1 - pos1b$1 : negint * -1 - 1;
-	/* c8 ignore next 4 */
 	if (unsigned < uintBoundaries[0]) return 1;
 	if (unsigned < uintBoundaries[1]) return 2;
 	if (unsigned < uintBoundaries[2]) return 3;
@@ -3974,7 +6275,7 @@ encodeNegint.encodedSize = function encodedSize(token) {
 * @returns {number}
 */
 encodeNegint.compareTokens = function compareTokens(tok1, tok2) {
-	return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : 	/* c8 ignore next */ 0;
+	return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : 0;
 };
 //#endregion
 //#region node_modules/@ipld/dag-cbor/node_modules/cborg/lib/2bytes.js
@@ -4582,12 +6883,10 @@ function encodeFloat16(inp) {
 		const valu32 = dataView.getUint32(0);
 		const exponent = (valu32 & 2139095040) >> 23;
 		const mantissa = valu32 & 8388607;
-		/* c8 ignore next 6 */
 		if (exponent === 255) dataView.setUint16(0, 31744, false);
 		else if (exponent === 0) dataView.setUint16(0, (valu32 & 2147483648) >> 16 | mantissa >> 13, false);
 		else {
 			const logicalExponent = exponent - 127;
-			/* c8 ignore next 6 */
 			if (logicalExponent < -24) dataView.setUint16(0, 0);
 			else if (logicalExponent < -14) dataView.setUint16(0, (valu32 & 2147483648) >> 16 | 1 << 24 + logicalExponent, false);
 			else dataView.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
@@ -4655,6 +6954,7 @@ encodeFloat.compareTokens = encodeUint.compareTokens;
 //#region node_modules/@ipld/dag-cbor/node_modules/cborg/lib/jump.js
 /**
 * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
 */
 /**
 * @param {Uint8Array} data
@@ -4764,7 +7064,7 @@ quick[245] = new Token(Type.true, true, 1);
 quick[246] = new Token(Type.null, null, 1);
 /**
 * @param {Token} token
-* @returns {Uint8Array|undefined}
+* @returns {AllocatedByteView|undefined}
 */
 function quickEncodeToken(token) {
 	switch (token.type) {
@@ -4779,11 +7079,9 @@ function quickEncodeToken(token) {
 			return;
 		case Type.array:
 			if (token.value === 0) return fromArray([128]);
-			/* c8 ignore next 2 */
 			return;
 		case Type.map:
 			if (token.value === 0) return fromArray([160]);
-			/* c8 ignore next 2 */
 			return;
 		case Type.uint:
 			if (token.value < 24) return fromArray([Number(token.value)]);
@@ -4801,6 +7099,8 @@ function quickEncodeToken(token) {
 * @typedef {import('../interface.js').TokenTypeEncoder} TokenTypeEncoder
 * @typedef {import('../interface.js').TokenOrNestedTokens} TokenOrNestedTokens
 * @typedef {import('../interface.js').ByteWriter} ByteWriter
+* @typedef {import('../interface.js').ByteView} ByteView
+* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
 */
 /** @type {EncodeOptions} */
 const defaultEncodeOptions = {
@@ -4810,7 +7110,6 @@ const defaultEncodeOptions = {
 };
 /** @type {EncodeOptions} */
 const rfc8949EncodeOptions = Object.freeze({
-	float64: true,
 	mapSorter: rfc8949MapSorter,
 	quickEncodeToken
 });
@@ -5072,17 +7371,15 @@ function sortMapEntries(entries, options) {
 * @returns {number}
 */
 function mapSorter(e1, e2) {
-	/* c8 ignore next 2 */
 	const keyToken1 = Array.isArray(e1[0]) ? e1[0][0] : e1[0];
 	const keyToken2 = Array.isArray(e2[0]) ? e2[0][0] : e2[0];
 	if (keyToken1.type !== keyToken2.type) return keyToken1.type.compare(keyToken2.type);
 	const tcmp = cborEncoders[keyToken1.type.major].compareTokens(keyToken1, keyToken2);
-	/* c8 ignore next 5 */
 	if (tcmp === 0) console.warn("WARNING: complex key types used, CBOR key sorting guarantees are gone");
 	return tcmp;
 }
 /**
-* @typedef {Token & { _keyBytes?: Uint8Array }} TokenEx
+* @typedef {Token & { _keyBytes?: AllocatedByteView }} TokenEx
 *
 * @param {(Token|Token[])[]} e1
 * @param {(Token|Token[])[]} e2
@@ -5100,7 +7397,7 @@ function rfc8949MapSorter(e1, e2) {
 }
 /**
 * @param {any} data
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 function encodeRfc8949(data) {
 	return encodeCustom(data, cborEncoders, rfc8949EncodeOptions);
@@ -5203,11 +7500,27 @@ function directEncode(writer, data, options, refStack) {
 	}
 }
 /**
+* @template {ArrayBufferLike} T
+* @overload
 * @param {any} data
 * @param {TokenTypeEncoder[]} encoders
 * @param {EncodeOptions} options
-* @param {Uint8Array} [destination]
-* @returns {Uint8Array}
+* @param {Uint8Array<T>} destination
+* @returns {Uint8Array<T>}
+*/
+/**
+* @overload
+* @param {any} data
+* @param {TokenTypeEncoder[]} encoders
+* @param {EncodeOptions} options
+* @returns {AllocatedByteView}
+*/
+/**
+* @param {any} data
+* @param {TokenTypeEncoder[]} encoders
+* @param {EncodeOptions} options
+* @param {ByteView} [destination]
+* @returns {ByteView}
 */
 function encodeCustom(data, encoders, options, destination) {
 	const hasDest = destination instanceof Uint8Array;
@@ -5227,7 +7540,6 @@ function encodeCustom(data, encoders, options, destination) {
 			const size = encoder.encodedSize(tokens, options);
 			if (!hasDest) writeTo = new Bl(size);
 			encoder(writeTo, tokens, options);
-			/* c8 ignore next 4 */
 			if (writeTo.chunks.length !== 1) throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
 			return hasDest ? writeTo.toBytes() : asU8A(writeTo.chunks[0]);
 		}
@@ -5239,7 +7551,7 @@ function encodeCustom(data, encoders, options, destination) {
 /**
 * @param {any} data
 * @param {EncodeOptions} [options]
-* @returns {Uint8Array}
+* @returns {AllocatedByteView}
 */
 function encode$2(data, options) {
 	options = Object.assign({}, defaultEncodeOptions, options);
@@ -5288,7 +7600,6 @@ var Tokeniser = class {
 		let token = quick[byt];
 		if (token === void 0) {
 			const decoder = jump[byt];
-			/* c8 ignore next 4 */
 			if (!decoder) throw new Error(`${decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, "0")})`);
 			const minor = byt & 31;
 			token = decoder(this.data, this._pos, minor, this.options);
@@ -5303,7 +7614,7 @@ const BREAK = Symbol.for("BREAK");
 * @param {Token} token
 * @param {DecodeTokenizer} tokeniser
 * @param {DecodeOptions} options
-* @returns {any|BREAK|DONE}
+* @returns {any|typeof BREAK|typeof DONE}
 */
 function tokenToArray(token, tokeniser, options) {
 	const arr = [];
@@ -5322,7 +7633,7 @@ function tokenToArray(token, tokeniser, options) {
 * @param {Token} token
 * @param {DecodeTokenizer} tokeniser
 * @param {DecodeOptions} options
-* @returns {any|BREAK|DONE}
+* @returns {any|typeof BREAK|typeof DONE}
 */
 function tokenToMap(token, tokeniser, options) {
 	const useMaps = options.useMaps === true;
@@ -5407,7 +7718,7 @@ function createTagDecodeControl(tokeniser, options) {
 /**
 * @param {DecodeTokenizer} tokeniser
 * @param {DecodeOptions} options
-* @returns {any|BREAK|DONE}
+* @returns {any|typeof BREAK|typeof DONE}
 */
 function tokensToObject(tokeniser, options) {
 	if (tokeniser.done()) return DONE;
@@ -5425,7 +7736,6 @@ function tokensToObject(tokeniser, options) {
 		}
 		throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`);
 	}
-	/* c8 ignore next */
 	throw new Error("unsupported");
 }
 /**
@@ -5730,13 +8040,19 @@ let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzr
 const POOL_SIZE_MULTIPLIER = 128;
 let pool, poolOffset;
 function fillPool(bytes) {
-	if (!pool || pool.length < bytes) {
-		pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-		webcrypto.getRandomValues(pool);
-		poolOffset = 0;
-	} else if (poolOffset + bytes > pool.length) {
-		webcrypto.getRandomValues(pool);
-		poolOffset = 0;
+	if (bytes < 0) throw new RangeError("Wrong ID size");
+	try {
+		if (!pool || pool.length < bytes) {
+			pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+			webcrypto.getRandomValues(pool);
+			poolOffset = 0;
+		} else if (poolOffset + bytes > pool.length) {
+			webcrypto.getRandomValues(pool);
+			poolOffset = 0;
+		}
+	} catch (e) {
+		pool = void 0;
+		throw e;
 	}
 	poolOffset += bytes;
 }