@bgd-labs/toolbox 0.2.15 → 0.2.17

package/dist/index.mjs

@@ -7,7 +7,26 @@ import { createPatch, createTwoFilesPatch, diffChars } from "diff";
 import { format } from "prettier/standalone";
 import solidityPlugin from "prettier-plugin-solidity/standalone";
 import { execSync } from "node:child_process";
+import crypto from "crypto";
+import { Buffer as Buffer$1 } from "node:buffer";
 
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
 //#region src/math/binary.ts
 /**
 * In solidity it is a quite common practice to encode bit variables in bitmaps opposed to bool structs.
@@ -19453,7 +19472,6 @@ const alchemyNetworkMap = {
 	1868: "soneium-mainnet",
 	1946: "soneium-minato",
 	2020: "ronin-mainnet",
-	2021: "ronin-saigon",
 	2201: "stable-testnet",
 	2442: "polygonzkevm-cardona",
 	2523: "frax-sepolia",
@@ -19513,6 +19531,7 @@ const alchemyNetworkMap = {
 	81457: "blast-mainnet",
 	84532: "base-sepolia",
 	99999: "adi-testnet",
+	202601: "ronin-saigon",
 	421614: "arb-sepolia",
 	510525: "clankermon-mainnet",
 	534351: "scroll-sepolia",
@@ -19532,9 +19551,7 @@ const alchemyNetworkMap = {
 	351243127: "xmtp-ropsten",
 	666666666: "degen-mainnet",
 	728126428: "tron-mainnet",
-	994873017: "lumia-prism",
 	999999999: "zora-sepolia",
-	2030232745: "lumia-beam",
 	3448148188: "tron-testnet",
 	"null": "sui-testnet"
 };
@@ -19674,6 +19691,7 @@ const tenderlyNetworkMap = {
 	9745: "plasma",
 	9746: "plasma-testnet",
 	10143: "monad-testnet",
+	10200: "gnosis-chiado-testnet",
 	11069: "interval-testnet",
 	13371: "immutable",
 	13473: "immutable-testnet",
@@ -19761,7 +19779,6 @@ const tenderlyExplorerMap = {
 	1946: "soneium-minato",
 	1952: "xlayer-testnet",
 	2020: "ronin",
-	2021: "ronin-testnet",
 	2201: "stable-testnet",
 	2391: "tac-spb-testnet",
 	2523: "fraxtal-hoodi",
@@ -19780,6 +19797,7 @@ const tenderlyExplorerMap = {
 	9746: "plasma-testnet",
 	9990: "peaq-agung-testnet",
 	10143: "monad-testnet",
+	10200: "gnosis-chiado-testnet",
 	11011: "shape-sepolia",
 	11069: "interval-testnet",
 	13371: "immutable",
@@ -20845,6 +20863,10 @@ const blockscoutExplorers = {
 		api: "https://aiascan.com/api",
 		explorer: "https://aiascan.com"
 	},
+	1330: {
+		api: "https://onnscan.com/api",
+		explorer: "https://onnscan.com"
+	},
 	1338: {
 		api: "https://blockscout.atlantischain.network/api",
 		explorer: "https://blockscout.atlantischain.network/"
@@ -34258,7 +34280,6 @@ const hyperRPCSupportedNetworks = [
 	1328,
 	1329,
 	1750,
-	1776,
 	1868,
 	1923,
 	2741,
@@ -34312,6 +34333,7 @@ const hyperRPCSupportedNetworks = [
 	531050104,
 	1184075182,
 	1313161554,
+	1660990954,
 	16666e5
 ];
 
@@ -35249,6 +35271,7 @@ var types_default = {
 			"vp": [10],
 			"vp_by_strategy": [10],
 			"vp_state": [2],
+			"vp_value": [10],
 			"__typename": [2]
 		},
 		"Alias": {
@@ -35362,6 +35385,7 @@ var types_default = {
 			"proposalsCount": [3],
 			"votesCount": [3],
 			"lastVote": [3],
+			"vpValue": [10],
 			"__typename": [2]
 		},
 		"Option": {
@@ -36285,5 +36309,3256 @@ function diffFoundryStorageLayout(layoutBefore, layoutAfter) {
 }
 
 //#endregion
-export { Aip, ChainId, ChainList, EVENT_DB, HALF_RAY, HALF_WAD, HUMAN_READABLE_PAYLOAD_STATE, HUMAN_READABLE_PROPOSAL_STATE, IAToken_ABI, IAaveOracle_ABI, IAaveV3ConfigEngine_ABI, IAccessControl_ABI, IAggregatorInterface_ABI, ICLRatePriceCapAdapter_ABI, ICLSynchronicityPriceAdapterBaseToPeg_ABI, ICLSynchronicityPriceAdapterPegToBase_ABI, ICLSynchronicityPriceAdapter_ABI, ICollector_ABI, IDefaultInterestRateStrategyV2_ABI, IERC1967_ABI, IERC20Metadata_ABI, IERC20_ABI, IEmissionManager_ABI, IGovernance_ABI, IOwnable_ABI, IPausableUpgradeable_ABI, IPayloadsController_ABI, IPendlePriceCapAdapter_ABI, IPoolAddressesProvider_ABI, IPoolConfigurator_ABI, IPool_ABI, IPriceCapAdapterBase_ABI, IPriceCapAdapterStable_ABI, IReserveInterestRateStrategy_ABI, IRewardsController_ABI, ISafe_ABI, IStataTokenFactory_ABI, IStataTokenV2_ABI, IUmbrellaStakeToken_ABI, IUmbrella_ABI, IWithGuardian_ABI, IWrappedTokenGatewayV3_ABI, IncentivizedERC20_ABI, LTV_PRECISION, PayloadState, ProposalState, RAY, SECONDS_PER_YEAR, SelfdestructCheckState, SoltypeType, Umbrella_IRewardsController_ABI, Umbrella_IRewardsDistributor_ABI, VerificationStatus, WAD, WAD_RAY_RATIO, aaveAddressesProvider_IncentivesControllerSlot, addAssetPrice, addAssetSymbol, alchemyNetworkMap, alchemySupportedChainIds, assetIndexesToAsset, assetToBase, bitmapToIndexes, blockscoutExplorers, bytes32ToAddress, calculateAvailableBorrowsMarketReferenceCurrency, calculateCompoundedInterest, calculateHealthFactor, calculateHealthFactorFromBalances, calculateLinearInterest, chainlinkFeeds, checkForSelfdestruct, decodeReserveConfiguration, decodeReserveConfigurationV2, decodeUserConfiguration, diffCode, diffFoundryStorageLayout, enhanceLogs, enhanceStateDiff, erc1967_AdminSlot, erc1967_ImplementationSlot, etherscanExplorers, fetchImmutablePoolAddresses, fetchMutablePoolAddresses, fetchPoolAddresses, findAsset, flashbotsClientExtension, flashbotsOnFetchRequest, formatNumberString, foundry_format, foundry_getStandardJsonInput, foundry_getStorageLayout, genericIndexer, getAlchemyRPC, getBits, getBytesValue, getClient, getCompleteReserveConfiguration, getContractDeploymentBlock, getCurrentDebtBalance, getCurrentLiquidityBalance, getDynamicArraySlot, getExplicitRPC, getExplorer, getGovernance, getHyperRPC, getImplementationSlot, getLogsRecursive, getMarketReferenceCurrencyAndUsdBalance, getMdContractName, getNetworkEnv, getNonFinalizedPayloads, getNonFinalizedProposals, getNormalizedDebt, getNormalizedIncome, getObjectDiff, getPayloadStorageOverrides, getPayloadsController, getPublicRpc, getQuicknodeRpc, getRPCUrl, getReserveConfigurations, getReserveTokens, getSolidityStorageSlotAddress, getSolidityStorageSlotBytes, getSolidityStorageSlotUint, getSourceCode, getTenderlyRpc, getVerificationStatus, hyperRPCSupportedNetworks, isPayloadFinal, isProposalFinal, makePayloadExecutableOnTestClient, makeProposalExecutableOnTestClient, onMevHandler, parseBlockscoutStyleSourceCode, parseEtherscanStyleSourceCode, parseFrontmatterMd, parseLogs, prettifyNumber, priceUpdateDecoder, publicRPCs, quicknodeNetworkMap, rayDiv, rayMul, rayToWad, renderMarkdownStateDiffReport, renderTenderlyReport, routescanExplorers, selfDestructStatusToString, setBits, snapshotClient, tenderlyExplorerMap, tenderlyNetworkMap, tenderly_createVnet, tenderly_deleteVnet, tenderly_getVnet, tenderly_logsToAbiLogs, tenderly_pingExplorer, tenderly_sim, tenderly_simVnet, toAddressLink, toBinaryString, toTxLink, transformTenderlyStateDiff, validateAip, verificationStatusToString, wadDiv, wadToRay };
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bytes.js
+const empty = new Uint8Array(0);
+function equals$1(aa, bb) {
+	if (aa === bb) return true;
+	if (aa.byteLength !== bb.byteLength) return false;
+	for (let ii = 0; ii < aa.byteLength; ii++) if (aa[ii] !== bb[ii]) return false;
+	return true;
+}
+function coerce(o) {
+	if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") return o;
+	if (o instanceof ArrayBuffer) return new Uint8Array(o);
+	if (ArrayBuffer.isView(o)) return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+	throw new Error("Unknown type, must be binary type");
+}
+function fromString$1(str) {
+	return new TextEncoder().encode(str);
+}
+function toString(b) {
+	return new TextDecoder().decode(b);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/base-x.js
+/**
+* @param {string} ALPHABET
+* @param {any} name
+*/
+function base$1(ALPHABET, name) {
+	if (ALPHABET.length >= 255) throw new TypeError("Alphabet too long");
+	var BASE_MAP = new Uint8Array(256);
+	for (var j = 0; j < BASE_MAP.length; j++) BASE_MAP[j] = 255;
+	for (var i = 0; i < ALPHABET.length; i++) {
+		var x = ALPHABET.charAt(i);
+		var xc = x.charCodeAt(0);
+		if (BASE_MAP[xc] !== 255) throw new TypeError(x + " is ambiguous");
+		BASE_MAP[xc] = i;
+	}
+	var BASE = ALPHABET.length;
+	var LEADER = ALPHABET.charAt(0);
+	var FACTOR = Math.log(BASE) / Math.log(256);
+	var iFACTOR = Math.log(256) / Math.log(BASE);
+	/**
+	* @param {any[] | Iterable<number>} source
+	*/
+	function encode(source) {
+		if (source instanceof Uint8Array);
+		else if (ArrayBuffer.isView(source)) source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+		else if (Array.isArray(source)) source = Uint8Array.from(source);
+		if (!(source instanceof Uint8Array)) throw new TypeError("Expected Uint8Array");
+		if (source.length === 0) return "";
+		var zeroes = 0;
+		var length = 0;
+		var pbegin = 0;
+		var pend = source.length;
+		while (pbegin !== pend && source[pbegin] === 0) {
+			pbegin++;
+			zeroes++;
+		}
+		var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+		var b58 = new Uint8Array(size);
+		while (pbegin !== pend) {
+			var carry = source[pbegin];
+			var i = 0;
+			for (var it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+				carry += 256 * b58[it1] >>> 0;
+				b58[it1] = carry % BASE >>> 0;
+				carry = carry / BASE >>> 0;
+			}
+			if (carry !== 0) throw new Error("Non-zero carry");
+			length = i;
+			pbegin++;
+		}
+		var it2 = size - length;
+		while (it2 !== size && b58[it2] === 0) it2++;
+		var str = LEADER.repeat(zeroes);
+		for (; it2 < size; ++it2) str += ALPHABET.charAt(b58[it2]);
+		return str;
+	}
+	/**
+	* @param {string | string[]} source
+	*/
+	function decodeUnsafe(source) {
+		if (typeof source !== "string") throw new TypeError("Expected String");
+		if (source.length === 0) return new Uint8Array();
+		var psz = 0;
+		if (source[psz] === " ") return;
+		var zeroes = 0;
+		var length = 0;
+		while (source[psz] === LEADER) {
+			zeroes++;
+			psz++;
+		}
+		var size = (source.length - psz) * FACTOR + 1 >>> 0;
+		var b256 = new Uint8Array(size);
+		while (source[psz]) {
+			var carry = BASE_MAP[source.charCodeAt(psz)];
+			if (carry === 255) return;
+			var i = 0;
+			for (var it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+				carry += BASE * b256[it3] >>> 0;
+				b256[it3] = carry % 256 >>> 0;
+				carry = carry / 256 >>> 0;
+			}
+			if (carry !== 0) throw new Error("Non-zero carry");
+			length = i;
+			psz++;
+		}
+		if (source[psz] === " ") return;
+		var it4 = size - length;
+		while (it4 !== size && b256[it4] === 0) it4++;
+		var vch = new Uint8Array(zeroes + (size - it4));
+		var j = zeroes;
+		while (it4 !== size) vch[j++] = b256[it4++];
+		return vch;
+	}
+	/**
+	* @param {string | string[]} string
+	*/
+	function decode(string) {
+		var buffer = decodeUnsafe(string);
+		if (buffer) return buffer;
+		throw new Error(`Non-${name} character`);
+	}
+	return {
+		encode,
+		decodeUnsafe,
+		decode
+	};
+}
+var _brrp__multiformats_scope_baseX = base$1;
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base.js
+/**
+* Class represents both BaseEncoder and MultibaseEncoder meaning it
+* can be used to encode to multibase or base encode without multibase
+* prefix.
+*/
+var Encoder = class {
+	name;
+	prefix;
+	baseEncode;
+	constructor(name, prefix, baseEncode) {
+		this.name = name;
+		this.prefix = prefix;
+		this.baseEncode = baseEncode;
+	}
+	encode(bytes) {
+		if (bytes instanceof Uint8Array) return `${this.prefix}${this.baseEncode(bytes)}`;
+		else throw Error("Unknown type, must be binary type");
+	}
+};
+/**
+* Class represents both BaseDecoder and MultibaseDecoder so it could be used
+* to decode multibases (with matching prefix) or just base decode strings
+* with corresponding base encoding.
+*/
+var Decoder = class {
+	name;
+	prefix;
+	baseDecode;
+	prefixCodePoint;
+	constructor(name, prefix, baseDecode) {
+		this.name = name;
+		this.prefix = prefix;
+		const prefixCodePoint = prefix.codePointAt(0);
+		/* c8 ignore next 3 */
+		if (prefixCodePoint === void 0) throw new Error("Invalid prefix character");
+		this.prefixCodePoint = prefixCodePoint;
+		this.baseDecode = baseDecode;
+	}
+	decode(text) {
+		if (typeof text === "string") {
+			if (text.codePointAt(0) !== this.prefixCodePoint) throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+			return this.baseDecode(text.slice(this.prefix.length));
+		} else throw Error("Can only multibase decode strings");
+	}
+	or(decoder) {
+		return or(this, decoder);
+	}
+};
+var ComposedDecoder = class {
+	decoders;
+	constructor(decoders) {
+		this.decoders = decoders;
+	}
+	or(decoder) {
+		return or(this, decoder);
+	}
+	decode(input) {
+		const prefix = input[0];
+		const decoder = this.decoders[prefix];
+		if (decoder != null) return decoder.decode(input);
+		else throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+	}
+};
+function or(left, right) {
+	return new ComposedDecoder({
+		...left.decoders ?? { [left.prefix]: left },
+		...right.decoders ?? { [right.prefix]: right }
+	});
+}
+var Codec = class {
+	name;
+	prefix;
+	baseEncode;
+	baseDecode;
+	encoder;
+	decoder;
+	constructor(name, prefix, baseEncode, baseDecode) {
+		this.name = name;
+		this.prefix = prefix;
+		this.baseEncode = baseEncode;
+		this.baseDecode = baseDecode;
+		this.encoder = new Encoder(name, prefix, baseEncode);
+		this.decoder = new Decoder(name, prefix, baseDecode);
+	}
+	encode(input) {
+		return this.encoder.encode(input);
+	}
+	decode(input) {
+		return this.decoder.decode(input);
+	}
+};
+function from$1({ name, prefix, encode, decode }) {
+	return new Codec(name, prefix, encode, decode);
+}
+function baseX({ name, prefix, alphabet }) {
+	const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
+	return from$1({
+		prefix,
+		name,
+		encode,
+		decode: (text) => coerce(decode(text))
+	});
+}
+function decode$4(string, alphabetIdx, bitsPerChar, name) {
+	let end = string.length;
+	while (string[end - 1] === "=") --end;
+	const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+	let bits = 0;
+	let buffer = 0;
+	let written = 0;
+	for (let i = 0; i < end; ++i) {
+		const value = alphabetIdx[string[i]];
+		if (value === void 0) throw new SyntaxError(`Non-${name} character`);
+		buffer = buffer << bitsPerChar | value;
+		bits += bitsPerChar;
+		if (bits >= 8) {
+			bits -= 8;
+			out[written++] = 255 & buffer >> bits;
+		}
+	}
+	if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) throw new SyntaxError("Unexpected end of data");
+	return out;
+}
+function encode$4(data, alphabet, bitsPerChar) {
+	const pad = alphabet[alphabet.length - 1] === "=";
+	const mask = (1 << bitsPerChar) - 1;
+	let out = "";
+	let bits = 0;
+	let buffer = 0;
+	for (let i = 0; i < data.length; ++i) {
+		buffer = buffer << 8 | data[i];
+		bits += 8;
+		while (bits > bitsPerChar) {
+			bits -= bitsPerChar;
+			out += alphabet[mask & buffer >> bits];
+		}
+	}
+	if (bits !== 0) out += alphabet[mask & buffer << bitsPerChar - bits];
+	if (pad) while ((out.length * bitsPerChar & 7) !== 0) out += "=";
+	return out;
+}
+function createAlphabetIdx(alphabet) {
+	const alphabetIdx = {};
+	for (let i = 0; i < alphabet.length; ++i) alphabetIdx[alphabet[i]] = i;
+	return alphabetIdx;
+}
+/**
+* RFC4648 Factory
+*/
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+	const alphabetIdx = createAlphabetIdx(alphabet);
+	return from$1({
+		prefix,
+		name,
+		encode(input) {
+			return encode$4(input, alphabet, bitsPerChar);
+		},
+		decode(input) {
+			return decode$4(input, alphabetIdx, bitsPerChar, name);
+		}
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base32.js
+var base32_exports = /* @__PURE__ */ __exportAll({
+	base32: () => base32,
+	base32hex: () => base32hex,
+	base32hexpad: () => base32hexpad,
+	base32hexpadupper: () => base32hexpadupper,
+	base32hexupper: () => base32hexupper,
+	base32pad: () => base32pad,
+	base32padupper: () => base32padupper,
+	base32upper: () => base32upper,
+	base32z: () => base32z
+});
+const base32 = rfc4648({
+	prefix: "b",
+	name: "base32",
+	alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+	bitsPerChar: 5
+});
+const base32upper = rfc4648({
+	prefix: "B",
+	name: "base32upper",
+	alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+	bitsPerChar: 5
+});
+const base32pad = rfc4648({
+	prefix: "c",
+	name: "base32pad",
+	alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+	bitsPerChar: 5
+});
+const base32padupper = rfc4648({
+	prefix: "C",
+	name: "base32padupper",
+	alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+	bitsPerChar: 5
+});
+const base32hex = rfc4648({
+	prefix: "v",
+	name: "base32hex",
+	alphabet: "0123456789abcdefghijklmnopqrstuv",
+	bitsPerChar: 5
+});
+const base32hexupper = rfc4648({
+	prefix: "V",
+	name: "base32hexupper",
+	alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+	bitsPerChar: 5
+});
+const base32hexpad = rfc4648({
+	prefix: "t",
+	name: "base32hexpad",
+	alphabet: "0123456789abcdefghijklmnopqrstuv=",
+	bitsPerChar: 5
+});
+const base32hexpadupper = rfc4648({
+	prefix: "T",
+	name: "base32hexpadupper",
+	alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+	bitsPerChar: 5
+});
+const base32z = rfc4648({
+	prefix: "h",
+	name: "base32z",
+	alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+	bitsPerChar: 5
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base36.js
+var base36_exports = /* @__PURE__ */ __exportAll({
+	base36: () => base36,
+	base36upper: () => base36upper
+});
+const base36 = baseX({
+	prefix: "k",
+	name: "base36",
+	alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
+});
+const base36upper = baseX({
+	prefix: "K",
+	name: "base36upper",
+	alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base58.js
+var base58_exports = /* @__PURE__ */ __exportAll({
+	base58btc: () => base58btc,
+	base58flickr: () => base58flickr
+});
+const base58btc = baseX({
+	name: "base58btc",
+	prefix: "z",
+	alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+const base58flickr = baseX({
+	name: "base58flickr",
+	prefix: "Z",
+	alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/vendor/varint.js
+var encode_1 = encode$3;
+var MSB$1 = 128, MSBALL = -128, INT = Math.pow(2, 31);
+/**
+* @param {number} num
+* @param {number[]} out
+* @param {number} offset
+*/
+function encode$3(num, out, offset) {
+	out = out || [];
+	offset = offset || 0;
+	var oldOffset = offset;
+	while (num >= INT) {
+		out[offset++] = num & 255 | MSB$1;
+		num /= 128;
+	}
+	while (num & MSBALL) {
+		out[offset++] = num & 255 | MSB$1;
+		num >>>= 7;
+	}
+	out[offset] = num | 0;
+	encode$3.bytes = offset - oldOffset + 1;
+	return out;
+}
+var decode$3 = read$1;
+var MSB$1$1 = 128, REST$1 = 127;
+/**
+* @param {string | any[]} buf
+* @param {number} offset
+*/
+function read$1(buf, offset) {
+	var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+	do {
+		if (counter >= l) {
+			read$1.bytes = 0;
+			throw new RangeError("Could not decode varint");
+		}
+		b = buf[counter++];
+		res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+		shift += 7;
+	} while (b >= MSB$1$1);
+	read$1.bytes = counter - offset;
+	return res;
+}
+var N1$1 = Math.pow(2, 7);
+var N2$1 = Math.pow(2, 14);
+var N3$1 = Math.pow(2, 21);
+var N4$1 = Math.pow(2, 28);
+var N5$1 = Math.pow(2, 35);
+var N6$1 = Math.pow(2, 42);
+var N7$1 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length$1 = function(value) {
+	return value < N1$1 ? 1 : value < N2$1 ? 2 : value < N3$1 ? 3 : value < N4$1 ? 4 : value < N5$1 ? 5 : value < N6$1 ? 6 : value < N7$1 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+};
+var _brrp_varint = {
+	encode: encode_1,
+	decode: decode$3,
+	encodingLength: length$1
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/varint.js
+function decode$2(data, offset = 0) {
+	return [_brrp_varint.decode(data, offset), _brrp_varint.decode.bytes];
+}
+function encodeTo(int, target, offset = 0) {
+	_brrp_varint.encode(int, target, offset);
+	return target;
+}
+function encodingLength$1(int) {
+	return _brrp_varint.encodingLength(int);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/hashes/digest.js
+/**
+* Creates a multihash digest.
+*/
+function create(code, digest) {
+	const size = digest.byteLength;
+	const sizeOffset = encodingLength$1(code);
+	const digestOffset = sizeOffset + encodingLength$1(size);
+	const bytes = new Uint8Array(digestOffset + size);
+	encodeTo(code, bytes, 0);
+	encodeTo(size, bytes, sizeOffset);
+	bytes.set(digest, digestOffset);
+	return new Digest(code, size, digest, bytes);
+}
+/**
+* Turns bytes representation of multihash digest into an instance.
+*/
+function decode$1(multihash) {
+	const bytes = coerce(multihash);
+	const [code, sizeOffset] = decode$2(bytes);
+	const [size, digestOffset] = decode$2(bytes.subarray(sizeOffset));
+	const digest = bytes.subarray(sizeOffset + digestOffset);
+	if (digest.byteLength !== size) throw new Error("Incorrect length");
+	return new Digest(code, size, digest, bytes);
+}
+function equals(a, b) {
+	if (a === b) return true;
+	else {
+		const data = b;
+		return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals$1(a.bytes, data.bytes);
+	}
+}
+/**
+* Represents a multihash digest which carries information about the
+* hashing algorithm and an actual hash digest.
+*/
+var Digest = class {
+	code;
+	size;
+	digest;
+	bytes;
+	/**
+	* Creates a multihash digest.
+	*/
+	constructor(code, size, digest, bytes) {
+		this.code = code;
+		this.size = size;
+		this.digest = digest;
+		this.bytes = bytes;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/cid.js
+function format$1(link, base) {
+	const { bytes, version } = link;
+	switch (version) {
+		case 0: return toStringV0(bytes, baseCache(link), base ?? base58btc.encoder);
+		default: return toStringV1(bytes, baseCache(link), base ?? base32.encoder);
+	}
+}
+const cache = /* @__PURE__ */ new WeakMap();
+function baseCache(cid) {
+	const baseCache = cache.get(cid);
+	if (baseCache == null) {
+		const baseCache = /* @__PURE__ */ new Map();
+		cache.set(cid, baseCache);
+		return baseCache;
+	}
+	return baseCache;
+}
+var CID = class CID {
+	code;
+	version;
+	multihash;
+	bytes;
+	"/";
+	/**
+	* @param version - Version of the CID
+	* @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+	* @param multihash - (Multi)hash of the of the content.
+	*/
+	constructor(version, code, multihash, bytes) {
+		this.code = code;
+		this.version = version;
+		this.multihash = multihash;
+		this.bytes = bytes;
+		this["/"] = bytes;
+	}
+	/**
+	* Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+	* please either use `CID.asCID(cid)` or switch to new signalling mechanism
+	*
+	* @deprecated
+	*/
+	get asCID() {
+		return this;
+	}
+	get byteOffset() {
+		return this.bytes.byteOffset;
+	}
+	get byteLength() {
+		return this.bytes.byteLength;
+	}
+	toV0() {
+		switch (this.version) {
+			case 0: return this;
+			case 1: {
+				const { code, multihash } = this;
+				if (code !== DAG_PB_CODE) throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+				if (multihash.code !== SHA_256_CODE) throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+				return CID.createV0(multihash);
+			}
+			default: throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+		}
+	}
+	toV1() {
+		switch (this.version) {
+			case 0: {
+				const { code, digest } = this.multihash;
+				const multihash = create(code, digest);
+				return CID.createV1(this.code, multihash);
+			}
+			case 1: return this;
+			default: throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+		}
+	}
+	equals(other) {
+		return CID.equals(this, other);
+	}
+	static equals(self, other) {
+		const unknown = other;
+		return unknown != null && self.code === unknown.code && self.version === unknown.version && equals(self.multihash, unknown.multihash);
+	}
+	toString(base) {
+		return format$1(this, base);
+	}
+	toJSON() {
+		return { "/": format$1(this) };
+	}
+	link() {
+		return this;
+	}
+	[Symbol.toStringTag] = "CID";
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return `CID(${this.toString()})`;
+	}
+	/**
+	* Takes any input `value` and returns a `CID` instance if it was
+	* a `CID` otherwise returns `null`. If `value` is instanceof `CID`
+	* it will return value back. If `value` is not instance of this CID
+	* class, but is compatible CID it will return new instance of this
+	* `CID` class. Otherwise returns null.
+	*
+	* This allows two different incompatible versions of CID library to
+	* co-exist and interop as long as binary interface is compatible.
+	*/
+	static asCID(input) {
+		if (input == null) return null;
+		const value = input;
+		if (value instanceof CID) return value;
+		else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+			const { version, code, multihash, bytes } = value;
+			return new CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
+		} else if (value[cidSymbol] === true) {
+			const { version, multihash, code } = value;
+			const digest = decode$1(multihash);
+			return CID.create(version, code, digest);
+		} else return null;
+	}
+	/**
+	* @param version - Version of the CID
+	* @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+	* @param digest - (Multi)hash of the of the content.
+	*/
+	static create(version, code, digest) {
+		if (typeof code !== "number") throw new Error("String codecs are no longer supported");
+		if (!(digest.bytes instanceof Uint8Array)) throw new Error("Invalid digest");
+		switch (version) {
+			case 0: if (code !== DAG_PB_CODE) throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+			else return new CID(version, code, digest, digest.bytes);
+			case 1: return new CID(version, code, digest, encodeCID(version, code, digest.bytes));
+			default: throw new Error("Invalid version");
+		}
+	}
+	/**
+	* Simplified version of `create` for CIDv0.
+	*/
+	static createV0(digest) {
+		return CID.create(0, DAG_PB_CODE, digest);
+	}
+	/**
+	* Simplified version of `create` for CIDv1.
+	*
+	* @param code - Content encoding format code.
+	* @param digest - Multihash of the content.
+	*/
+	static createV1(code, digest) {
+		return CID.create(1, code, digest);
+	}
+	/**
+	* Decoded a CID from its binary representation. The byte array must contain
+	* only the CID with no additional bytes.
+	*
+	* An error will be thrown if the bytes provided do not contain a valid
+	* binary representation of a CID.
+	*/
+	static decode(bytes) {
+		const [cid, remainder] = CID.decodeFirst(bytes);
+		if (remainder.length !== 0) throw new Error("Incorrect length");
+		return cid;
+	}
+	/**
+	* Decoded a CID from its binary representation at the beginning of a byte
+	* array.
+	*
+	* Returns an array with the first element containing the CID and the second
+	* element containing the remainder of the original byte array. The remainder
+	* will be a zero-length byte array if the provided bytes only contained a
+	* binary CID representation.
+	*/
+	static decodeFirst(bytes) {
+		const specs = CID.inspectBytes(bytes);
+		const prefixSize = specs.size - specs.multihashSize;
+		const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+		if (multihashBytes.byteLength !== specs.multihashSize) throw new Error("Incorrect length");
+		const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+		const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+		return [specs.version === 0 ? CID.createV0(digest) : CID.createV1(specs.codec, digest), bytes.subarray(specs.size)];
+	}
+	/**
+	* Inspect the initial bytes of a CID to determine its properties.
+	*
+	* Involves decoding up to 4 varints. Typically this will require only 4 to 6
+	* bytes but for larger multicodec code values and larger multihash digest
+	* lengths these varints can be quite large. It is recommended that at least
+	* 10 bytes be made available in the `initialBytes` argument for a complete
+	* inspection.
+	*/
+	static inspectBytes(initialBytes) {
+		let offset = 0;
+		const next = () => {
+			const [i, length] = decode$2(initialBytes.subarray(offset));
+			offset += length;
+			return i;
+		};
+		let version = next();
+		let codec = DAG_PB_CODE;
+		if (version === 18) {
+			version = 0;
+			offset = 0;
+		} else codec = next();
+		if (version !== 0 && version !== 1) throw new RangeError(`Invalid CID version ${version}`);
+		const prefixSize = offset;
+		const multihashCode = next();
+		const digestSize = next();
+		const size = offset + digestSize;
+		const multihashSize = size - prefixSize;
+		return {
+			version,
+			codec,
+			multihashCode,
+			digestSize,
+			multihashSize,
+			size
+		};
+	}
+	/**
+	* Takes cid in a string representation and creates an instance. If `base`
+	* decoder is not provided will use a default from the configuration. It will
+	* throw an error if encoding of the CID is not compatible with supplied (or
+	* a default decoder).
+	*/
+	static parse(source, base) {
+		const [prefix, bytes] = parseCIDtoBytes(source, base);
+		const cid = CID.decode(bytes);
+		if (cid.version === 0 && source[0] !== "Q") throw Error("Version 0 CID string must not include multibase prefix");
+		baseCache(cid).set(prefix, source);
+		return cid;
+	}
+};
+function parseCIDtoBytes(source, base) {
+	switch (source[0]) {
+		case "Q": {
+			const decoder = base ?? base58btc;
+			return [base58btc.prefix, decoder.decode(`${base58btc.prefix}${source}`)];
+		}
+		case base58btc.prefix: {
+			const decoder = base ?? base58btc;
+			return [base58btc.prefix, decoder.decode(source)];
+		}
+		case base32.prefix: {
+			const decoder = base ?? base32;
+			return [base32.prefix, decoder.decode(source)];
+		}
+		case base36.prefix: {
+			const decoder = base ?? base36;
+			return [base36.prefix, decoder.decode(source)];
+		}
+		default:
+			if (base == null) throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
+			return [source[0], base.decode(source)];
+	}
+}
+function toStringV0(bytes, cache, base) {
+	const { prefix } = base;
+	if (prefix !== base58btc.prefix) throw Error(`Cannot string encode V0 in ${base.name} encoding`);
+	const cid = cache.get(prefix);
+	if (cid == null) {
+		const cid = base.encode(bytes).slice(1);
+		cache.set(prefix, cid);
+		return cid;
+	} else return cid;
+}
+function toStringV1(bytes, cache, base) {
+	const { prefix } = base;
+	const cid = cache.get(prefix);
+	if (cid == null) {
+		const cid = base.encode(bytes);
+		cache.set(prefix, cid);
+		return cid;
+	} else return cid;
+}
+const DAG_PB_CODE = 112;
+const SHA_256_CODE = 18;
+function encodeCID(version, code, multihash) {
+	const codeOffset = encodingLength$1(version);
+	const hashOffset = codeOffset + encodingLength$1(code);
+	const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+	encodeTo(version, bytes, 0);
+	encodeTo(code, bytes, codeOffset);
+	bytes.set(multihash, hashOffset);
+	return bytes;
+}
+const cidSymbol = Symbol.for("@ipld/js-cid/CID");
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/hashes/hasher.js
+const DEFAULT_MIN_DIGEST_LENGTH = 20;
+function from({ name, code, encode, minDigestLength, maxDigestLength }) {
+	return new Hasher(name, code, encode, minDigestLength, maxDigestLength);
+}
+/**
+* Hasher represents a hashing algorithm implementation that produces as
+* `MultihashDigest`.
+*/
+var Hasher = class {
+	name;
+	code;
+	encode;
+	minDigestLength;
+	maxDigestLength;
+	constructor(name, code, encode, minDigestLength, maxDigestLength) {
+		this.name = name;
+		this.code = code;
+		this.encode = encode;
+		this.minDigestLength = minDigestLength ?? DEFAULT_MIN_DIGEST_LENGTH;
+		this.maxDigestLength = maxDigestLength;
+	}
+	digest(input, options) {
+		if (options?.truncate != null) {
+			if (options.truncate < this.minDigestLength) throw new Error(`Invalid truncate option, must be greater than or equal to ${this.minDigestLength}`);
+			if (this.maxDigestLength != null && options.truncate > this.maxDigestLength) throw new Error(`Invalid truncate option, must be less than or equal to ${this.maxDigestLength}`);
+		}
+		if (input instanceof Uint8Array) {
+			const result = this.encode(input);
+			if (result instanceof Uint8Array) return createDigest(result, this.code, options?.truncate);
+			return result.then((digest) => createDigest(digest, this.code, options?.truncate));
+		} else throw Error("Unknown type, must be binary type");
+	}
+};
+/**
+* Create a Digest from the passed uint8array and code, optionally truncating it
+* first.
+*/
+function createDigest(digest, code, truncate) {
+	if (truncate != null && truncate !== digest.byteLength) {
+		if (truncate > digest.byteLength) throw new Error(`Invalid truncate option, must be less than or equal to ${digest.byteLength}`);
+		digest = digest.subarray(0, truncate);
+	}
+	return create(code, digest);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/hashes/sha2.js
+var sha2_exports = /* @__PURE__ */ __exportAll({
+	sha256: () => sha256,
+	sha512: () => sha512
+});
+const sha256 = from({
+	name: "sha2-256",
+	code: 18,
+	encode: (input) => coerce(crypto.createHash("sha256").update(input).digest())
+});
+const sha512 = from({
+	name: "sha2-512",
+	code: 19,
+	encode: (input) => coerce(crypto.createHash("sha512").update(input).digest())
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ipld+dag-pb@4.1.3/node_modules/@ipld/dag-pb/src/pb-decode.js
+const textDecoder$1 = new TextDecoder();
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ipld+dag-pb@4.1.3/node_modules/@ipld/dag-pb/src/pb-encode.js
+const textEncoder$2 = new TextEncoder();
+const maxInt32 = 2 ** 32;
+const maxUInt32 = 2 ** 31;
+/**
+* @typedef {import('./interface.js').RawPBLink} RawPBLink
+*/
+/**
+* @typedef {import('./interface.js').RawPBNode} RawPBNode
+*/
+/**
+* encodeLink() is passed a slice of the parent byte array that ends where this
+* link needs to end, so it packs to the right-most part of the passed `bytes`
+*
+* @param {RawPBLink} link
+* @param {Uint8Array} bytes
+* @returns {number}
+*/
+function encodeLink(link, bytes) {
+	let i = bytes.length;
+	if (typeof link.Tsize === "number") {
+		if (link.Tsize < 0) throw new Error("Tsize cannot be negative");
+		if (!Number.isSafeInteger(link.Tsize)) throw new Error("Tsize too large for encoding");
+		i = encodeVarint(bytes, i, link.Tsize) - 1;
+		bytes[i] = 24;
+	}
+	if (typeof link.Name === "string") {
+		const nameBytes = textEncoder$2.encode(link.Name);
+		i -= nameBytes.length;
+		bytes.set(nameBytes, i);
+		i = encodeVarint(bytes, i, nameBytes.length) - 1;
+		bytes[i] = 18;
+	}
+	if (link.Hash) {
+		i -= link.Hash.length;
+		bytes.set(link.Hash, i);
+		i = encodeVarint(bytes, i, link.Hash.length) - 1;
+		bytes[i] = 10;
+	}
+	return bytes.length - i;
+}
+/**
+* Encodes a PBNode into a new byte array of precisely the correct size
+*
+* @param {RawPBNode} node
+* @returns {Uint8Array}
+*/
+function encodeNode(node) {
+	const size = sizeNode(node);
+	const bytes = new Uint8Array(size);
+	let i = size;
+	if (node.Data) {
+		i -= node.Data.length;
+		bytes.set(node.Data, i);
+		i = encodeVarint(bytes, i, node.Data.length) - 1;
+		bytes[i] = 10;
+	}
+	if (node.Links) for (let index = node.Links.length - 1; index >= 0; index--) {
+		const size = encodeLink(node.Links[index], bytes.subarray(0, i));
+		i -= size;
+		i = encodeVarint(bytes, i, size) - 1;
+		bytes[i] = 18;
+	}
+	return bytes;
+}
+/**
+* work out exactly how many bytes this link takes up
+*
+* @param {RawPBLink} link
+* @returns
+*/
+function sizeLink(link) {
+	let n = 0;
+	if (link.Hash) {
+		const l = link.Hash.length;
+		n += 1 + l + sov(l);
+	}
+	if (typeof link.Name === "string") {
+		const l = textEncoder$2.encode(link.Name).length;
+		n += 1 + l + sov(l);
+	}
+	if (typeof link.Tsize === "number") n += 1 + sov(link.Tsize);
+	return n;
+}
+/**
+* Work out exactly how many bytes this node takes up
+*
+* @param {RawPBNode} node
+* @returns {number}
+*/
+function sizeNode(node) {
+	let n = 0;
+	if (node.Data) {
+		const l = node.Data.length;
+		n += 1 + l + sov(l);
+	}
+	if (node.Links) for (const link of node.Links) {
+		const l = sizeLink(link);
+		n += 1 + l + sov(l);
+	}
+	return n;
+}
+/**
+* @param {Uint8Array} bytes
+* @param {number} offset
+* @param {number} v
+* @returns {number}
+*/
+function encodeVarint(bytes, offset, v) {
+	offset -= sov(v);
+	const base = offset;
+	while (v >= maxUInt32) {
+		bytes[offset++] = v & 127 | 128;
+		v /= 128;
+	}
+	while (v >= 128) {
+		bytes[offset++] = v & 127 | 128;
+		v >>>= 7;
+	}
+	bytes[offset] = v;
+	return base;
+}
+/**
+* size of varint
+*
+* @param {number} x
+* @returns {number}
+*/
+function sov(x) {
+	if (x % 2 === 0) x++;
+	return Math.floor((len64(x) + 6) / 7);
+}
+/**
+* golang math/bits, how many bits does it take to represent this integer?
+*
+* @param {number} x
+* @returns {number}
+*/
+function len64(x) {
+	let n = 0;
+	if (x >= maxInt32) {
+		x = Math.floor(x / maxInt32);
+		n = 32;
+	}
+	if (x >= 65536) {
+		x >>>= 16;
+		n += 16;
+	}
+	if (x >= 256) {
+		x >>>= 8;
+		n += 8;
+	}
+	return n + len8tab[x];
+}
+const len8tab = [
+	0,
+	1,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	7,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ipld+dag-pb@4.1.3/node_modules/@ipld/dag-pb/src/util.js
+/**
+* @typedef {import('./interface.js').PBLink} PBLink
+* @typedef {import('./interface.js').PBNode} PBNode
+*/
+/**
+* @template T
+* @typedef {import('multiformats/codecs/interface').ByteView<T>} ByteView
+*/
+/**
+* @template T
+* @typedef {import('multiformats/codecs/interface').ArrayBufferView<T>} ArrayBufferView
+*/
+const pbNodeProperties = ["Data", "Links"];
+const pbLinkProperties = [
+	"Hash",
+	"Name",
+	"Tsize"
+];
+const textEncoder$1 = new TextEncoder();
+/**
+* @param {PBLink} a
+* @param {PBLink} b
+* @returns {number}
+*/
+function linkComparator(a, b) {
+	if (a === b) return 0;
+	const abuf = a.Name ? textEncoder$1.encode(a.Name) : [];
+	const bbuf = b.Name ? textEncoder$1.encode(b.Name) : [];
+	let x = abuf.length;
+	let y = bbuf.length;
+	for (let i = 0, len = Math.min(x, y); i < len; ++i) if (abuf[i] !== bbuf[i]) {
+		x = abuf[i];
+		y = bbuf[i];
+		break;
+	}
+	return x < y ? -1 : y < x ? 1 : 0;
+}
+/**
+* @param {any} node
+* @param {string[]} properties
+* @returns {boolean}
+*/
+function hasOnlyProperties(node, properties) {
+	return !Object.keys(node).some((p) => !properties.includes(p));
+}
+/**
+* @param {PBNode} node
+*/
+function validate(node) {
+	if (!node || typeof node !== "object" || Array.isArray(node) || node instanceof Uint8Array || node["/"] && node["/"] === node.bytes) throw new TypeError("Invalid DAG-PB form");
+	if (!hasOnlyProperties(node, pbNodeProperties)) throw new TypeError("Invalid DAG-PB form (extraneous properties)");
+	if (node.Data !== void 0 && !(node.Data instanceof Uint8Array)) throw new TypeError("Invalid DAG-PB form (Data must be bytes)");
+	if (!Array.isArray(node.Links)) throw new TypeError("Invalid DAG-PB form (Links must be a list)");
+	for (let i = 0; i < node.Links.length; i++) {
+		const link = node.Links[i];
+		if (!link || typeof link !== "object" || Array.isArray(link) || link instanceof Uint8Array || link["/"] && link["/"] === link.bytes) throw new TypeError("Invalid DAG-PB form (bad link)");
+		if (!hasOnlyProperties(link, pbLinkProperties)) throw new TypeError("Invalid DAG-PB form (extraneous properties on link)");
+		if (link.Hash === void 0) throw new TypeError("Invalid DAG-PB form (link must have a Hash)");
+		if (link.Hash == null || !link.Hash["/"] || link.Hash["/"] !== link.Hash.bytes) throw new TypeError("Invalid DAG-PB form (link Hash must be a CID)");
+		if (link.Name !== void 0 && typeof link.Name !== "string") throw new TypeError("Invalid DAG-PB form (link Name must be a string)");
+		if (link.Tsize !== void 0) {
+			if (typeof link.Tsize !== "number" || link.Tsize % 1 !== 0) throw new TypeError("Invalid DAG-PB form (link Tsize must be an integer)");
+			if (link.Tsize < 0) throw new TypeError("Invalid DAG-PB form (link Tsize cannot be negative)");
+		}
+		if (i > 0 && linkComparator(link, node.Links[i - 1]) === -1) throw new TypeError("Invalid DAG-PB form (links must be sorted by Name bytes)");
+	}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@ipld+dag-pb@4.1.3/node_modules/@ipld/dag-pb/src/index.js
+/**
+* @param {PBNode} node
+* @returns {ByteView<PBNode>}
+*/
+function encode$2(node) {
+	validate(node);
+	const pbn = {};
+	if (node.Links) pbn.Links = node.Links.map((l) => {
+		const link = {};
+		if (l.Hash) link.Hash = l.Hash.bytes;
+		if (l.Name !== void 0) link.Name = l.Name;
+		if (l.Tsize !== void 0) link.Tsize = l.Tsize;
+		return link;
+	});
+	if (node.Data) pbn.Data = node.Data;
+	return encodeNode(pbn);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ipfs-unixfs@12.0.0/node_modules/ipfs-unixfs/dist/src/errors.js
+var InvalidTypeError = class InvalidTypeError extends Error {
+	static name = "InvalidTypeError";
+	static code = "ERR_INVALID_TYPE";
+	name = InvalidTypeError.name;
+	code = InvalidTypeError.code;
+	constructor(message = "Invalid type") {
+		super(message);
+	}
+};
+var InvalidUnixFSMessageError = class InvalidUnixFSMessageError extends Error {
+	static name = "InvalidUnixFSMessageError";
+	static code = "ERR_INVALID_MESSAGE";
+	name = InvalidUnixFSMessageError.name;
+	code = InvalidUnixFSMessageError.code;
+	constructor(message = "Invalid message") {
+		super(message);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/uint8arrays@5.1.0/node_modules/uint8arrays/dist/src/util/as-uint8array.node.js
+/**
+* To guarantee Uint8Array semantics, convert nodejs Buffers
+* into vanilla Uint8Arrays
+*/
+function asUint8Array(buf) {
+	return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/uint8arrays@5.1.0/node_modules/uint8arrays/dist/src/alloc.node.js
+/**
+* Where possible returns a Uint8Array of the requested size that references
+* uninitialized memory. Only use if you are certain you will immediately
+* overwrite every value in the returned `Uint8Array`.
+*/
+function allocUnsafe(size = 0) {
+	return asUint8Array(Buffer$1.allocUnsafe(size));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/uint8-varint@2.0.4/node_modules/uint8-varint/dist/src/index.js
+const N1 = Math.pow(2, 7);
+const N2 = Math.pow(2, 14);
+const N3 = Math.pow(2, 21);
+const N4 = Math.pow(2, 28);
+const N5 = Math.pow(2, 35);
+const N6 = Math.pow(2, 42);
+const N7 = Math.pow(2, 49);
+/** Most significant bit of a byte */
+const MSB = 128;
+/** Rest of the bits in a byte */
+const REST = 127;
+function encodingLength(value) {
+	if (value < N1) return 1;
+	if (value < N2) return 2;
+	if (value < N3) return 3;
+	if (value < N4) return 4;
+	if (value < N5) return 5;
+	if (value < N6) return 6;
+	if (value < N7) return 7;
+	if (Number.MAX_SAFE_INTEGER != null && value > Number.MAX_SAFE_INTEGER) throw new RangeError("Could not encode varint");
+	return 8;
+}
+function encodeUint8Array(value, buf, offset = 0) {
+	switch (encodingLength(value)) {
+		case 8:
+			buf[offset++] = value & 255 | MSB;
+			value /= 128;
+		case 7:
+			buf[offset++] = value & 255 | MSB;
+			value /= 128;
+		case 6:
+			buf[offset++] = value & 255 | MSB;
+			value /= 128;
+		case 5:
+			buf[offset++] = value & 255 | MSB;
+			value /= 128;
+		case 4:
+			buf[offset++] = value & 255 | MSB;
+			value >>>= 7;
+		case 3:
+			buf[offset++] = value & 255 | MSB;
+			value >>>= 7;
+		case 2:
+			buf[offset++] = value & 255 | MSB;
+			value >>>= 7;
+		case 1:
+			buf[offset++] = value & 255;
+			value >>>= 7;
+			break;
+		default: throw new Error("unreachable");
+	}
+	return buf;
+}
+function decodeUint8Array(buf, offset) {
+	let b = buf[offset];
+	let res = 0;
+	res += b & REST;
+	if (b < MSB) return res;
+	b = buf[offset + 1];
+	res += (b & REST) << 7;
+	if (b < MSB) return res;
+	b = buf[offset + 2];
+	res += (b & REST) << 14;
+	if (b < MSB) return res;
+	b = buf[offset + 3];
+	res += (b & REST) << 21;
+	if (b < MSB) return res;
+	b = buf[offset + 4];
+	res += (b & REST) * N4;
+	if (b < MSB) return res;
+	b = buf[offset + 5];
+	res += (b & REST) * N5;
+	if (b < MSB) return res;
+	b = buf[offset + 6];
+	res += (b & REST) * N6;
+	if (b < MSB) return res;
+	b = buf[offset + 7];
+	res += (b & REST) * N7;
+	if (b < MSB) return res;
+	throw new RangeError("Could not decode varint");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/utils/float.js
+const f32 = new Float32Array([-0]);
+const f8b = new Uint8Array(f32.buffer);
+/**
+* Writes a 32 bit float to a buffer using little endian byte order
+*/
+function writeFloatLE(val, buf, pos) {
+	f32[0] = val;
+	buf[pos] = f8b[0];
+	buf[pos + 1] = f8b[1];
+	buf[pos + 2] = f8b[2];
+	buf[pos + 3] = f8b[3];
+}
+/**
+* Reads a 32 bit float from a buffer using little endian byte order
+*/
+function readFloatLE(buf, pos) {
+	f8b[0] = buf[pos];
+	f8b[1] = buf[pos + 1];
+	f8b[2] = buf[pos + 2];
+	f8b[3] = buf[pos + 3];
+	return f32[0];
+}
+const f64 = new Float64Array([-0]);
+const d8b = new Uint8Array(f64.buffer);
+/**
+* Writes a 64 bit double to a buffer using little endian byte order
+*/
+function writeDoubleLE(val, buf, pos) {
+	f64[0] = val;
+	buf[pos] = d8b[0];
+	buf[pos + 1] = d8b[1];
+	buf[pos + 2] = d8b[2];
+	buf[pos + 3] = d8b[3];
+	buf[pos + 4] = d8b[4];
+	buf[pos + 5] = d8b[5];
+	buf[pos + 6] = d8b[6];
+	buf[pos + 7] = d8b[7];
+}
+/**
+* Reads a 64 bit double from a buffer using little endian byte order
+*/
+function readDoubleLE(buf, pos) {
+	d8b[0] = buf[pos];
+	d8b[1] = buf[pos + 1];
+	d8b[2] = buf[pos + 2];
+	d8b[3] = buf[pos + 3];
+	d8b[4] = buf[pos + 4];
+	d8b[5] = buf[pos + 5];
+	d8b[6] = buf[pos + 6];
+	d8b[7] = buf[pos + 7];
+	return f64[0];
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/utils/longbits.js
+const MAX_SAFE_NUMBER_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_NUMBER_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
+/**
+* Constructs new long bits.
+*
+* @classdesc Helper class for working with the low and high bits of a 64 bit value.
+* @memberof util
+* @function Object() { [native code] }
+* @param {number} lo - Low 32 bits, unsigned
+* @param {number} hi - High 32 bits, unsigned
+*/
+var LongBits = class LongBits {
+	lo;
+	hi;
+	constructor(lo, hi) {
+		/**
+		* Low bits
+		*/
+		this.lo = lo | 0;
+		/**
+		* High bits
+		*/
+		this.hi = hi | 0;
+	}
+	/**
+	* Converts this long bits to a possibly unsafe JavaScript number
+	*/
+	toNumber(unsigned = false) {
+		if (!unsigned && this.hi >>> 31 > 0) {
+			const lo = ~this.lo + 1 >>> 0;
+			let hi = ~this.hi >>> 0;
+			if (lo === 0) hi = hi + 1 >>> 0;
+			return -(lo + hi * 4294967296);
+		}
+		return this.lo + this.hi * 4294967296;
+	}
+	/**
+	* Converts this long bits to a bigint
+	*/
+	toBigInt(unsigned = false) {
+		if (unsigned) return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+		if (this.hi >>> 31 !== 0) {
+			const lo = ~this.lo + 1 >>> 0;
+			let hi = ~this.hi >>> 0;
+			if (lo === 0) hi = hi + 1 >>> 0;
+			return -(BigInt(lo) + (BigInt(hi) << 32n));
+		}
+		return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+	}
+	/**
+	* Converts this long bits to a string
+	*/
+	toString(unsigned = false) {
+		return this.toBigInt(unsigned).toString();
+	}
+	/**
+	* Zig-zag encodes this long bits
+	*/
+	zzEncode() {
+		const mask = this.hi >> 31;
+		this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+		this.lo = (this.lo << 1 ^ mask) >>> 0;
+		return this;
+	}
+	/**
+	* Zig-zag decodes this long bits
+	*/
+	zzDecode() {
+		const mask = -(this.lo & 1);
+		this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+		this.hi = (this.hi >>> 1 ^ mask) >>> 0;
+		return this;
+	}
+	/**
+	* Calculates the length of this longbits when encoded as a varint.
+	*/
+	length() {
+		const part0 = this.lo;
+		const part1 = (this.lo >>> 28 | this.hi << 4) >>> 0;
+		const part2 = this.hi >>> 24;
+		return part2 === 0 ? part1 === 0 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
+	}
+	/**
+	* Constructs new long bits from the specified number
+	*/
+	static fromBigInt(value) {
+		if (value === 0n) return zero;
+		if (value < MAX_SAFE_NUMBER_INTEGER && value > MIN_SAFE_NUMBER_INTEGER) return this.fromNumber(Number(value));
+		const negative = value < 0n;
+		if (negative) value = -value;
+		let hi = value >> 32n;
+		let lo = value - (hi << 32n);
+		if (negative) {
+			hi = ~hi | 0n;
+			lo = ~lo | 0n;
+			if (++lo > TWO_32) {
+				lo = 0n;
+				if (++hi > TWO_32) hi = 0n;
+			}
+		}
+		return new LongBits(Number(lo), Number(hi));
+	}
+	/**
+	* Constructs new long bits from the specified number
+	*/
+	static fromNumber(value) {
+		if (value === 0) return zero;
+		const sign = value < 0;
+		if (sign) value = -value;
+		let lo = value >>> 0;
+		let hi = (value - lo) / 4294967296 >>> 0;
+		if (sign) {
+			hi = ~hi >>> 0;
+			lo = ~lo >>> 0;
+			if (++lo > 4294967295) {
+				lo = 0;
+				if (++hi > 4294967295) hi = 0;
+			}
+		}
+		return new LongBits(lo, hi);
+	}
+	/**
+	* Constructs new long bits from a number, long or string
+	*/
+	static from(value) {
+		if (typeof value === "number") return LongBits.fromNumber(value);
+		if (typeof value === "bigint") return LongBits.fromBigInt(value);
+		if (typeof value === "string") return LongBits.fromBigInt(BigInt(value));
+		return value.low != null || value.high != null ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+	}
+};
+const zero = new LongBits(0, 0);
+zero.toBigInt = function() {
+	return 0n;
+};
+zero.zzEncode = zero.zzDecode = function() {
+	return this;
+};
+zero.length = function() {
+	return 1;
+};
+const TWO_32 = 4294967296n;
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/utils/utf8.js
+/**
+* Calculates the UTF8 byte length of a string
+*/
+function length(string) {
+	let len = 0;
+	let c = 0;
+	for (let i = 0; i < string.length; ++i) {
+		c = string.charCodeAt(i);
+		if (c < 128) len += 1;
+		else if (c < 2048) len += 2;
+		else if ((c & 64512) === 55296 && (string.charCodeAt(i + 1) & 64512) === 56320) {
+			++i;
+			len += 4;
+		} else len += 3;
+	}
+	return len;
+}
+/**
+* Reads UTF8 bytes as a string
+*/
+function read(buffer, start, end) {
+	if (end - start < 1) return "";
+	let parts;
+	const chunk = [];
+	let i = 0;
+	let t;
+	while (start < end) {
+		t = buffer[start++];
+		if (t < 128) chunk[i++] = t;
+		else if (t > 191 && t < 224) chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;
+		else if (t > 239 && t < 365) {
+			t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 65536;
+			chunk[i++] = 55296 + (t >> 10);
+			chunk[i++] = 56320 + (t & 1023);
+		} else chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;
+		if (i > 8191) {
+			(parts ?? (parts = [])).push(String.fromCharCode.apply(String, chunk));
+			i = 0;
+		}
+	}
+	if (parts != null) {
+		if (i > 0) parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+		return parts.join("");
+	}
+	return String.fromCharCode.apply(String, chunk.slice(0, i));
+}
+/**
+* Writes a string as UTF8 bytes
+*/
+function write(string, buffer, offset) {
+	const start = offset;
+	let c1;
+	let c2;
+	for (let i = 0; i < string.length; ++i) {
+		c1 = string.charCodeAt(i);
+		if (c1 < 128) buffer[offset++] = c1;
+		else if (c1 < 2048) {
+			buffer[offset++] = c1 >> 6 | 192;
+			buffer[offset++] = c1 & 63 | 128;
+		} else if ((c1 & 64512) === 55296 && ((c2 = string.charCodeAt(i + 1)) & 64512) === 56320) {
+			c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+			++i;
+			buffer[offset++] = c1 >> 18 | 240;
+			buffer[offset++] = c1 >> 12 & 63 | 128;
+			buffer[offset++] = c1 >> 6 & 63 | 128;
+			buffer[offset++] = c1 & 63 | 128;
+		} else {
+			buffer[offset++] = c1 >> 12 | 224;
+			buffer[offset++] = c1 >> 6 & 63 | 128;
+			buffer[offset++] = c1 & 63 | 128;
+		}
+	}
+	return offset - start;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/utils/reader.js
+/* istanbul ignore next */
+function indexOutOfRange(reader, writeLength) {
+	return RangeError(`index out of range: ${reader.pos} + ${writeLength ?? 1} > ${reader.len}`);
+}
+function readFixed32End(buf, end) {
+	return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
+}
+/**
+* Constructs a new reader instance using the specified buffer.
+*/
+var Uint8ArrayReader = class {
+	buf;
+	pos;
+	len;
+	_slice = Uint8Array.prototype.subarray;
+	constructor(buffer) {
+		/**
+		* Read buffer
+		*/
+		this.buf = buffer;
+		/**
+		* Read buffer position
+		*/
+		this.pos = 0;
+		/**
+		* Read buffer length
+		*/
+		this.len = buffer.length;
+	}
+	/**
+	* Reads a varint as an unsigned 32 bit value
+	*/
+	uint32() {
+		let value = 4294967295;
+		value = (this.buf[this.pos] & 127) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
+		if (this.buf[this.pos++] < 128) return value;
+		if ((this.pos += 5) > this.len) {
+			this.pos = this.len;
+			throw indexOutOfRange(this, 10);
+		}
+		return value;
+	}
+	/**
+	* Reads a varint as a signed 32 bit value
+	*/
+	int32() {
+		return this.uint32() | 0;
+	}
+	/**
+	* Reads a zig-zag encoded varint as a signed 32 bit value
+	*/
+	sint32() {
+		const value = this.uint32();
+		return value >>> 1 ^ -(value & 1) | 0;
+	}
+	/**
+	* Reads a varint as a boolean
+	*/
+	bool() {
+		return this.uint32() !== 0;
+	}
+	/**
+	* Reads fixed 32 bits as an unsigned 32 bit integer
+	*/
+	fixed32() {
+		if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+		return readFixed32End(this.buf, this.pos += 4);
+	}
+	/**
+	* Reads fixed 32 bits as a signed 32 bit integer
+	*/
+	sfixed32() {
+		if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+		return readFixed32End(this.buf, this.pos += 4) | 0;
+	}
+	/**
+	* Reads a float (32 bit) as a number
+	*/
+	float() {
+		if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+		const value = readFloatLE(this.buf, this.pos);
+		this.pos += 4;
+		return value;
+	}
+	/**
+	* Reads a double (64 bit float) as a number
+	*/
+	double() {
+		/* istanbul ignore if */
+		if (this.pos + 8 > this.len) throw indexOutOfRange(this, 4);
+		const value = readDoubleLE(this.buf, this.pos);
+		this.pos += 8;
+		return value;
+	}
+	/**
+	* Reads a sequence of bytes preceded by its length as a varint
+	*/
+	bytes() {
+		const length = this.uint32();
+		const start = this.pos;
+		const end = this.pos + length;
+		/* istanbul ignore if */
+		if (end > this.len) throw indexOutOfRange(this, length);
+		this.pos += length;
+		return start === end ? new Uint8Array(0) : this.buf.subarray(start, end);
+	}
+	/**
+	* Reads a string preceded by its byte length as a varint
+	*/
+	string() {
+		const bytes = this.bytes();
+		return read(bytes, 0, bytes.length);
+	}
+	/**
+	* Skips the specified number of bytes if specified, otherwise skips a varint
+	*/
+	skip(length) {
+		if (typeof length === "number") {
+			/* istanbul ignore if */
+			if (this.pos + length > this.len) throw indexOutOfRange(this, length);
+			this.pos += length;
+		} else do
+			/* istanbul ignore if */
+			if (this.pos >= this.len) throw indexOutOfRange(this);
+		while ((this.buf[this.pos++] & 128) !== 0);
+		return this;
+	}
+	/**
+	* Skips the next element of the specified wire type
+	*/
+	skipType(wireType) {
+		switch (wireType) {
+			case 0:
+				this.skip();
+				break;
+			case 1:
+				this.skip(8);
+				break;
+			case 2:
+				this.skip(this.uint32());
+				break;
+			case 3:
+				while ((wireType = this.uint32() & 7) !== 4) this.skipType(wireType);
+				break;
+			case 5:
+				this.skip(4);
+				break;
+			default: throw Error(`invalid wire type ${wireType} at offset ${this.pos}`);
+		}
+		return this;
+	}
+	readLongVarint() {
+		const bits = new LongBits(0, 0);
+		let i = 0;
+		if (this.len - this.pos > 4) {
+			for (; i < 4; ++i) {
+				bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+				if (this.buf[this.pos++] < 128) return bits;
+			}
+			bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
+			bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
+			if (this.buf[this.pos++] < 128) return bits;
+			i = 0;
+		} else {
+			for (; i < 3; ++i) {
+				/* istanbul ignore if */
+				if (this.pos >= this.len) throw indexOutOfRange(this);
+				bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+				if (this.buf[this.pos++] < 128) return bits;
+			}
+			bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+			return bits;
+		}
+		if (this.len - this.pos > 4) for (; i < 5; ++i) {
+			bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+			if (this.buf[this.pos++] < 128) return bits;
+		}
+		else for (; i < 5; ++i) {
+			if (this.pos >= this.len) throw indexOutOfRange(this);
+			bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+			if (this.buf[this.pos++] < 128) return bits;
+		}
+		throw Error("invalid varint encoding");
+	}
+	readFixed64() {
+		if (this.pos + 8 > this.len) throw indexOutOfRange(this, 8);
+		return new LongBits(readFixed32End(this.buf, this.pos += 4), readFixed32End(this.buf, this.pos += 4));
+	}
+	/**
+	* Reads a varint as a signed 64 bit value
+	*/
+	int64() {
+		return this.readLongVarint().toBigInt();
+	}
+	/**
+	* Reads a varint as a signed 64 bit value returned as a possibly unsafe
+	* JavaScript number
+	*/
+	int64Number() {
+		return this.readLongVarint().toNumber();
+	}
+	/**
+	* Reads a varint as a signed 64 bit value returned as a string
+	*/
+	int64String() {
+		return this.readLongVarint().toString();
+	}
+	/**
+	* Reads a varint as an unsigned 64 bit value
+	*/
+	uint64() {
+		return this.readLongVarint().toBigInt(true);
+	}
+	/**
+	* Reads a varint as an unsigned 64 bit value returned as a possibly unsafe
+	* JavaScript number
+	*/
+	uint64Number() {
+		const value = decodeUint8Array(this.buf, this.pos);
+		this.pos += encodingLength(value);
+		return value;
+	}
+	/**
+	* Reads a varint as an unsigned 64 bit value returned as a string
+	*/
+	uint64String() {
+		return this.readLongVarint().toString(true);
+	}
+	/**
+	* Reads a zig-zag encoded varint as a signed 64 bit value
+	*/
+	sint64() {
+		return this.readLongVarint().zzDecode().toBigInt();
+	}
+	/**
+	* Reads a zig-zag encoded varint as a signed 64 bit value returned as a
+	* possibly unsafe JavaScript number
+	*/
+	sint64Number() {
+		return this.readLongVarint().zzDecode().toNumber();
+	}
+	/**
+	* Reads a zig-zag encoded varint as a signed 64 bit value returned as a
+	* string
+	*/
+	sint64String() {
+		return this.readLongVarint().zzDecode().toString();
+	}
+	/**
+	* Reads fixed 64 bits
+	*/
+	fixed64() {
+		return this.readFixed64().toBigInt();
+	}
+	/**
+	* Reads fixed 64 bits returned as a possibly unsafe JavaScript number
+	*/
+	fixed64Number() {
+		return this.readFixed64().toNumber();
+	}
+	/**
+	* Reads fixed 64 bits returned as a string
+	*/
+	fixed64String() {
+		return this.readFixed64().toString();
+	}
+	/**
+	* Reads zig-zag encoded fixed 64 bits
+	*/
+	sfixed64() {
+		return this.readFixed64().toBigInt();
+	}
+	/**
+	* Reads zig-zag encoded fixed 64 bits returned as a possibly unsafe
+	* JavaScript number
+	*/
+	sfixed64Number() {
+		return this.readFixed64().toNumber();
+	}
+	/**
+	* Reads zig-zag encoded fixed 64 bits returned as a string
+	*/
+	sfixed64String() {
+		return this.readFixed64().toString();
+	}
+};
+function createReader(buf) {
+	return new Uint8ArrayReader(buf instanceof Uint8Array ? buf : buf.subarray());
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/decode.js
+function decodeMessage(buf, codec, opts) {
+	const reader = createReader(buf);
+	return codec.decode(reader, void 0, opts);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base10.js
+var base10_exports = /* @__PURE__ */ __exportAll({ base10: () => base10 });
+const base10 = baseX({
+	prefix: "9",
+	name: "base10",
+	alphabet: "0123456789"
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base16.js
+var base16_exports = /* @__PURE__ */ __exportAll({
+	base16: () => base16,
+	base16upper: () => base16upper
+});
+const base16 = rfc4648({
+	prefix: "f",
+	name: "base16",
+	alphabet: "0123456789abcdef",
+	bitsPerChar: 4
+});
+const base16upper = rfc4648({
+	prefix: "F",
+	name: "base16upper",
+	alphabet: "0123456789ABCDEF",
+	bitsPerChar: 4
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base2.js
+var base2_exports = /* @__PURE__ */ __exportAll({ base2: () => base2 });
+const base2 = rfc4648({
+	prefix: "0",
+	name: "base2",
+	alphabet: "01",
+	bitsPerChar: 1
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base256emoji.js
+var base256emoji_exports = /* @__PURE__ */ __exportAll({ base256emoji: () => base256emoji });
+const alphabet = Array.from("🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂");
+const alphabetBytesToChars = alphabet.reduce((p, c, i) => {
+	p[i] = c;
+	return p;
+}, []);
+const alphabetCharsToBytes = alphabet.reduce((p, c, i) => {
+	const codePoint = c.codePointAt(0);
+	if (codePoint == null) throw new Error(`Invalid character: ${c}`);
+	p[codePoint] = i;
+	return p;
+}, []);
+function encode$1(data) {
+	return data.reduce((p, c) => {
+		p += alphabetBytesToChars[c];
+		return p;
+	}, "");
+}
+function decode(str) {
+	const byts = [];
+	for (const char of str) {
+		const codePoint = char.codePointAt(0);
+		if (codePoint == null) throw new Error(`Invalid character: ${char}`);
+		const byt = alphabetCharsToBytes[codePoint];
+		if (byt == null) throw new Error(`Non-base256emoji character: ${char}`);
+		byts.push(byt);
+	}
+	return new Uint8Array(byts);
+}
+const base256emoji = from$1({
+	prefix: "🚀",
+	name: "base256emoji",
+	encode: encode$1,
+	decode
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base64.js
+var base64_exports = /* @__PURE__ */ __exportAll({
+	base64: () => base64,
+	base64pad: () => base64pad,
+	base64url: () => base64url,
+	base64urlpad: () => base64urlpad
+});
+const base64 = rfc4648({
+	prefix: "m",
+	name: "base64",
+	alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+	bitsPerChar: 6
+});
+const base64pad = rfc4648({
+	prefix: "M",
+	name: "base64pad",
+	alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+	bitsPerChar: 6
+});
+const base64url = rfc4648({
+	prefix: "u",
+	name: "base64url",
+	alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+	bitsPerChar: 6
+});
+const base64urlpad = rfc4648({
+	prefix: "U",
+	name: "base64urlpad",
+	alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=",
+	bitsPerChar: 6
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/base8.js
+var base8_exports = /* @__PURE__ */ __exportAll({ base8: () => base8 });
+const base8 = rfc4648({
+	prefix: "7",
+	name: "base8",
+	alphabet: "01234567",
+	bitsPerChar: 3
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/bases/identity.js
+var identity_exports$1 = /* @__PURE__ */ __exportAll({ identity: () => identity$1 });
+const identity$1 = from$1({
+	prefix: "\0",
+	name: "identity",
+	encode: (buf) => toString(buf),
+	decode: (str) => fromString$1(str)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/codecs/json.js
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/hashes/identity.js
+var identity_exports = /* @__PURE__ */ __exportAll({ identity: () => identity });
+const code = 0;
+const name = "identity";
+const encode = coerce;
+function digest(input, options) {
+	if (options?.truncate != null && options.truncate !== input.byteLength) {
+		if (options.truncate < 0 || options.truncate > input.byteLength) throw new Error(`Invalid truncate option, must be less than or equal to ${input.byteLength}`);
+		input = input.subarray(0, options.truncate);
+	}
+	return create(code, encode(input));
+}
+const identity = {
+	code,
+	name,
+	encode,
+	digest
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/multiformats@13.4.2/node_modules/multiformats/dist/src/basics.js
+const bases = {
+	...identity_exports$1,
+	...base2_exports,
+	...base8_exports,
+	...base10_exports,
+	...base16_exports,
+	...base32_exports,
+	...base36_exports,
+	...base58_exports,
+	...base64_exports,
+	...base256emoji_exports
+};
+const hashes = {
+	...sha2_exports,
+	...identity_exports
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/uint8arrays@5.1.0/node_modules/uint8arrays/dist/src/util/bases.js
+function createCodec$1(name, prefix, encode, decode) {
+	return {
+		name,
+		prefix,
+		encoder: {
+			name,
+			prefix,
+			encode
+		},
+		decoder: { decode }
+	};
+}
+const string = createCodec$1("utf8", "u", (buf) => {
+	return "u" + new TextDecoder("utf8").decode(buf);
+}, (str) => {
+	return new TextEncoder().encode(str.substring(1));
+});
+const ascii = createCodec$1("ascii", "a", (buf) => {
+	let string = "a";
+	for (let i = 0; i < buf.length; i++) string += String.fromCharCode(buf[i]);
+	return string;
+}, (str) => {
+	str = str.substring(1);
+	const buf = allocUnsafe(str.length);
+	for (let i = 0; i < str.length; i++) buf[i] = str.charCodeAt(i);
+	return buf;
+});
+const BASES = {
+	utf8: string,
+	"utf-8": string,
+	hex: bases.base16,
+	latin1: ascii,
+	ascii,
+	binary: ascii,
+	...bases
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/uint8arrays@5.1.0/node_modules/uint8arrays/dist/src/from-string.node.js
+/**
+* Create a `Uint8Array` from the passed string
+*
+* Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.
+*
+* Also `ascii` which is similar to node's 'binary' encoding.
+*/
+function fromString(string, encoding = "utf8") {
+	const base = BASES[encoding];
+	if (base == null) throw new Error(`Unsupported encoding "${encoding}"`);
+	if (encoding === "utf8" || encoding === "utf-8") return asUint8Array(Buffer$1.from(string, "utf-8"));
+	return base.decoder.decode(`${base.prefix}${string}`);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/utils/pool.js
+/**
+* A general purpose buffer pool
+*/
+function pool(size) {
+	const SIZE = size ?? 8192;
+	const MAX = SIZE >>> 1;
+	let slab;
+	let offset = SIZE;
+	return function poolAlloc(size) {
+		if (size < 1 || size > MAX) return allocUnsafe(size);
+		if (offset + size > SIZE) {
+			slab = allocUnsafe(SIZE);
+			offset = 0;
+		}
+		const buf = slab.subarray(offset, offset += size);
+		if ((offset & 7) !== 0) offset = (offset | 7) + 1;
+		return buf;
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/utils/writer.js
+/**
+* Constructs a new writer operation instance.
+*
+* @classdesc Scheduled writer operation
+*/
+var Op = class {
+	/**
+	* Function to call
+	*/
+	fn;
+	/**
+	* Value byte length
+	*/
+	len;
+	/**
+	* Next operation
+	*/
+	next;
+	/**
+	* Value to write
+	*/
+	val;
+	constructor(fn, len, val) {
+		this.fn = fn;
+		this.len = len;
+		this.next = void 0;
+		this.val = val;
+	}
+};
+/* istanbul ignore next */
+function noop() {}
+/**
+* Constructs a new writer state instance
+*/
+var State = class {
+	/**
+	* Current head
+	*/
+	head;
+	/**
+	* Current tail
+	*/
+	tail;
+	/**
+	* Current buffer length
+	*/
+	len;
+	/**
+	* Next state
+	*/
+	next;
+	constructor(writer) {
+		this.head = writer.head;
+		this.tail = writer.tail;
+		this.len = writer.len;
+		this.next = writer.states;
+	}
+};
+const bufferPool = pool();
+/**
+* Allocates a buffer of the specified size
+*/
+function alloc(size) {
+	if (globalThis.Buffer != null) return allocUnsafe(size);
+	return bufferPool(size);
+}
+/**
+* When a value is written, the writer calculates its byte length and puts it into a linked
+* list of operations to perform when finish() is called. This both allows us to allocate
+* buffers of the exact required size and reduces the amount of work we have to do compared
+* to first calculating over objects and then encoding over objects. In our case, the encoding
+* part is just a linked list walk calling operations with already prepared values.
+*/
+var Uint8ArrayWriter = class {
+	/**
+	* Current length
+	*/
+	len;
+	/**
+	* Operations head
+	*/
+	head;
+	/**
+	* Operations tail
+	*/
+	tail;
+	/**
+	* Linked forked states
+	*/
+	states;
+	constructor() {
+		this.len = 0;
+		this.head = new Op(noop, 0, 0);
+		this.tail = this.head;
+		this.states = null;
+	}
+	/**
+	* Pushes a new operation to the queue
+	*/
+	_push(fn, len, val) {
+		this.tail = this.tail.next = new Op(fn, len, val);
+		this.len += len;
+		return this;
+	}
+	/**
+	* Writes an unsigned 32 bit value as a varint
+	*/
+	uint32(value) {
+		this.len += (this.tail = this.tail.next = new VarintOp((value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5, value)).len;
+		return this;
+	}
+	/**
+	* Writes a signed 32 bit value as a varint`
+	*/
+	int32(value) {
+		return value < 0 ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) : this.uint32(value);
+	}
+	/**
+	* Writes a 32 bit value as a varint, zig-zag encoded
+	*/
+	sint32(value) {
+		return this.uint32((value << 1 ^ value >> 31) >>> 0);
+	}
+	/**
+	* Writes an unsigned 64 bit value as a varint
+	*/
+	uint64(value) {
+		const bits = LongBits.fromBigInt(value);
+		return this._push(writeVarint64, bits.length(), bits);
+	}
+	/**
+	* Writes an unsigned 64 bit value as a varint
+	*/
+	uint64Number(value) {
+		return this._push(encodeUint8Array, encodingLength(value), value);
+	}
+	/**
+	* Writes an unsigned 64 bit value as a varint
+	*/
+	uint64String(value) {
+		return this.uint64(BigInt(value));
+	}
+	/**
+	* Writes a signed 64 bit value as a varint
+	*/
+	int64(value) {
+		return this.uint64(value);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint
+	*/
+	int64Number(value) {
+		return this.uint64Number(value);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint
+	*/
+	int64String(value) {
+		return this.uint64String(value);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint, zig-zag encoded
+	*/
+	sint64(value) {
+		const bits = LongBits.fromBigInt(value).zzEncode();
+		return this._push(writeVarint64, bits.length(), bits);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint, zig-zag encoded
+	*/
+	sint64Number(value) {
+		const bits = LongBits.fromNumber(value).zzEncode();
+		return this._push(writeVarint64, bits.length(), bits);
+	}
+	/**
+	* Writes a signed 64 bit value as a varint, zig-zag encoded
+	*/
+	sint64String(value) {
+		return this.sint64(BigInt(value));
+	}
+	/**
+	* Writes a boolish value as a varint
+	*/
+	bool(value) {
+		return this._push(writeByte, 1, value ? 1 : 0);
+	}
+	/**
+	* Writes an unsigned 32 bit value as fixed 32 bits
+	*/
+	fixed32(value) {
+		return this._push(writeFixed32, 4, value >>> 0);
+	}
+	/**
+	* Writes a signed 32 bit value as fixed 32 bits
+	*/
+	sfixed32(value) {
+		return this.fixed32(value);
+	}
+	/**
+	* Writes an unsigned 64 bit value as fixed 64 bits
+	*/
+	fixed64(value) {
+		const bits = LongBits.fromBigInt(value);
+		return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+	}
+	/**
+	* Writes an unsigned 64 bit value as fixed 64 bits
+	*/
+	fixed64Number(value) {
+		const bits = LongBits.fromNumber(value);
+		return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);
+	}
+	/**
+	* Writes an unsigned 64 bit value as fixed 64 bits
+	*/
+	fixed64String(value) {
+		return this.fixed64(BigInt(value));
+	}
+	/**
+	* Writes a signed 64 bit value as fixed 64 bits
+	*/
+	sfixed64(value) {
+		return this.fixed64(value);
+	}
+	/**
+	* Writes a signed 64 bit value as fixed 64 bits
+	*/
+	sfixed64Number(value) {
+		return this.fixed64Number(value);
+	}
+	/**
+	* Writes a signed 64 bit value as fixed 64 bits
+	*/
+	sfixed64String(value) {
+		return this.fixed64String(value);
+	}
+	/**
+	* Writes a float (32 bit)
+	*/
+	float(value) {
+		return this._push(writeFloatLE, 4, value);
+	}
+	/**
+	* Writes a double (64 bit float).
+	*
+	* @function
+	* @param {number} value - Value to write
+	* @returns {Writer} `this`
+	*/
+	double(value) {
+		return this._push(writeDoubleLE, 8, value);
+	}
+	/**
+	* Writes a sequence of bytes
+	*/
+	bytes(value) {
+		const len = value.length >>> 0;
+		if (len === 0) return this._push(writeByte, 1, 0);
+		return this.uint32(len)._push(writeBytes, len, value);
+	}
+	/**
+	* Writes a string
+	*/
+	string(value) {
+		const len = length(value);
+		return len !== 0 ? this.uint32(len)._push(write, len, value) : this._push(writeByte, 1, 0);
+	}
+	/**
+	* Forks this writer's state by pushing it to a stack.
+	* Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.
+	*/
+	fork() {
+		this.states = new State(this);
+		this.head = this.tail = new Op(noop, 0, 0);
+		this.len = 0;
+		return this;
+	}
+	/**
+	* Resets this instance to the last state
+	*/
+	reset() {
+		if (this.states != null) {
+			this.head = this.states.head;
+			this.tail = this.states.tail;
+			this.len = this.states.len;
+			this.states = this.states.next;
+		} else {
+			this.head = this.tail = new Op(noop, 0, 0);
+			this.len = 0;
+		}
+		return this;
+	}
+	/**
+	* Resets to the last state and appends the fork state's current write length as a varint followed by its operations.
+	*/
+	ldelim() {
+		const head = this.head;
+		const tail = this.tail;
+		const len = this.len;
+		this.reset().uint32(len);
+		if (len !== 0) {
+			this.tail.next = head.next;
+			this.tail = tail;
+			this.len += len;
+		}
+		return this;
+	}
+	/**
+	* Finishes the write operation
+	*/
+	finish() {
+		let head = this.head.next;
+		const buf = alloc(this.len);
+		let pos = 0;
+		while (head != null) {
+			head.fn(head.val, buf, pos);
+			pos += head.len;
+			head = head.next;
+		}
+		return buf;
+	}
+};
+function writeByte(val, buf, pos) {
+	buf[pos] = val & 255;
+}
+function writeVarint32(val, buf, pos) {
+	while (val > 127) {
+		buf[pos++] = val & 127 | 128;
+		val >>>= 7;
+	}
+	buf[pos] = val;
+}
+/**
+* Constructs a new varint writer operation instance.
+*
+* @classdesc Scheduled varint writer operation
+*/
+var VarintOp = class extends Op {
+	next;
+	constructor(len, val) {
+		super(writeVarint32, len, val);
+		this.next = void 0;
+	}
+};
+function writeVarint64(val, buf, pos) {
+	while (val.hi !== 0) {
+		buf[pos++] = val.lo & 127 | 128;
+		val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
+		val.hi >>>= 7;
+	}
+	while (val.lo > 127) {
+		buf[pos++] = val.lo & 127 | 128;
+		val.lo = val.lo >>> 7;
+	}
+	buf[pos++] = val.lo;
+}
+function writeFixed32(val, buf, pos) {
+	buf[pos] = val & 255;
+	buf[pos + 1] = val >>> 8 & 255;
+	buf[pos + 2] = val >>> 16 & 255;
+	buf[pos + 3] = val >>> 24;
+}
+function writeBytes(val, buf, pos) {
+	buf.set(val, pos);
+}
+if (globalThis.Buffer != null) {
+	Uint8ArrayWriter.prototype.bytes = function(value) {
+		const len = value.length >>> 0;
+		this.uint32(len);
+		if (len > 0) this._push(writeBytesBuffer, len, value);
+		return this;
+	};
+	Uint8ArrayWriter.prototype.string = function(value) {
+		const len = globalThis.Buffer.byteLength(value);
+		this.uint32(len);
+		if (len > 0) this._push(writeStringBuffer, len, value);
+		return this;
+	};
+}
+function writeBytesBuffer(val, buf, pos) {
+	buf.set(val, pos);
+}
+function writeStringBuffer(val, buf, pos) {
+	if (val.length < 40) write(val, buf, pos);
+	else if (buf.utf8Write != null) buf.utf8Write(val, pos);
+	else buf.set(fromString(val), pos);
+}
+/**
+* Creates a new writer
+*/
+function createWriter() {
+	return new Uint8ArrayWriter();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/encode.js
+function encodeMessage(message, codec) {
+	const w = createWriter();
+	codec.encode(message, w, { lengthDelimited: false });
+	return w.finish();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/codec.js
+var CODEC_TYPES;
+(function(CODEC_TYPES) {
+	CODEC_TYPES[CODEC_TYPES["VARINT"] = 0] = "VARINT";
+	CODEC_TYPES[CODEC_TYPES["BIT64"] = 1] = "BIT64";
+	CODEC_TYPES[CODEC_TYPES["LENGTH_DELIMITED"] = 2] = "LENGTH_DELIMITED";
+	CODEC_TYPES[CODEC_TYPES["START_GROUP"] = 3] = "START_GROUP";
+	CODEC_TYPES[CODEC_TYPES["END_GROUP"] = 4] = "END_GROUP";
+	CODEC_TYPES[CODEC_TYPES["BIT32"] = 5] = "BIT32";
+})(CODEC_TYPES || (CODEC_TYPES = {}));
+function createCodec(name, type, encode, decode) {
+	return {
+		name,
+		type,
+		encode,
+		decode
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/codecs/enum.js
+function enumeration(v) {
+	function findValue(val) {
+		if (v[val.toString()] == null) throw new Error("Invalid enum value");
+		return v[val];
+	}
+	return createCodec("enum", CODEC_TYPES.VARINT, function enumEncode(val, writer) {
+		const enumValue = findValue(val);
+		writer.int32(enumValue);
+	}, function enumDecode(reader) {
+		return findValue(reader.int32());
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/protons-runtime@5.5.0/node_modules/protons-runtime/dist/src/codecs/message.js
+function message(encode, decode) {
+	return createCodec("message", CODEC_TYPES.LENGTH_DELIMITED, encode, decode);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/ipfs-unixfs@12.0.0/node_modules/ipfs-unixfs/dist/src/unixfs.js
+var Data;
+(function(Data) {
+	(function(DataType) {
+		DataType["Raw"] = "Raw";
+		DataType["Directory"] = "Directory";
+		DataType["File"] = "File";
+		DataType["Metadata"] = "Metadata";
+		DataType["Symlink"] = "Symlink";
+		DataType["HAMTShard"] = "HAMTShard";
+	})(Data.DataType || (Data.DataType = {}));
+	let __DataTypeValues;
+	(function(__DataTypeValues) {
+		__DataTypeValues[__DataTypeValues["Raw"] = 0] = "Raw";
+		__DataTypeValues[__DataTypeValues["Directory"] = 1] = "Directory";
+		__DataTypeValues[__DataTypeValues["File"] = 2] = "File";
+		__DataTypeValues[__DataTypeValues["Metadata"] = 3] = "Metadata";
+		__DataTypeValues[__DataTypeValues["Symlink"] = 4] = "Symlink";
+		__DataTypeValues[__DataTypeValues["HAMTShard"] = 5] = "HAMTShard";
+	})(__DataTypeValues || (__DataTypeValues = {}));
+	(function(DataType) {
+		DataType.codec = () => {
+			return enumeration(__DataTypeValues);
+		};
+	})(Data.DataType || (Data.DataType = {}));
+	let _codec;
+	Data.codec = () => {
+		if (_codec == null) _codec = message((obj, w, opts = {}) => {
+			if (opts.lengthDelimited !== false) w.fork();
+			if (obj.Type != null) {
+				w.uint32(8);
+				Data.DataType.codec().encode(obj.Type, w);
+			}
+			if (obj.Data != null) {
+				w.uint32(18);
+				w.bytes(obj.Data);
+			}
+			if (obj.filesize != null) {
+				w.uint32(24);
+				w.uint64(obj.filesize);
+			}
+			if (obj.blocksizes != null) for (const value of obj.blocksizes) {
+				w.uint32(32);
+				w.uint64(value);
+			}
+			if (obj.hashType != null) {
+				w.uint32(40);
+				w.uint64(obj.hashType);
+			}
+			if (obj.fanout != null) {
+				w.uint32(48);
+				w.uint64(obj.fanout);
+			}
+			if (obj.mode != null) {
+				w.uint32(56);
+				w.uint32(obj.mode);
+			}
+			if (obj.mtime != null) {
+				w.uint32(66);
+				UnixTime.codec().encode(obj.mtime, w);
+			}
+			if (opts.lengthDelimited !== false) w.ldelim();
+		}, (reader, length) => {
+			const obj = { blocksizes: [] };
+			const end = length == null ? reader.len : reader.pos + length;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				switch (tag >>> 3) {
+					case 1:
+						obj.Type = Data.DataType.codec().decode(reader);
+						break;
+					case 2:
+						obj.Data = reader.bytes();
+						break;
+					case 3:
+						obj.filesize = reader.uint64();
+						break;
+					case 4:
+						obj.blocksizes.push(reader.uint64());
+						break;
+					case 5:
+						obj.hashType = reader.uint64();
+						break;
+					case 6:
+						obj.fanout = reader.uint64();
+						break;
+					case 7:
+						obj.mode = reader.uint32();
+						break;
+					case 8:
+						obj.mtime = UnixTime.codec().decode(reader, reader.uint32());
+						break;
+					default:
+						reader.skipType(tag & 7);
+						break;
+				}
+			}
+			return obj;
+		});
+		return _codec;
+	};
+	Data.encode = (obj) => {
+		return encodeMessage(obj, Data.codec());
+	};
+	Data.decode = (buf) => {
+		return decodeMessage(buf, Data.codec());
+	};
+})(Data || (Data = {}));
+var UnixTime;
+(function(UnixTime) {
+	let _codec;
+	UnixTime.codec = () => {
+		if (_codec == null) _codec = message((obj, w, opts = {}) => {
+			if (opts.lengthDelimited !== false) w.fork();
+			if (obj.Seconds != null) {
+				w.uint32(8);
+				w.int64(obj.Seconds);
+			}
+			if (obj.FractionalNanoseconds != null) {
+				w.uint32(21);
+				w.fixed32(obj.FractionalNanoseconds);
+			}
+			if (opts.lengthDelimited !== false) w.ldelim();
+		}, (reader, length) => {
+			const obj = {};
+			const end = length == null ? reader.len : reader.pos + length;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				switch (tag >>> 3) {
+					case 1:
+						obj.Seconds = reader.int64();
+						break;
+					case 2:
+						obj.FractionalNanoseconds = reader.fixed32();
+						break;
+					default:
+						reader.skipType(tag & 7);
+						break;
+				}
+			}
+			return obj;
+		});
+		return _codec;
+	};
+	UnixTime.encode = (obj) => {
+		return encodeMessage(obj, UnixTime.codec());
+	};
+	UnixTime.decode = (buf) => {
+		return decodeMessage(buf, UnixTime.codec());
+	};
+})(UnixTime || (UnixTime = {}));
+var Metadata;
+(function(Metadata) {
+	let _codec;
+	Metadata.codec = () => {
+		if (_codec == null) _codec = message((obj, w, opts = {}) => {
+			if (opts.lengthDelimited !== false) w.fork();
+			if (obj.MimeType != null) {
+				w.uint32(10);
+				w.string(obj.MimeType);
+			}
+			if (opts.lengthDelimited !== false) w.ldelim();
+		}, (reader, length) => {
+			const obj = {};
+			const end = length == null ? reader.len : reader.pos + length;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				switch (tag >>> 3) {
+					case 1:
+						obj.MimeType = reader.string();
+						break;
+					default:
+						reader.skipType(tag & 7);
+						break;
+				}
+			}
+			return obj;
+		});
+		return _codec;
+	};
+	Metadata.encode = (obj) => {
+		return encodeMessage(obj, Metadata.codec());
+	};
+	Metadata.decode = (buf) => {
+		return decodeMessage(buf, Metadata.codec());
+	};
+})(Metadata || (Metadata = {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/ipfs-unixfs@12.0.0/node_modules/ipfs-unixfs/dist/src/index.js
+/**
+* @packageDocumentation
+*
+* This module contains the protobuf definition of the UnixFS data structure found at the root of all UnixFS DAGs.
+*
+* The UnixFS spec can be found in the [ipfs/specs repository](http://github.com/ipfs/specs)
+*
+* @example Create a file composed of several blocks
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+* data.addBlockSize(256n) // add the size of each block
+* data.addBlockSize(256n)
+* // ...
+* ```
+*
+* @example Create a directory that contains several files
+*
+* Creating a directory that contains several files is achieve by creating a unixfs element that identifies a MerkleDAG node as a directory. The links of that MerkleDAG node are the files that are contained in this directory.
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'directory' })
+* ```
+*
+* @example Create an unixfs Data element
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({
+*   // ...options
+* })
+* ```
+*
+* `options` is an optional object argument that might include the following keys:
+*
+* - type (string, default `file`): The type of UnixFS entry.  Can be:
+*   - `raw`
+*   - `directory`
+*   - `file`
+*   - `metadata`
+*   - `symlink`
+*   - `hamt-sharded-directory`
+* - data (Uint8Array): The optional data field for this node
+* - blockSizes (Array, default: `[]`): If this is a `file` node that is made up of multiple blocks, `blockSizes` is a list numbers that represent the size of the file chunks stored in each child node. It is used to calculate the total file size.
+* - mode (Number, default `0644` for files, `0755` for directories/hamt-sharded-directories) file mode
+* - mtime (`Date`, `{ secs, nsecs }`, `{ Seconds, FractionalNanoseconds }`, `[ secs, nsecs ]`): The modification time of this node
+*
+* @example Add and remove a block size to the block size list
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+* const sizeInBytes = 100n
+* data.addBlockSize(sizeInBytes)
+* ```
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+*
+* const index = 0
+* data.removeBlockSize(index)
+* ```
+*
+* @example Get total fileSize
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+* data.fileSize() // => size in bytes
+* ```
+*
+* @example Marshal and unmarshal
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const data = new UnixFS({ type: 'file' })
+* const marshaled = data.marshal()
+* const unmarshaled = UnixFS.unmarshal(marshaled)
+* ```
+*
+* @example Is this UnixFS entry a directory?
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const dir = new UnixFS({ type: 'directory' })
+* dir.isDirectory() // true
+*
+* const file = new UnixFS({ type: 'file' })
+* file.isDirectory() // false
+* ```
+*
+* @example Has an mtime been set?
+*
+* If no modification time has been set, no `mtime` property will be present on the `Data` instance:
+*
+* ```TypeScript
+* import { UnixFS } from 'ipfs-unixfs'
+*
+* const file = new UnixFS({ type: 'file' })
+* file.mtime // undefined
+*
+* Object.prototype.hasOwnProperty.call(file, 'mtime') // false
+*
+* const dir = new UnixFS({ type: 'directory', mtime: { secs: 5n } })
+* dir.mtime // { secs: Number, nsecs: Number }
+* ```
+*/
+const types = {
+	Raw: "raw",
+	Directory: "directory",
+	File: "file",
+	Metadata: "metadata",
+	Symlink: "symlink",
+	HAMTShard: "hamt-sharded-directory"
+};
+const dirTypes = ["directory", "hamt-sharded-directory"];
+const DEFAULT_FILE_MODE = parseInt("0644", 8);
+const DEFAULT_DIRECTORY_MODE = parseInt("0755", 8);
+const MAX_FANOUT = BigInt(1024);
+var UnixFS = class UnixFS {
+	/**
+	* Decode from protobuf https://github.com/ipfs/specs/blob/master/UNIXFS.md
+	*/
+	static unmarshal(marshaled) {
+		const message = Data.decode(marshaled);
+		if (message.fanout != null && message.fanout > MAX_FANOUT) throw new InvalidUnixFSMessageError(`Fanout size was too large - ${message.fanout} > ${MAX_FANOUT}`);
+		const data = new UnixFS({
+			type: types[message.Type != null ? message.Type.toString() : "File"],
+			data: message.Data,
+			blockSizes: message.blocksizes,
+			mode: message.mode,
+			mtime: message.mtime != null ? {
+				secs: message.mtime.Seconds ?? 0n,
+				nsecs: message.mtime.FractionalNanoseconds
+			} : void 0,
+			fanout: message.fanout
+		});
+		data._originalMode = message.mode ?? 0;
+		return data;
+	}
+	type;
+	data;
+	blockSizes;
+	hashType;
+	fanout;
+	mtime;
+	_mode;
+	_originalMode;
+	constructor(options = { type: "file" }) {
+		const { type, data, blockSizes, hashType, fanout, mtime, mode } = options;
+		if (type != null && !Object.values(types).includes(type)) throw new InvalidTypeError("Type: " + type + " is not valid");
+		this.type = type ?? "file";
+		this.data = data;
+		this.hashType = hashType;
+		this.fanout = fanout;
+		this.blockSizes = blockSizes ?? [];
+		this._originalMode = 0;
+		this.mode = mode;
+		this.mtime = mtime;
+	}
+	set mode(mode) {
+		if (mode == null) this._mode = this.isDirectory() ? DEFAULT_DIRECTORY_MODE : DEFAULT_FILE_MODE;
+		else this._mode = mode & 4095;
+	}
+	get mode() {
+		return this._mode;
+	}
+	isDirectory() {
+		return dirTypes.includes(this.type);
+	}
+	addBlockSize(size) {
+		this.blockSizes.push(size);
+	}
+	removeBlockSize(index) {
+		this.blockSizes.splice(index, 1);
+	}
+	/**
+	* Returns `0n` for directories or `data.length + sum(blockSizes)` for everything else
+	*/
+	fileSize() {
+		if (this.isDirectory()) return 0n;
+		let sum = 0n;
+		this.blockSizes.forEach((size) => {
+			sum += size;
+		});
+		if (this.data != null) sum += BigInt(this.data.length);
+		return sum;
+	}
+	/**
+	* encode to protobuf Uint8Array
+	*/
+	marshal() {
+		let type;
+		switch (this.type) {
+			case "raw":
+				type = Data.DataType.Raw;
+				break;
+			case "directory":
+				type = Data.DataType.Directory;
+				break;
+			case "file":
+				type = Data.DataType.File;
+				break;
+			case "metadata":
+				type = Data.DataType.Metadata;
+				break;
+			case "symlink":
+				type = Data.DataType.Symlink;
+				break;
+			case "hamt-sharded-directory":
+				type = Data.DataType.HAMTShard;
+				break;
+			default: throw new InvalidTypeError(`Type: ${type} is not valid`);
+		}
+		let data = this.data;
+		if (this.data == null || this.data.length === 0) data = void 0;
+		let mode;
+		if (this.mode != null) {
+			mode = this._originalMode & 4294963200 | (this.mode ?? 0);
+			if (mode === DEFAULT_FILE_MODE && !this.isDirectory()) mode = void 0;
+			if (mode === DEFAULT_DIRECTORY_MODE && this.isDirectory()) mode = void 0;
+		}
+		let mtime;
+		if (this.mtime != null) mtime = {
+			Seconds: this.mtime.secs,
+			FractionalNanoseconds: this.mtime.nsecs
+		};
+		return Data.encode({
+			Type: type,
+			Data: data,
+			filesize: this.isDirectory() ? void 0 : this.fileSize(),
+			blocksizes: this.blockSizes,
+			hashType: this.hashType,
+			fanout: this.fanout,
+			mode,
+			mtime
+		});
+	}
+};
+
+//#endregion
+//#region src/ecosystem/ipfs.ts
+/**
+* Generates an IPFS CIDv0 hash for the given content
+* @param content - String or Uint8Array to hash
+* @returns IPFS CIDv0 hash (starts with "Qm")
+*/
+async function hash(content) {
+	const unixfs = new UnixFS({
+		type: "file",
+		data: typeof content === "string" ? new TextEncoder().encode(content) : content
+	});
+	const block = encode$2({
+		Data: unixfs.marshal(),
+		Links: []
+	});
+	const hash = await sha256.digest(block);
+	return CID.createV0(hash).toString();
+}
+
+//#endregion
+export { Aip, ChainId, ChainList, EVENT_DB, HALF_RAY, HALF_WAD, HUMAN_READABLE_PAYLOAD_STATE, HUMAN_READABLE_PROPOSAL_STATE, IAToken_ABI, IAaveOracle_ABI, IAaveV3ConfigEngine_ABI, IAccessControl_ABI, IAggregatorInterface_ABI, ICLRatePriceCapAdapter_ABI, ICLSynchronicityPriceAdapterBaseToPeg_ABI, ICLSynchronicityPriceAdapterPegToBase_ABI, ICLSynchronicityPriceAdapter_ABI, ICollector_ABI, IDefaultInterestRateStrategyV2_ABI, IERC1967_ABI, IERC20Metadata_ABI, IERC20_ABI, IEmissionManager_ABI, IGovernance_ABI, IOwnable_ABI, IPausableUpgradeable_ABI, IPayloadsController_ABI, IPendlePriceCapAdapter_ABI, IPoolAddressesProvider_ABI, IPoolConfigurator_ABI, IPool_ABI, IPriceCapAdapterBase_ABI, IPriceCapAdapterStable_ABI, IReserveInterestRateStrategy_ABI, IRewardsController_ABI, ISafe_ABI, IStataTokenFactory_ABI, IStataTokenV2_ABI, IUmbrellaStakeToken_ABI, IUmbrella_ABI, IWithGuardian_ABI, IWrappedTokenGatewayV3_ABI, IncentivizedERC20_ABI, LTV_PRECISION, PayloadState, ProposalState, RAY, SECONDS_PER_YEAR, SelfdestructCheckState, SoltypeType, Umbrella_IRewardsController_ABI, Umbrella_IRewardsDistributor_ABI, VerificationStatus, WAD, WAD_RAY_RATIO, aaveAddressesProvider_IncentivesControllerSlot, addAssetPrice, addAssetSymbol, alchemyNetworkMap, alchemySupportedChainIds, assetIndexesToAsset, assetToBase, bitmapToIndexes, blockscoutExplorers, bytes32ToAddress, calculateAvailableBorrowsMarketReferenceCurrency, calculateCompoundedInterest, calculateHealthFactor, calculateHealthFactorFromBalances, calculateLinearInterest, chainlinkFeeds, checkForSelfdestruct, decodeReserveConfiguration, decodeReserveConfigurationV2, decodeUserConfiguration, diffCode, diffFoundryStorageLayout, enhanceLogs, enhanceStateDiff, erc1967_AdminSlot, erc1967_ImplementationSlot, etherscanExplorers, fetchImmutablePoolAddresses, fetchMutablePoolAddresses, fetchPoolAddresses, findAsset, flashbotsClientExtension, flashbotsOnFetchRequest, formatNumberString, foundry_format, foundry_getStandardJsonInput, foundry_getStorageLayout, genericIndexer, getAlchemyRPC, getBits, getBytesValue, getClient, getCompleteReserveConfiguration, getContractDeploymentBlock, getCurrentDebtBalance, getCurrentLiquidityBalance, getDynamicArraySlot, getExplicitRPC, getExplorer, getGovernance, getHyperRPC, getImplementationSlot, getLogsRecursive, getMarketReferenceCurrencyAndUsdBalance, getMdContractName, getNetworkEnv, getNonFinalizedPayloads, getNonFinalizedProposals, getNormalizedDebt, getNormalizedIncome, getObjectDiff, getPayloadStorageOverrides, getPayloadsController, getPublicRpc, getQuicknodeRpc, getRPCUrl, getReserveConfigurations, getReserveTokens, getSolidityStorageSlotAddress, getSolidityStorageSlotBytes, getSolidityStorageSlotUint, getSourceCode, getTenderlyRpc, getVerificationStatus, hash, hyperRPCSupportedNetworks, isPayloadFinal, isProposalFinal, makePayloadExecutableOnTestClient, makeProposalExecutableOnTestClient, onMevHandler, parseBlockscoutStyleSourceCode, parseEtherscanStyleSourceCode, parseFrontmatterMd, parseLogs, prettifyNumber, priceUpdateDecoder, publicRPCs, quicknodeNetworkMap, rayDiv, rayMul, rayToWad, renderMarkdownStateDiffReport, renderTenderlyReport, routescanExplorers, selfDestructStatusToString, setBits, snapshotClient, tenderlyExplorerMap, tenderlyNetworkMap, tenderly_createVnet, tenderly_deleteVnet, tenderly_getVnet, tenderly_logsToAbiLogs, tenderly_pingExplorer, tenderly_sim, tenderly_simVnet, toAddressLink, toBinaryString, toTxLink, transformTenderlyStateDiff, validateAip, verificationStatusToString, wadDiv, wadToRay };
 //# sourceMappingURL=index.mjs.map